diff --git a/src/intel/compiler/meson.build b/src/intel/compiler/meson.build index e89ba8093d3..cd5c43e247f 100644 --- a/src/intel/compiler/meson.build +++ b/src/intel/compiler/meson.build @@ -210,6 +210,8 @@ if with_tests files( 'test_eu_compact.cpp', 'test_eu_validate.cpp', + 'test_helpers.cpp', + 'test_helpers.h', 'test_lower_scoreboard.cpp', 'test_opt_cmod_propagation.cpp', 'test_opt_combine_constants.cpp', diff --git a/src/intel/compiler/test_helpers.cpp b/src/intel/compiler/test_helpers.cpp new file mode 100644 index 00000000000..bb776b32b52 --- /dev/null +++ b/src/intel/compiler/test_helpers.cpp @@ -0,0 +1,257 @@ +/* + * Copyright © 2025 Intel Corporation + * SPDX-License-Identifier: MIT + */ + +#include "test_helpers.h" +#include "brw_builder.h" + +std::string +brw_shader_to_string(brw_shader *s) +{ + if (!s->cfg) + brw_calculate_cfg(*s); + + char *str = NULL; + size_t size = 0; + + FILE *f = open_memstream(&str, &size); + brw_print_instructions(*s, f); + fclose(f); + + std::string result(str); + free(str); + return result; +} + +void +brw_reindex_vgrfs(brw_shader *s) +{ + struct Entry { + int new_nr; + int size; + bool valid; + }; + + unsigned next_nr = 0; + Entry *map = rzalloc_array(NULL, Entry, s->alloc.count); + + /* Build map and update references to VGRFs instructions as + * they are seen. First destination then sources. + */ + foreach_block_and_inst(block, brw_inst, inst, s->cfg) { + if (inst->dst.file == VGRF) { + Entry &entry = map[inst->dst.nr]; + if (!entry.valid) { + entry.new_nr = next_nr++; + entry.size = s->alloc.sizes[inst->dst.nr]; + entry.valid = true; + } + inst->dst.nr = entry.new_nr; + } + + for (int i = 0; i < inst->sources; i++) { + if (inst->src[i].file == VGRF) { + Entry &entry = map[inst->src[i].nr]; + if (!entry.valid) { + entry.new_nr = next_nr++; + entry.size = s->alloc.sizes[inst->src[i].nr]; + entry.valid = true; + } + inst->src[i].nr = entry.new_nr; + } + } + } + + /* Move unused entries to the end. */ + for (unsigned i = 0; i < s->alloc.count; i++) { + Entry &entry = map[i]; + if (!entry.valid) { + entry.new_nr = next_nr++; + entry.size = s->alloc.sizes[i]; + entry.valid = true; + } + } + + assert(next_nr == s->alloc.count); + + /* Update sizes. */ + for (unsigned i = 0; i < s->alloc.count; i++) + s->alloc.sizes[map[i].new_nr] = map[i].size; + + ralloc_free(map); + + s->invalidate_analysis(BRW_DEPENDENCY_VARIABLES); +} + +void +EXPECT_SHADERS_MATCH(brw_shader *a, brw_shader *b) +{ + if (!a->cfg) + brw_calculate_cfg(*a); + if (!b->cfg) + brw_calculate_cfg(*b); + + brw_validate(*a); + brw_validate(*b); + + brw_reindex_vgrfs(a); + brw_reindex_vgrfs(b); + + std::string sa = brw_shader_to_string(a); + std::string sb = brw_shader_to_string(b); + + EXPECT_EQ(sa, sb); +} + +class TestHelpers : public brw_shader_pass_test {}; + +TEST_F(TestHelpers, ReindexVGRFsDestinations) +{ + brw_builder bld = make_shader(); + + brw_reg d = bld.vgrf(BRW_TYPE_UD); + brw_reg c = bld.vgrf(BRW_TYPE_UD); + brw_reg b = bld.vgrf(BRW_TYPE_UD); + brw_reg a = bld.vgrf(BRW_TYPE_UD); + + brw_inst *mov_a = bld.MOV(a, brw_vec8_grf(0, 0)); + brw_inst *mov_b = bld.MOV(b, a); + brw_inst *mov_c = bld.MOV(c, b); + brw_inst *add_d = bld.ADD(d, a, b); + + EXPECT_EQ(mov_a->dst.nr, 3); + EXPECT_EQ(mov_b->dst.nr, 2); + EXPECT_EQ(mov_c->dst.nr, 1); + EXPECT_EQ(add_d->dst.nr, 0); + + brw_calculate_cfg(*bld.shader); + brw_reindex_vgrfs(bld.shader); + + EXPECT_EQ(mov_a->dst.nr, 0); + EXPECT_EQ(mov_b->dst.nr, 1); + EXPECT_EQ(mov_c->dst.nr, 2); + EXPECT_EQ(add_d->dst.nr, 3); +} + +TEST_F(TestHelpers, ReindexVGRFsSources) +{ + brw_builder bld = make_shader(); + + brw_reg d = bld.vgrf(BRW_TYPE_UD); + brw_reg c = bld.vgrf(BRW_TYPE_UD); + brw_reg b = bld.vgrf(BRW_TYPE_UD); + brw_reg a = bld.vgrf(BRW_TYPE_UD); + + brw_inst *mov_a = bld.MOV(brw_vec8_grf(0, 0), a); + brw_inst *mov_b = bld.MOV(brw_vec8_grf(7, 0), b); + brw_inst *add_cd = bld.ADD(brw_vec8_grf(14, 0), c, d); + + EXPECT_EQ(mov_a->src[0].nr, 3); + EXPECT_EQ(mov_b->src[0].nr, 2); + EXPECT_EQ(add_cd->src[0].nr, 1); + EXPECT_EQ(add_cd->src[1].nr, 0); + + brw_calculate_cfg(*bld.shader); + brw_reindex_vgrfs(bld.shader); + + EXPECT_EQ(mov_a->src[0].nr, 0); + EXPECT_EQ(mov_b->src[0].nr, 1); + EXPECT_EQ(add_cd->src[0].nr, 2); + EXPECT_EQ(add_cd->src[1].nr, 3); +} + +TEST_F(TestHelpers, ReindexVGRFsIncludesSizes) +{ + brw_builder bld = make_shader(); + + brw_reg d = bld.vgrf(BRW_TYPE_UD, 1); + brw_reg c = bld.vgrf(BRW_TYPE_UD, 6); + brw_reg b = bld.vgrf(BRW_TYPE_UD, 8); + brw_reg a = bld.vgrf(BRW_TYPE_UD, 2); + + brw_inst *mov_a = bld.MOV(a, brw_imm_d(2222)); + brw_inst *mov_b = bld.MOV(b, brw_imm_d(8888)); + brw_inst *mov_c = bld.MOV(c, brw_imm_d(6666)); + brw_inst *mov_d = bld.MOV(d, brw_imm_d(1111)); + + EXPECT_EQ(mov_a->dst.nr, 3); + EXPECT_EQ(mov_b->dst.nr, 2); + EXPECT_EQ(mov_c->dst.nr, 1); + EXPECT_EQ(mov_d->dst.nr, 0); + + brw_calculate_cfg(*bld.shader); + brw_reindex_vgrfs(bld.shader); + + EXPECT_EQ(mov_a->dst.nr, 0); + EXPECT_EQ(mov_b->dst.nr, 1); + EXPECT_EQ(mov_c->dst.nr, 2); + EXPECT_EQ(mov_d->dst.nr, 3); + + brw_shader *s = bld.shader; + EXPECT_EQ(s->alloc.count, 4); + EXPECT_EQ(s->alloc.sizes[0], 2); + EXPECT_EQ(s->alloc.sizes[1], 8); + EXPECT_EQ(s->alloc.sizes[2], 6); + EXPECT_EQ(s->alloc.sizes[3], 1); +} + +TEST_F(TestHelpers, ReindexVGRFsUnusedAreMovedToTheEnd) +{ + brw_builder bld = make_shader(); + + brw_reg a = bld.vgrf(BRW_TYPE_UD, 4); + UNUSED brw_reg b = bld.vgrf(BRW_TYPE_UD, 6); + brw_reg c = bld.vgrf(BRW_TYPE_UD, 8); + + brw_inst *add = bld.ADD(a, a, c); + + brw_calculate_cfg(*bld.shader); + brw_reindex_vgrfs(bld.shader); + + EXPECT_EQ(add->src[0].nr, 0); + EXPECT_EQ(add->src[1].nr, 1); + + brw_shader *s = bld.shader; + EXPECT_EQ(s->alloc.count, 3); + EXPECT_EQ(s->alloc.sizes[0], 4); + EXPECT_EQ(s->alloc.sizes[1], 8); + EXPECT_EQ(s->alloc.sizes[2], 6); +} + +TEST_F(TestHelpers, MatchShadersSameStructureDifferentNumbers) +{ + brw_builder a = make_shader(); + brw_builder b = make_shader(); + + int nr_from_a; + int nr_from_b; + + /* Build using the builder automatic allocations. */ + { + brw_inst *add = NULL; + + brw_reg src0 = a.MOV(brw_ud8_grf(1, 0)); + brw_reg src1 = a.MOV(brw_ud8_grf(7, 0)); + a.ADD(src0, src1, &add); + + EXPECT_EQ(add->dst.file, VGRF); + nr_from_a = add->dst.nr; + } + + /* Build using explicitly created VGRFs. */ + { + brw_reg dst = b.vgrf(BRW_TYPE_UD); + brw_reg src0 = b.vgrf(BRW_TYPE_UD); + brw_reg src1 = b.vgrf(BRW_TYPE_UD); + + b.MOV(src0, brw_ud8_grf(1, 0)); + b.MOV(src1, brw_ud8_grf(7, 0)); + b.ADD(dst, src0, src1); + + nr_from_b = dst.nr; + } + + EXPECT_NE(nr_from_a, nr_from_b); + EXPECT_SHADERS_MATCH(a, b); +} diff --git a/src/intel/compiler/test_helpers.h b/src/intel/compiler/test_helpers.h new file mode 100644 index 00000000000..05f5546ce4b --- /dev/null +++ b/src/intel/compiler/test_helpers.h @@ -0,0 +1,199 @@ +/* + * Copyright © 2025 Intel Corporation + * SPDX-License-Identifier: MIT + */ + +#pragma once + +#include +#include "brw_shader.h" +#include "brw_builder.h" + +#include +#include + +std::string brw_shader_to_string(brw_shader *s); + +void brw_reindex_vgrfs(brw_shader *s); + +/* Note: the order of instructions must be the same for shaders to match + * so be careful when using patterns like bld.ADD(bld.MOV(), bld.MOV()) + * in the tests since order of argument evaluation is unspecified. + */ +void EXPECT_SHADERS_MATCH(brw_shader *a, brw_shader *b); + +inline void +EXPECT_SHADERS_MATCH(brw_builder &a, brw_builder &b) +{ + EXPECT_SHADERS_MATCH(a.shader, b.shader); +} + +template +inline void +EXPECT_PROGRESS_RESULT(bool should_progress, PASS pass, brw_shader *s) +{ + if (!s->cfg) + brw_calculate_cfg(*s); + + brw_validate(*s); + + auto before = brw_shader_to_string(s); + bool progress = pass(*s); + auto after = brw_shader_to_string(s); + + brw_validate(*s); + + if (progress != should_progress || getenv("TEST_DEBUG")) { + fprintf(stderr, "= Before =\n" + "%s\n" + "\n" + "= After =\n" + "%s\n", + before.c_str(), + after.c_str()); + } + + EXPECT_EQ(progress, should_progress); + if (should_progress) + EXPECT_NE(before, after); + else + EXPECT_EQ(before, after); +} + +template +inline void +EXPECT_PROGRESS(PASS pass, brw_shader *s) +{ + EXPECT_PROGRESS_RESULT(true, pass, s); +} + +template +inline void +EXPECT_NO_PROGRESS(PASS pass, brw_shader *s) +{ + EXPECT_PROGRESS_RESULT(false, pass, s); +} + +template +inline void +EXPECT_PROGRESS_RESULT(bool should_progress, PASS pass, brw_builder &bld) +{ + EXPECT_PROGRESS_RESULT(should_progress, pass, bld.shader); +} + +template +inline void +EXPECT_PROGRESS(PASS pass, brw_builder &bld) +{ + EXPECT_PROGRESS(pass, bld.shader); +} + +template +inline void +EXPECT_NO_PROGRESS(PASS pass, brw_builder &bld) +{ + EXPECT_NO_PROGRESS(pass, bld.shader); +} + +class brw_shader_pass_test : public ::testing::Test { +protected: + void *mem_ctx; + struct brw_compiler *compiler; + struct intel_device_info *devinfo; + + /* TODO: Once brw_shader is ralloc-able, we can simply get rid of this. */ + std::vector> shaders; + + brw_shader_pass_test() + { + mem_ctx = ralloc_context(NULL); + compiler = rzalloc(mem_ctx, struct brw_compiler); + devinfo = rzalloc(mem_ctx, struct intel_device_info); + compiler->devinfo = devinfo; + + set_gfx_verx10(90); + } + + ~brw_shader_pass_test() override + { + ralloc_free(mem_ctx); + } + + void + set_gfx_verx10(unsigned verx10) + { + devinfo->verx10 = verx10; + devinfo->ver = verx10 / 10; + assert(devinfo->ver > 0); + brw_init_isa_info(&compiler->isa, devinfo); + } + + brw_builder + make_shader(gl_shader_stage stage = MESA_SHADER_FRAGMENT, + unsigned dispatch_width = 0) + { + if (dispatch_width == 0) + dispatch_width = devinfo->ver >= 20 ? 16 : 8; + + nir_shader *nir = nir_shader_create(mem_ctx, stage, NULL, NULL); + brw_stage_prog_data *pd = + (struct brw_stage_prog_data *)rzalloc(mem_ctx, brw_any_prog_data); + + brw_compile_params params = {}; + params.mem_ctx = mem_ctx; + + shaders.push_back(std::make_unique(compiler, ¶ms, nullptr, pd, nir, + dispatch_width, false, false)); + + brw_shader *s = shaders.back().get(); + s->phase = BRW_SHADER_PHASE_AFTER_OPT_LOOP; + return brw_builder(s); + } + + /* Helper to allocate same vgrf number in two shaders. */ + static brw_reg + vgrf(brw_shader *a, brw_shader *b, + brw_reg_type type, unsigned n = 1, + unsigned dispatch_width = 0) + { + assert(a && b && a->dispatch_width == b->dispatch_width); + + if (dispatch_width == 0) + dispatch_width = a->dispatch_width; + + brw_reg reg_a = brw_allocate_vgrf(*a, type, n * dispatch_width); + brw_reg reg_b = brw_allocate_vgrf(*b, type, n * dispatch_width); + assert(brw_regs_equal(®_a, ®_b)); + + return reg_a; + } + + static brw_reg + vgrf(brw_builder &a, brw_builder &b, + brw_reg_type type, unsigned n = 1, + unsigned dispatch_width = 0) + { + return vgrf(a.shader, b.shader, type, n, dispatch_width); + } + + static brw_reg + vgrf(brw_shader *a, + brw_reg_type type, unsigned n = 1, + unsigned dispatch_width = 0) + { + assert(a); + + if (dispatch_width == 0) + dispatch_width = a->dispatch_width; + + return brw_allocate_vgrf(*a, type, n * dispatch_width); + } + + static brw_reg + vgrf(brw_builder &a, + brw_reg_type type, unsigned n = 1, + unsigned dispatch_width = 0) + { + return vgrf(a.shader, type, n, dispatch_width); + } +}; diff --git a/src/intel/compiler/test_opt_cmod_propagation.cpp b/src/intel/compiler/test_opt_cmod_propagation.cpp index ba6c43fd878..f7e2011d545 100644 --- a/src/intel/compiler/test_opt_cmod_propagation.cpp +++ b/src/intel/compiler/test_opt_cmod_propagation.cpp @@ -1,45 +1,13 @@ /* * Copyright © 2015 Intel 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. + * SPDX-License-Identifier: MIT */ -#include -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -class cmod_propagation_test : public ::testing::Test { +class cmod_propagation_test : public brw_shader_pass_test { protected: - cmod_propagation_test(); - ~cmod_propagation_test() override; - - struct brw_compiler *compiler; - struct brw_compile_params params; - struct intel_device_info *devinfo; - void *ctx; - struct brw_wm_prog_data *prog_data; - struct gl_shader_program *shader_prog; - brw_shader *v; - brw_builder bld; - void test_mov_prop(enum brw_conditional_mod cmod, enum brw_reg_type add_type, enum brw_reg_type mov_dst_type, @@ -52,384 +20,181 @@ protected: bool expected_cmod_prop_progress); }; -cmod_propagation_test::cmod_propagation_test() -{ - ctx = ralloc_context(NULL); - compiler = rzalloc(ctx, struct brw_compiler); - devinfo = rzalloc(ctx, struct intel_device_info); - compiler->devinfo = devinfo; - - params = {}; - params.mem_ctx = ctx; - - prog_data = ralloc(ctx, struct brw_wm_prog_data); - nir_shader *shader = - nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL); - - v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader, - 8, false, false); - - bld = brw_builder(v); - - devinfo->ver = 9; - devinfo->verx10 = devinfo->ver * 10; -} - -cmod_propagation_test::~cmod_propagation_test() -{ - delete v; - v = NULL; - - ralloc_free(ctx); - ctx = NULL; -} - -static brw_inst * -instruction(bblock_t *block, int num) -{ - brw_inst *inst = (brw_inst *)block->start(); - for (int i = 0; i < num; i++) { - inst = (brw_inst *)inst->next; - } - return inst; -} - -static bool -cmod_propagation(brw_shader *v) -{ - const bool print = getenv("TEST_DEBUG"); - - if (print) { - fprintf(stderr, "= Before =\n"); - v->cfg->dump(); - } - - bool ret = brw_opt_cmod_propagation(*v); - - if (print) { - fprintf(stderr, "\n= After =\n"); - v->cfg->dump(); - } - - return ret; -} - TEST_F(cmod_propagation_test, basic) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), dest, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0(8) null dest 0.0f - * - * = After = - * 0: add.ge.f0(8) dest src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_GE; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, basic_other_flag) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), dest, zero, BRW_CONDITIONAL_GE) ->flag_subreg = 1; - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0.1(8) null dest 0.0f - * - * = After = - * 0: add.ge.f0.1(8) dest src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + brw_inst *add = exp.ADD(dest, src0, src1); + add->conditional_mod = BRW_CONDITIONAL_GE; + add->flag_subreg = 1; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(1, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_nonzero) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); brw_reg nonzero(brw_imm_f(1.0f)); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), dest, nonzero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0(8) null dest 1.0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, non_cmod_instruction) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_UD); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg zero(brw_imm_ud(0u)); + bld.FBL(dest, src0); bld.CMP(bld.null_reg_ud(), dest, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: fbl(8) dest src0 - * 1: cmp.ge.f0(8) null dest 0u - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_FBL, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, non_cmod_livechannel) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 32); + brw_reg dest = bld.vgrf(BRW_TYPE_UD); brw_reg zero(brw_imm_d(0)); - bld.emit(SHADER_OPCODE_FIND_LIVE_CHANNEL, dest)->exec_size = 32; - bld.CMP(bld.null_reg_d(), dest, zero, BRW_CONDITIONAL_Z)->exec_size = 32; - /* = Before = - * - * 0: find_live_channel(32) dest - * 1: cmp.z.f0.0(32) null dest 0d - * - * - * = After = - * (no changes) - */ + bld.emit(SHADER_OPCODE_FIND_LIVE_CHANNEL, dest); + bld.CMP(bld.null_reg_d(), dest, zero, BRW_CONDITIONAL_Z); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(SHADER_OPCODE_FIND_LIVE_CHANNEL, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, intervening_flag_write) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); brw_reg src2 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), src2, zero, BRW_CONDITIONAL_GE); bld.CMP(bld.null_reg_f(), dest, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0(8) null src2 0.0f - * 2: cmp.ge.f0(8) null dest 0.0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, intervening_mismatch_flag_write) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), src2, zero, BRW_CONDITIONAL_GE) ->flag_subreg = 1; bld.CMP(bld.null_reg_f(), dest, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0.1(8) null src2 0.0f - * 2: cmp.ge.f0(8) null dest 0.0f - * - * = After = - * 0: add.ge.f0(8) dest src0 src1 - * 1: cmp.ge.f0.1(8) null src2 0.0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_GE; + exp.CMP(bld.null_reg_f(), src2, zero, BRW_CONDITIONAL_GE) + ->flag_subreg = 1; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, intervening_flag_read) { + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_F); brw_reg dest1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); brw_reg src2 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); + bld.ADD(dest0, src0, src1); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)); bld.CMP(bld.null_reg_f(), dest0, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - * 2: cmp.ge.f0(8) null dest0 0.0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, intervening_mismatch_flag_read) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + bld.ADD(dest0, src0, src1); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)) ->flag_subreg = 1; bld.CMP(bld.null_reg_f(), dest0, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest0 src0 src1 - * 1: (+f0.1) sel(8) dest1 src2 0.0f - * 2: cmp.ge.f0(8) null dest0 0.0f - * - * = After = - * 0: add.ge.f0(8) dest0 src0 src1 - * 1: (+f0.1) sel(8) dest1 src2 0.0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest0, src0, src1)->conditional_mod = BRW_CONDITIONAL_GE; + set_predicate(BRW_PREDICATE_NORMAL, exp.SEL(dest1, src2, zero)) + ->flag_subreg = 1; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, intervening_dest_write) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F, 4); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); @@ -448,203 +213,112 @@ TEST_F(cmod_propagation_test, intervening_dest_write) ->size_written = 4 * REG_SIZE; bld.CMP(bld.null_reg_f(), offset(dest, bld, 2), zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest+2 src0 src1 - * 1: tex(8) rlen 4 dest+0 src2 - * 2: cmp.ge.f0(8) null dest+2 0.0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(SHADER_OPCODE_TEX_LOGICAL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, intervening_flag_read_same_value) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); - set_condmod(BRW_CONDITIONAL_GE, bld.ADD(dest0, src0, src1)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + + set_condmod(BRW_CONDITIONAL_GE, bld.ADD(dest0, src0, src1)); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)); bld.CMP(bld.null_reg_f(), dest0, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add.ge.f0(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - * 2: cmp.ge.f0(8) null dest0 0.0f - * - * = After = - * 0: add.ge.f0(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + set_condmod(BRW_CONDITIONAL_GE, exp.ADD(dest0, src0, src1)); + set_predicate(BRW_PREDICATE_NORMAL, exp.SEL(dest1, src2, zero)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, negate) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + bld.ADD(dest, src0, src1); - dest.negate = true; - bld.CMP(bld.null_reg_f(), dest, zero, BRW_CONDITIONAL_GE); + bld.CMP(bld.null_reg_f(), negate(dest), zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: cmp.ge.f0(8) null -dest 0.0f - * - * = After = - * 0: add.le.f0(8) dest src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_LE; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_LE, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, movnz) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + bld.CMP(dest, src0, src1, BRW_CONDITIONAL_GE); - set_condmod(BRW_CONDITIONAL_NZ, - bld.MOV(bld.null_reg_f(), dest)); + bld.MOV(bld.null_reg_f(), dest)->conditional_mod = BRW_CONDITIONAL_NZ; - /* = Before = - * - * 0: cmp.ge.f0(8) dest src0 src1 - * 1: mov.nz.f0(8) null dest - * - * = After = - * 0: cmp.ge.f0(8) dest src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(dest, src0, src1, BRW_CONDITIONAL_GE); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, different_types_cmod_with_zero) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_D); brw_reg src1 = bld.vgrf(BRW_TYPE_D); brw_reg zero(brw_imm_f(0.0f)); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), retype(dest, BRW_TYPE_F), zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest:D src0:D src1:D - * 1: cmp.ge.f0(8) null:F dest:F 0.0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, andnz_one) { - brw_reg dest = bld.vgrf(BRW_TYPE_D); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); - brw_reg one(brw_imm_d(1)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_D); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + brw_reg one = brw_imm_d(1); bld.CMP(retype(dest, BRW_TYPE_F), src0, zero, BRW_CONDITIONAL_L); - set_condmod(BRW_CONDITIONAL_NZ, - bld.AND(bld.null_reg_d(), dest, one)); + bld.AND(bld.null_reg_d(), dest, one)->conditional_mod = BRW_CONDITIONAL_NZ; - /* = Before = - * 0: cmp.l.f0(8) dest:F src0:F 0F - * 1: and.nz.f0(8) null:D dest:D 1D - * - * = After = - * 0: cmp.l.f0(8) dest:F src0:F 0F - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(retype(dest, BRW_TYPE_F), src0, zero, BRW_CONDITIONAL_L); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_TRUE(retype(dest, BRW_TYPE_F) - .equals(instruction(block0, 0)->dst)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, andnz_non_one) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); @@ -654,58 +328,32 @@ TEST_F(cmod_propagation_test, andnz_non_one) set_condmod(BRW_CONDITIONAL_NZ, bld.AND(bld.null_reg_d(), dest, nonone)); - /* = Before = - * 0: cmp.l.f0(8) dest:F src0:F 0F - * 1: and.nz.f0(8) null:D dest:D 38D - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, cmp_cmpnz) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0); bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_f(), dst0, zero, BRW_CONDITIONAL_NZ); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - * 1: cmp.nz.f0.0(8) null:F, vgrf0:F, 0f - * - * = After = - * 0: cmp.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_cmpg) { + brw_builder bld = make_shader(); + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0)); @@ -713,82 +361,51 @@ TEST_F(cmod_propagation_test, cmp_cmpg) bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_f(), dst0, zero, BRW_CONDITIONAL_G); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - * 1: cmp.g.f0.0(8) null:F, vgrf0:F, 0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_G, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, plnnz_cmpnz) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - set_condmod(BRW_CONDITIONAL_NZ, bld.PLN(dst0, src0, zero)); + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0); + + bld.PLN(dst0, src0, zero)->conditional_mod = BRW_CONDITIONAL_NZ; bld.CMP(bld.null_reg_f(), dst0, zero, BRW_CONDITIONAL_NZ); - /* = Before = - * 0: pln.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - * 1: cmp.nz.f0.0(8) null:F, vgrf0:F, 0f - * - * = After = - * 0: pln.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.PLN(dst0, src0, zero)->conditional_mod = BRW_CONDITIONAL_NZ; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_PLN, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, plnnz_cmpz) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - set_condmod(BRW_CONDITIONAL_NZ, bld.PLN(dst0, src0, zero)); + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0); + + bld.PLN(dst0, src0, zero)->conditional_mod = BRW_CONDITIONAL_NZ; bld.CMP(bld.null_reg_f(), dst0, zero, BRW_CONDITIONAL_Z); - /* = Before = - * 0: pln.nz.f0.0(8) vgrf0:F, vgrf1:F, 0f - * 1: cmp.z.f0.0(8) null:F, vgrf0:F, 0f - * - * = After = - * 0: pln.z.f0.0(8) vgrf0:F, vgrf1:F, 0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.PLN(dst0, src0, zero)->conditional_mod = BRW_CONDITIONAL_Z; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_PLN, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, plnnz_sel_cmpz) { + brw_builder bld = make_shader(); + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); @@ -798,31 +415,13 @@ TEST_F(cmod_propagation_test, plnnz_sel_cmpz) set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dst1, src0, zero)); bld.CMP(bld.null_reg_f(), dst0, zero, BRW_CONDITIONAL_Z); - /* = Before = - * 0: pln.nz.f0.0(8) vgrf0:F, vgrf2:F, 0f - * 1: (+f0.0) sel(8) vgrf1:F, vgrf2:F, 0f - * 2: cmp.z.f0.0(8) null:F, vgrf0:F, 0f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_PLN, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, cmp_cmpg_D) { + brw_builder bld = make_shader(); + brw_reg dst0 = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_D); brw_reg zero(brw_imm_d(0)); @@ -830,82 +429,53 @@ TEST_F(cmod_propagation_test, cmp_cmpg_D) bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_d(), dst0, zero, BRW_CONDITIONAL_G); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:D, vgrf1:D, 0d - * 1: cmp.g.f0.0(8) null:D, vgrf0:D, 0d - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_G, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } + + TEST_F(cmod_propagation_test, cmp_cmpg_UD) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg zero(brw_imm_ud(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg zero = brw_imm_ud(0); bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_ud(), dst0, zero, BRW_CONDITIONAL_G); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:UD, vgrf1:UD, 0u - * 1: cmp.g.f0.0(8) null:UD, vgrf0:UD, 0u - * - * = After = - * 0: cmp.nz.f0.0(8) vgrf0:UD, vgrf1:UD, 0u - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_cmpl_D) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_D); - brw_reg src0 = bld.vgrf(BRW_TYPE_D); - brw_reg zero(brw_imm_d(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_D); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_D); + brw_reg zero = brw_imm_d(0); bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_d(), dst0, zero, BRW_CONDITIONAL_L); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:D, vgrf1:D, 0d - * 1: cmp.l.f0.0(8) null:D, vgrf0:D, 0d - * - * = After = - * 0: cmp.nz.f0.0(8) vgrf0:D, vgrf1:D, 0d - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_cmpl_UD) { + brw_builder bld = make_shader(); + brw_reg dst0 = bld.vgrf(BRW_TYPE_UD); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg zero(brw_imm_ud(0)); @@ -913,28 +483,13 @@ TEST_F(cmod_propagation_test, cmp_cmpl_UD) bld.CMP(dst0, src0, zero, BRW_CONDITIONAL_NZ); bld.CMP(bld.null_reg_ud(), dst0, zero, BRW_CONDITIONAL_L); - /* = Before = - * 0: cmp.nz.f0.0(8) vgrf0:UD, vgrf1:UD, 0u - * 1: cmp.l.f0.0(8) null:UD, vgrf0:UD, 0u - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, andz_one) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); @@ -944,96 +499,51 @@ TEST_F(cmod_propagation_test, andz_one) set_condmod(BRW_CONDITIONAL_Z, bld.AND(bld.null_reg_d(), dest, one)); - /* = Before = - * 0: cmp.l.f0(8) dest:F src0:F 0F - * 1: and.z.f0(8) null:D dest:D 1D - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_EQ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, add_not_merge_with_compare) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); - /* The addition and the implicit subtraction in the compare do not compute - * related values. - * - * = Before = - * 0: add(8) dest:F src0:F src1:F - * 1: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * (no changes) - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, subtract_merge_with_compare) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + bld.ADD(dest, src0, negate(src1)); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); - /* = Before = - * 0: add(8) dest:F src0:F -src1:F - * 1: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * 0: add.l.f0(8) dest:F src0:F -src1:F - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.ADD(dest, src0, negate(src1))->conditional_mod = BRW_CONDITIONAL_L; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_immediate_merge_with_compare) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg one(brw_imm_f(1.0f)); - brw_reg negative_one(brw_imm_f(-1.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg one = brw_imm_f(1.0f); + brw_reg negative_one = brw_imm_f(-1.0f); bld.ADD(dest, src0, negative_one); bld.CMP(bld.null_reg_f(), src0, one, BRW_CONDITIONAL_NZ); @@ -1045,189 +555,118 @@ TEST_F(cmod_propagation_test, subtract_immediate_merge_with_compare) * = After = * 0: add.nz.f0(8) dest:F src0:F -1.0f */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.ADD(dest, src0, negative_one)->conditional_mod = BRW_CONDITIONAL_NZ; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_merge_with_compare_intervening_add) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + bld.ADD(dest0, src0, negate(src1)); bld.ADD(dest1, src0, src1); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); - /* = Before = - * 0: add(8) dest0:F src0:F -src1:F - * 1: add(8) dest1:F src0:F src1:F - * 2: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * 0: add.l.f0(8) dest0:F src0:F -src1:F - * 1: add(8) dest1:F src0:F src1:F - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + exp.ADD(dest0, src0, negate(src1))->conditional_mod = BRW_CONDITIONAL_L; + exp.ADD(dest1, src0, src1); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 1)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_not_merge_with_compare_intervening_partial_write) { + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_F); brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_reg src0 = bld.vgrf(BRW_TYPE_F); + brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.ADD(dest0, src0, negate(src1)); set_predicate(BRW_PREDICATE_NORMAL, bld.ADD(dest1, src0, negate(src1))); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); - /* = Before = - * 0: add(8) dest0:F src0:F -src1:F - * 1: (+f0) add(8) dest1:F src0:F -src1:F - * 2: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * (no changes) - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, subtract_not_merge_with_compare_intervening_add) { + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_F); brw_reg dest1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.ADD(dest0, src0, negate(src1)); set_condmod(BRW_CONDITIONAL_EQ, bld.ADD(dest1, src0, src1)); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); - /* = Before = - * 0: add(8) dest0:F src0:F -src1:F - * 1: add.z.f0(8) dest1:F src0:F src1:F - * 2: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * (no changes) - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_EQ, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, add_merge_with_compare) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + bld.ADD(dest, src0, src1); bld.CMP(bld.null_reg_f(), src0, negate(src1), BRW_CONDITIONAL_L); - /* = Before = - * 0: add(8) dest:F src0:F src1:F - * 1: cmp.l.f0(8) null:F src0:F -src1:F - * - * = After = - * 0: add.l.f0(8) dest:F src0:F src1:F - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.ADD(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_L; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, negative_subtract_merge_with_compare) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + bld.ADD(dest, src1, negate(src0)); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L); + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); + /* The result of the subtract is the negatiion of the result of the * implicit subtract in the compare, so the condition must change. - * - * = Before = - * 0: add(8) dest:F src1:F -src0:F - * 1: cmp.l.f0(8) null:F src0:F src1:F - * - * = After = - * 0: add.g.f0(8) dest:F src0:F -src1:F */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest, src1, negate(src0))->conditional_mod = BRW_CONDITIONAL_G; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_G, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_delete_compare) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); set_condmod(BRW_CONDITIONAL_L, bld.ADD(dest, src0, negate(src1))); set_predicate(BRW_PREDICATE_NORMAL, bld.MOV(dest1, src2)); @@ -1242,19 +681,12 @@ TEST_F(cmod_propagation_test, subtract_delete_compare) * 0: add.l.f0(8) dest:F src0:F -src1:F * 1: (+f0) mov(0) dest1:F src2:F */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + set_condmod(BRW_CONDITIONAL_L, exp.ADD(dest, src0, negate(src1))); + set_predicate(BRW_PREDICATE_NORMAL, exp.MOV(dest1, src2)); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_delete_compare_other_flag) @@ -1262,11 +694,14 @@ TEST_F(cmod_propagation_test, subtract_delete_compare_other_flag) /* This test is the same as subtract_delete_compare but it explicitly used * flag f0.1 for the subtraction and the comparison. */ - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); set_condmod(BRW_CONDITIONAL_L, bld.ADD(dest, src0, negate(src1))) ->flag_subreg = 1; @@ -1283,24 +718,19 @@ TEST_F(cmod_propagation_test, subtract_delete_compare_other_flag) * 0: add.l.f0.1(8) dest:F src0:F -src1:F * 1: (+f0) mov(0) dest1:F src2:F */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + set_condmod(BRW_CONDITIONAL_L, exp.ADD(dest, src0, negate(src1))) + ->flag_subreg = 1; + set_predicate(BRW_PREDICATE_NORMAL, exp.MOV(dest1, src2)); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_to_mismatch_flag) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); @@ -1309,36 +739,18 @@ TEST_F(cmod_propagation_test, subtract_to_mismatch_flag) bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L) ->flag_subreg = 1; - /* = Before = - * 0: add.l.f0(8) dest0:F src0:F -src1:F - * 1: cmp.l.f0.1(8) null:F src0:F src1:F - * - * = After = - * No changes - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, subtract_merge_with_compare_intervening_mismatch_flag_write) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); bld.ADD(dest0, src0, negate(src1)); bld.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L) @@ -1363,32 +775,27 @@ TEST_F(cmod_propagation_test, * Because of this, the cmp.l.f0 will always be chosen. If the pass * changes its strategy, this test will also need to change. */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + exp.ADD(dest0, src0, negate(src1))->conditional_mod = BRW_CONDITIONAL_L; + exp.CMP(bld.null_reg_f(), src0, src1, BRW_CONDITIONAL_L) + ->flag_subreg = 1; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_merge_with_compare_intervening_mismatch_flag_read) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); bld.ADD(dest0, src0, negate(src1)); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)) @@ -1404,29 +811,24 @@ TEST_F(cmod_propagation_test, * 0: add.l.f0(8) dest0:F src0:F -src1:F * 1: (+f0.1) sel(8) dest1 src2 0.0f */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + exp.ADD(dest0, src0, negate(src1))->conditional_mod = BRW_CONDITIONAL_L; + set_predicate(BRW_PREDICATE_NORMAL, exp.SEL(dest1, src2, zero)) + ->flag_subreg = 1; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, subtract_delete_compare_derp) { - brw_reg dest0 = bld.vgrf(BRW_TYPE_F); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); set_condmod(BRW_CONDITIONAL_L, bld.ADD(dest0, src0, negate(src1))); set_predicate(BRW_PREDICATE_NORMAL, bld.ADD(dest1, negate(src0), src1)); @@ -1441,23 +843,18 @@ TEST_F(cmod_propagation_test, subtract_delete_compare_derp) * 0: add.l.f0(8) dest0:F src0:F -src1:F * 1: (+f0) add(0) dest1:F -src0:F src1:F */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + set_condmod(BRW_CONDITIONAL_L, exp.ADD(dest0, src0, negate(src1))); + set_predicate(BRW_PREDICATE_NORMAL, exp.ADD(dest1, negate(src0), src1)); - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, signed_unsigned_comparison_mismatch) { + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_D); src0.type = BRW_TYPE_W; @@ -1466,29 +863,13 @@ TEST_F(cmod_propagation_test, signed_unsigned_comparison_mismatch) bld.CMP(bld.null_reg_ud(), retype(dest0, BRW_TYPE_UD), brw_imm_ud(0u), BRW_CONDITIONAL_LE); - /* = Before = - * 0: asr(8) dest:D -src0:W 15D - * 1: cmp.le.f0(8) null:UD dest:UD 0UD - * - * = After = - * (no changes) - */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ASR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_LE, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, ior_f2i_nz) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_D); brw_reg src0 = bld.vgrf(BRW_TYPE_D); brw_reg src1 = bld.vgrf(BRW_TYPE_D); @@ -1508,28 +889,13 @@ TEST_F(cmod_propagation_test, ior_f2i_nz) * dest, interpreted as floating point, is 0.5. This bit pattern is not * zero, but after the float-to-integer conversion, the value is zero. */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - - /* This is ASSERT_EQ because if end_ip is 0, the instruction(block0, 1) - * calls will not work properly, and the test will give weird results. - */ - ASSERT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, uand_b2f_g) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_UD); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg src1 = bld.vgrf(BRW_TYPE_UD); @@ -1551,25 +917,7 @@ TEST_F(cmod_propagation_test, uand_b2f_g) * dest:UD can never be < 0. * */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - - EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - - /* This is ASSERT_EQ because if end_ip is 0, the instruction(block0, 1) - * calls will not work properly, and the test will give weird results. - */ - ASSERT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_G, instruction(block0, 1)->conditional_mod); - EXPECT_TRUE(instruction(block0, 1)->src[0].negate); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } void @@ -1578,40 +926,24 @@ cmod_propagation_test::test_mov_prop(enum brw_conditional_mod cmod, enum brw_reg_type mov_dst_type, bool expected_cmod_prop_progress) { - brw_reg dest = bld.vgrf(add_type); - brw_reg src0 = bld.vgrf(add_type); - brw_reg src1 = bld.vgrf(add_type); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, add_type); + brw_reg src0 = vgrf(bld, exp, add_type); + brw_reg src1 = vgrf(bld, exp, add_type); bld.ADD(dest, src0, src1); bld.MOV(retype(bld.null_reg_ud(), mov_dst_type), dest) ->conditional_mod = cmod; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_EQ(expected_cmod_prop_progress, cmod_propagation(v)); - - const enum brw_conditional_mod add_cmod = - expected_cmod_prop_progress ? cmod : BRW_CONDITIONAL_NONE; - - EXPECT_EQ(0, block0->start_ip); - - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(add_cmod, instruction(block0, 0)->conditional_mod); + EXPECT_PROGRESS_RESULT(expected_cmod_prop_progress, + brw_opt_cmod_propagation, bld); if (expected_cmod_prop_progress) { - EXPECT_EQ(0, block0->end_ip); - } else { - /* This is ASSERT_EQ because if end_ip is 0, the instruction(block0, 1) - * calls will not work properly, and the test will give weird results. - */ - ASSERT_EQ(1, block0->end_ip); + exp.ADD(dest, src0, src1)->conditional_mod = cmod; - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_EQ(cmod, instruction(block0, 1)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } } @@ -2155,10 +1487,13 @@ cmod_propagation_test::test_saturate_prop(enum brw_conditional_mod before, enum brw_reg_type op_type, bool expected_cmod_prop_progress) { - brw_reg dest = bld.vgrf(add_type); - brw_reg src0 = bld.vgrf(add_type); - brw_reg src1 = bld.vgrf(add_type); - brw_reg zero(brw_imm_ud(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, add_type); + brw_reg src0 = vgrf(bld, exp, add_type); + brw_reg src1 = vgrf(bld, exp, add_type); + brw_reg zero = brw_imm_ud(0); bld.ADD(dest, src0, src1)->saturate = true; @@ -2173,36 +1508,15 @@ cmod_propagation_test::test_saturate_prop(enum brw_conditional_mod before, ->conditional_mod = before; } - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_EQ(expected_cmod_prop_progress, cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(add_type, instruction(block0, 0)->dst.type); - EXPECT_EQ(add_type, instruction(block0, 0)->src[0].type); - EXPECT_EQ(add_type, instruction(block0, 0)->src[1].type); - EXPECT_TRUE(instruction(block0, 0)->saturate); + EXPECT_PROGRESS_RESULT(expected_cmod_prop_progress, + brw_opt_cmod_propagation, bld); if (expected_cmod_prop_progress) { - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(before, instruction(block0, 0)->conditional_mod); - } else { - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); + brw_inst *add = exp.ADD(dest, src0, src1); + add->saturate = true; + add->conditional_mod = before; - /* This is ASSERT_EQ because if end_ip is 0, the instruction(block0, 1) - * calls will not work properly, and the test will give weird results. - */ - ASSERT_EQ(1, block0->end_ip); - EXPECT_EQ(op, instruction(block0, 1)->opcode); - EXPECT_EQ(op_type, instruction(block0, 1)->dst.type); - EXPECT_EQ(op_type, instruction(block0, 1)->src[0].type); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_EQ(before, instruction(block0, 1)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } } @@ -2640,11 +1954,15 @@ TEST_F(cmod_propagation_test, not_to_or) /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ - brw_reg dest = bld.vgrf(BRW_TYPE_UD); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src1 = bld.vgrf(BRW_TYPE_UD); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_UD); + bld.OR(dest, src0, src1); - set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest)); + bld.NOT(bld.null_reg_ud(), dest)->conditional_mod = BRW_CONDITIONAL_NZ; /* = Before = * @@ -2655,17 +1973,11 @@ TEST_F(cmod_propagation_test, not_to_or) * 0: or.z.f0(8) dest src0 src1 */ - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.OR(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_Z; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, not_to_and) @@ -2673,32 +1985,21 @@ TEST_F(cmod_propagation_test, not_to_and) /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ - brw_reg dest = bld.vgrf(BRW_TYPE_UD); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src1 = bld.vgrf(BRW_TYPE_UD); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_UD); + bld.AND(dest, src0, src1); - set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest)); + bld.NOT(bld.null_reg_ud(), dest)->conditional_mod = BRW_CONDITIONAL_NZ; - /* = Before = - * - * 0: and(8) dest src0 src1 - * 1: not.nz.f0(8) null dest - * - * = After = - * 0: and.z.f0(8) dest src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.AND(dest, src0, src1)->conditional_mod = BRW_CONDITIONAL_Z; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, not_to_uadd) @@ -2711,34 +2012,16 @@ TEST_F(cmod_propagation_test, not_to_uadd) * restriction is just the the destination type of the ALU instruction is * the same as the source type of the NOT instruction. */ + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_UD); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg src1 = bld.vgrf(BRW_TYPE_UD); + bld.ADD(dest, src0, src1); set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest)); - /* = Before = - * - * 0: add(8) dest src0 src1 - * 1: not.nz.f0(8) null dest - * - * = After = - * No changes - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_NOT, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, not_to_fadd_to_ud) @@ -2751,34 +2034,16 @@ TEST_F(cmod_propagation_test, not_to_fadd_to_ud) * restriction is just the the destination type of the ALU instruction is * the same as the source type of the NOT instruction. */ + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_UD); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.ADD(dest, src0, src1); set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest)); - /* = Before = - * - * 0: add(8) dest.ud src0.f src1.f - * 1: not.nz.f0(8) null dest.ud - * - * = After = - * No changes - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_NOT, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, not_to_fadd) @@ -2791,36 +2056,18 @@ TEST_F(cmod_propagation_test, not_to_fadd) * restriction is just the the destination type of the ALU instruction is * the same as the source type of the NOT instruction. */ + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.ADD(dest, src0, src1); set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), retype(dest, BRW_TYPE_UD))); - /* = Before = - * - * 0: add(8) dest.f src0.f src1.f - * 1: not.nz.f0(8) null dest.ud - * - * = After = - * No changes - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_NOT, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, not_to_or_intervening_flag_read_compatible_value) @@ -2828,40 +2075,27 @@ TEST_F(cmod_propagation_test, not_to_or_intervening_flag_read_compatible_value) /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ - brw_reg dest0 = bld.vgrf(BRW_TYPE_UD); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src1 = bld.vgrf(BRW_TYPE_UD); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); - set_condmod(BRW_CONDITIONAL_Z, bld.OR(dest0, src0, src1)); + + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + + set_condmod(BRW_CONDITIONAL_Z, bld.OR(dest0, src0, src1)); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)); - set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); + set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); - /* = Before = - * - * 0: or.z.f0(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - * 2: not.nz.f0(8) null dest0 - * - * = After = - * 0: or.z.f0(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + set_condmod(BRW_CONDITIONAL_Z, exp.OR(dest0, src0, src1)); + set_predicate(BRW_PREDICATE_NORMAL, exp.SEL(dest1, src2, zero)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, @@ -2870,44 +2104,22 @@ TEST_F(cmod_propagation_test, /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ + + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_UD); brw_reg dest1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg src1 = bld.vgrf(BRW_TYPE_UD); brw_reg src2 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); + set_condmod(BRW_CONDITIONAL_Z, bld.OR(dest0, src0, src1)) ->flag_subreg = 1; set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)); set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); - /* = Before = - * - * 0: or.z.f0.1(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - * 2: not.nz.f0(8) null dest0 - * - * = After = - * No changes - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(BRW_OPCODE_NOT, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 2)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 2)->flag_subreg); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, not_to_or_intervening_flag_read_incompatible_value) @@ -2915,41 +2127,21 @@ TEST_F(cmod_propagation_test, not_to_or_intervening_flag_read_incompatible_value /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ + + brw_builder bld = make_shader(); + brw_reg dest0 = bld.vgrf(BRW_TYPE_UD); brw_reg dest1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_UD); brw_reg src1 = bld.vgrf(BRW_TYPE_UD); brw_reg src2 = bld.vgrf(BRW_TYPE_F); brw_reg zero(brw_imm_f(0.0f)); + set_condmod(BRW_CONDITIONAL_NZ, bld.OR(dest0, src0, src1)); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)); set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); - /* = Before = - * - * 0: or.nz.f0(8) dest0 src0 src1 - * 1: (+f0) sel(8) dest1 src2 0.0f - * 2: not.nz.f0(8) null dest0 - * - * = After = - * No changes - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(BRW_OPCODE_NOT, instruction(block0, 2)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 2)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, not_to_or_intervening_mismatch_flag_write) @@ -2957,42 +2149,27 @@ TEST_F(cmod_propagation_test, not_to_or_intervening_mismatch_flag_write) /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ - brw_reg dest0 = bld.vgrf(BRW_TYPE_UD); - brw_reg dest1 = bld.vgrf(BRW_TYPE_UD); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src1 = bld.vgrf(BRW_TYPE_UD); + + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_UD); bld.OR(dest0, src0, src1); set_condmod(BRW_CONDITIONAL_Z, bld.OR(dest1, src0, src1)) ->flag_subreg = 1; set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); - /* = Before = - * - * 0: or(8) dest0 src0 src1 - * 1: or.z.f0.1(8) dest1 src0 src1 - * 2: not.nz.f0(8) null dest0 - * - * = After = - * 0: or.z.f0(8) dest0 src0 src1 - * 1: or.z.f0.1(8) dest1 src0 src1 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + set_condmod(BRW_CONDITIONAL_Z, exp.OR(dest0, src0, src1)); + set_condmod(BRW_CONDITIONAL_Z, exp.OR(dest1, src0, src1)) + ->flag_subreg = 1; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 1)->conditional_mod); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, not_to_or_intervening_mismatch_flag_read) @@ -3000,48 +2177,35 @@ TEST_F(cmod_propagation_test, not_to_or_intervening_mismatch_flag_read) /* Exercise propagation of conditional modifier from a NOT instruction to * another ALU instruction as performed by cmod_propagate_not. */ - brw_reg dest0 = bld.vgrf(BRW_TYPE_UD); - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_UD); - brw_reg src1 = bld.vgrf(BRW_TYPE_UD); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); bld.OR(dest0, src0, src1); set_predicate(BRW_PREDICATE_NORMAL, bld.SEL(dest1, src2, zero)) ->flag_subreg = 1; set_condmod(BRW_CONDITIONAL_NZ, bld.NOT(bld.null_reg_ud(), dest0)); - /* = Before = - * - * 0: or(8) dest0 src0 src1 - * 1: (+f0.1) sel(8) dest1 src2 0.0f - * 2: not.nz.f0(8) null dest0 - * - * = After = - * 0: or.z.f0(8) dest0 src0 src1 - * 1: (+f0.1) sel(8) dest1 src2 0.0f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.OR(dest0, src0, src1)->conditional_mod = BRW_CONDITIONAL_Z; + set_predicate(BRW_PREDICATE_NORMAL, exp.SEL(dest1, src2, zero)) + ->flag_subreg = 1; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_OR, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_Z, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(0, instruction(block0, 0)->flag_subreg); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate); - EXPECT_EQ(1, instruction(block0, 1)->flag_subreg); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_to_add_float_e) { + brw_builder bld = make_shader(); + brw_reg dest = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg neg10(brw_imm_f(-10.0f)); @@ -3050,148 +2214,93 @@ TEST_F(cmod_propagation_test, cmp_to_add_float_e) bld.ADD(dest, src0, neg10)->saturate = true; bld.CMP(bld.null_reg_f(), src0, pos10, BRW_CONDITIONAL_EQ); - /* = Before = - * 0: add.sat(8) vgrf0:F, vgrf1:F, -10f - * 1: cmp.z.f0.0(8) null:F, vgrf1:F, 10f - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_FALSE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_EQ, instruction(block0, 1)->conditional_mod); + EXPECT_NO_PROGRESS(brw_opt_cmod_propagation, bld); } TEST_F(cmod_propagation_test, cmp_to_add_float_g) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg neg10(brw_imm_f(-10.0f)); - brw_reg pos10(brw_imm_f(10.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg neg10 = brw_imm_f(-10.0f); + brw_reg pos10 = brw_imm_f(10.0f); bld.ADD(dest, src0, neg10)->saturate = true; bld.CMP(bld.null_reg_f(), src0, pos10, BRW_CONDITIONAL_G); - /* = Before = - * 0: add.sat(8) vgrf0:F, vgrf1:F, -10f - * 1: cmp.g.f0.0(8) null:F, vgrf1:F, 10f - * - * = After = - * 0: add.sat.g.f0.0(8) vgrf0:F, vgrf1:F, -10f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + brw_inst *add = exp.ADD(dest, src0, neg10); + add->saturate = true; + add->conditional_mod = BRW_CONDITIONAL_G; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_G, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, cmp_to_add_float_le) { - brw_reg dest = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg neg10(brw_imm_f(-10.0f)); - brw_reg pos10(brw_imm_f(10.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg neg10 = brw_imm_f(-10.0f); + brw_reg pos10 = brw_imm_f(10.0f); bld.ADD(dest, src0, neg10)->saturate = true; bld.CMP(bld.null_reg_f(), src0, pos10, BRW_CONDITIONAL_LE); - /* = Before = - * 0: add.sat(8) vgrf0:F, vgrf1:F, -10f - * 1: cmp.le.f0.0(8) null:F, vgrf1:F, 10f - * - * = After = - * 0: add.sat.le.f0.0(8) vgrf0:F, vgrf1:F, -10f - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + brw_inst *add = exp.ADD(dest, src0, neg10); + add->saturate = true; + add->conditional_mod = BRW_CONDITIONAL_LE; - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_LE, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, prop_across_sel) { - brw_reg dest1 = bld.vgrf(BRW_TYPE_F); - brw_reg dest2 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg src3 = bld.vgrf(BRW_TYPE_F); - brw_reg zero(brw_imm_f(0.0f)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dest2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src3 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg zero = brw_imm_f(0.0f); + bld.ADD(dest1, src0, src1); bld.emit_minmax(dest2, src2, src3, BRW_CONDITIONAL_GE); bld.CMP(bld.null_reg_f(), dest1, zero, BRW_CONDITIONAL_GE); - /* = Before = - * - * 0: add(8) dest1 src0 src1 - * 1: sel.ge(8) dest2 src2 src3 - * 2: cmp.ge.f0(8) null dest1 0.0f - * - * = After = - * 0: add.ge.f0(8) dest1 src0 src1 - * 1: sel.ge(8) dest2 src2 src3 - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.ADD(dest1, src0, src1)->conditional_mod = BRW_CONDITIONAL_GE; + exp.SEL(dest2, src2, src3)->conditional_mod = BRW_CONDITIONAL_GE; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod); - EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(cmod_propagation_test, Boolean_size_conversion) { - brw_reg dest1 = bld.vgrf(BRW_TYPE_W); - brw_reg src0 = bld.vgrf(BRW_TYPE_W); - brw_reg zero(brw_imm_w(0)); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); + + brw_reg dest1 = vgrf(bld, exp, BRW_TYPE_W); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_W); + brw_reg zero = brw_imm_w(0); bld.CMP(dest1, src0, zero, BRW_CONDITIONAL_NZ); - set_condmod(BRW_CONDITIONAL_NZ, bld.MOV(bld.null_reg_d(), dest1)); + bld.MOV(bld.null_reg_d(), dest1)->conditional_mod = BRW_CONDITIONAL_NZ; - /* = Before = - * 0: cmp.nz.f0 dest1:W src0:W 0W - * 1: mov.nz.f0 null:D dest1:W - * - * = After = - * 0: cmp.nz.f0 dest1:W src0:W 0W - */ + EXPECT_PROGRESS(brw_opt_cmod_propagation, bld); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + exp.CMP(dest1, src0, zero, BRW_CONDITIONAL_NZ); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_TRUE(cmod_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(0, block0->end_ip); - - EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 0)->conditional_mod); + EXPECT_SHADERS_MATCH(bld, exp); } diff --git a/src/intel/compiler/test_opt_combine_constants.cpp b/src/intel/compiler/test_opt_combine_constants.cpp index 793d2c3cb5a..885ceff11fd 100644 --- a/src/intel/compiler/test_opt_combine_constants.cpp +++ b/src/intel/compiler/test_opt_combine_constants.cpp @@ -3,101 +3,41 @@ * SPDX-License-Identifier: MIT */ -#include -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -struct FSCombineConstantsTest : public ::testing::Test { - FSCombineConstantsTest() { - mem_ctx = ralloc_context(NULL); +class CombineConstantsTest : public brw_shader_pass_test {}; - devinfo = {}; - devinfo.ver = 9; - devinfo.verx10 = 90; - - compiler = {}; - compiler.devinfo = &devinfo; - brw_init_isa_info(&compiler.isa, &devinfo); - - params = {}; - params.mem_ctx = mem_ctx; - - prog_data = {}; - nir_shader *nir = - nir_shader_create(mem_ctx, MESA_SHADER_COMPUTE, NULL, NULL); - - shader = new brw_shader(&compiler, ¶ms, NULL, - &prog_data.base, nir, 8, false, false); - } - - ~FSCombineConstantsTest() override { - delete shader; - ralloc_free(mem_ctx); - mem_ctx = NULL; - } - - void *mem_ctx; - brw_compiler compiler; - brw_compile_params params; - intel_device_info devinfo; - struct brw_wm_prog_data prog_data; - struct gl_shader_program *shader_prog; - - brw_shader *shader; - - bool opt_combine_constants(brw_shader *s) { - const bool print = getenv("TEST_DEBUG"); - - if (print) { - fprintf(stderr, "= Before =\n"); - s->cfg->dump(); - } - - bool ret = brw_opt_combine_constants(*s); - - if (print) { - fprintf(stderr, "\n= After =\n"); - s->cfg->dump(); - } - - return ret; - } -}; - -TEST_F(FSCombineConstantsTest, Simple) +TEST_F(CombineConstantsTest, Simple) { - brw_builder bld = brw_builder(shader); + brw_builder bld = make_shader(MESA_SHADER_COMPUTE); + brw_builder exp = make_shader(MESA_SHADER_COMPUTE); brw_reg r = brw_vec8_grf(1, 0); - brw_reg imm_a = brw_imm_ud(1); - brw_reg imm_b = brw_imm_ud(2); + brw_reg imm_a = brw_imm_d(1); + brw_reg imm_b = brw_imm_d(2); bld.SEL(r, imm_a, imm_b); - brw_calculate_cfg(*shader); - bool progress = opt_combine_constants(shader); - ASSERT_TRUE(progress); + EXPECT_PROGRESS(brw_opt_combine_constants, bld); - ASSERT_EQ(shader->cfg->num_blocks, 1); - bblock_t *block = shader->cfg->first_block(); - ASSERT_NE(block, nullptr); + brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0); - /* We can do better but for now sanity check that - * there's a MOV and a SEL. - */ - ASSERT_EQ(block->start()->opcode, BRW_OPCODE_MOV); - ASSERT_EQ(block->end()->opcode, BRW_OPCODE_SEL); + exp.group(1, 0).exec_all().MOV(tmp, imm_a); + exp .SEL(r, tmp, imm_b); + + EXPECT_SHADERS_MATCH(bld, exp); } -TEST_F(FSCombineConstantsTest, DoContainingDo) +TEST_F(CombineConstantsTest, DoContainingDo) { - brw_builder bld = brw_builder(shader); + brw_builder bld = make_shader(MESA_SHADER_COMPUTE); + brw_builder exp = make_shader(MESA_SHADER_COMPUTE); brw_reg r1 = brw_vec8_grf(1, 0); brw_reg r2 = brw_vec8_grf(2, 0); - brw_reg imm_a = brw_imm_ud(1); - brw_reg imm_b = brw_imm_ud(2); + brw_reg imm_a = brw_imm_d(1); + brw_reg imm_b = brw_imm_d(2); bld.DO(); bld.DO(); @@ -105,18 +45,19 @@ TEST_F(FSCombineConstantsTest, DoContainingDo) bld.WHILE(); bld.WHILE(); bld.SEL(r2, imm_a, imm_b); - brw_calculate_cfg(*shader); - unsigned original_num_blocks = shader->cfg->num_blocks; + EXPECT_PROGRESS(brw_opt_combine_constants, bld); - bool progress = opt_combine_constants(shader); - ASSERT_TRUE(progress); + /* Explicit emit the expected FLOW instruction. */ + exp.emit(BRW_OPCODE_DO); + brw_reg tmp = component(exp.vgrf(BRW_TYPE_D), 0); + exp.group(1, 0).exec_all().MOV(tmp, imm_a); + exp.emit(SHADER_OPCODE_FLOW); + exp.DO(); + exp.SEL(r1, tmp, imm_b); + exp.WHILE(); + exp.WHILE(); + exp.SEL(r2, tmp, imm_b); - /* We can do better but for now sanity check there's - * enough blocks, since the original issue motivating this - * test is that the shader would be empty. - */ - ASSERT_GE(shader->cfg->num_blocks, original_num_blocks); - brw_validate(*shader); + EXPECT_SHADERS_MATCH(bld, exp); } - diff --git a/src/intel/compiler/test_opt_copy_propagation.cpp b/src/intel/compiler/test_opt_copy_propagation.cpp index f2ad005f7e6..97f5e32fee7 100644 --- a/src/intel/compiler/test_opt_copy_propagation.cpp +++ b/src/intel/compiler/test_opt_copy_propagation.cpp @@ -1,155 +1,37 @@ /* * Copyright © 2016 Intel 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. + * SPDX-License-Identifier: MIT */ -#include -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -class copy_propagation_test : public ::testing::Test { -protected: - copy_propagation_test(); - ~copy_propagation_test() override; - - struct brw_compiler *compiler; - struct brw_compile_params params; - struct intel_device_info *devinfo; - void *ctx; - struct brw_wm_prog_data *prog_data; - struct gl_shader_program *shader_prog; - brw_shader *v; - brw_builder bld; -}; - -copy_propagation_test::copy_propagation_test() -{ - ctx = ralloc_context(NULL); - compiler = rzalloc(ctx, struct brw_compiler); - devinfo = rzalloc(ctx, struct intel_device_info); - compiler->devinfo = devinfo; - - params = {}; - params.mem_ctx = ctx; - - prog_data = ralloc(ctx, struct brw_wm_prog_data); - nir_shader *shader = - nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL); - - v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader, - 8, false, false); - - bld = brw_builder(v); - - devinfo->ver = 9; - devinfo->verx10 = devinfo->ver * 10; -} - -copy_propagation_test::~copy_propagation_test() -{ - delete v; - v = NULL; - - ralloc_free(ctx); - ctx = NULL; -} - -static brw_inst * -instruction(bblock_t *block, int num) -{ - brw_inst *inst = (brw_inst *)block->start(); - for (int i = 0; i < num; i++) { - inst = (brw_inst *)inst->next; - } - return inst; -} - -static bool -copy_propagation(brw_shader *v) -{ - const bool print = getenv("TEST_DEBUG"); - - if (print) { - fprintf(stderr, "= Before =\n"); - v->cfg->dump(); - } - - bool ret = brw_opt_copy_propagation(*v); - - if (print) { - fprintf(stderr, "\n= After =\n"); - v->cfg->dump(); - } - - return ret; -} +class copy_propagation_test : public brw_shader_pass_test {}; TEST_F(copy_propagation_test, basic) { - brw_reg vgrf0 = bld.vgrf(BRW_TYPE_F); - brw_reg vgrf1 = bld.vgrf(BRW_TYPE_F); - brw_reg vgrf2 = bld.vgrf(BRW_TYPE_F); - brw_reg vgrf3 = bld.vgrf(BRW_TYPE_F); - bld.MOV(vgrf0, vgrf2); - bld.ADD(vgrf1, vgrf0, vgrf3); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - /* = Before = - * - * 0: mov(8) vgrf0 vgrf2 - * 1: add(8) vgrf1 vgrf0 vgrf3 - * - * = After = - * 0: mov(8) vgrf0 vgrf2 - * 1: add(8) vgrf1 vgrf2 vgrf3 - */ + brw_reg v0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg v1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg v2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg v3 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.MOV(v0, v2); + bld.ADD(v1, v0, v3); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + /* Propagation makes ADD use v2 as source. */ + EXPECT_PROGRESS(brw_opt_copy_propagation, bld); - EXPECT_TRUE(copy_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.MOV(v0, v2); + exp.ADD(v1, v2, v3); - brw_inst *mov = instruction(block0, 0); - EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode); - EXPECT_TRUE(mov->dst.equals(vgrf0)); - EXPECT_TRUE(mov->src[0].equals(vgrf2)); - - brw_inst *add = instruction(block0, 1); - EXPECT_EQ(BRW_OPCODE_ADD, add->opcode); - EXPECT_TRUE(add->dst.equals(vgrf1)); - EXPECT_TRUE(add->src[0].equals(vgrf2)); - EXPECT_TRUE(add->src[1].equals(vgrf3)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(copy_propagation_test, maxmax_sat_imm) { - brw_reg vgrf0 = bld.vgrf(BRW_TYPE_F); - brw_reg vgrf1 = bld.vgrf(BRW_TYPE_F); - brw_reg vgrf2 = bld.vgrf(BRW_TYPE_F); - static const struct { enum brw_conditional_mod conditional_mod; float immediate; @@ -177,126 +59,57 @@ TEST_F(copy_propagation_test, maxmax_sat_imm) { BRW_CONDITIONAL_U , 0.5f, false }, }; - for (unsigned i = 0; i < sizeof(test) / sizeof(test[0]); i++) { - brw_inst *mov = set_saturate(true, bld.MOV(vgrf0, vgrf1)); - brw_inst *sel = set_condmod(test[i].conditional_mod, - bld.SEL(vgrf2, vgrf0, - brw_imm_f(test[i].immediate))); + for (unsigned i = 0; i < ARRAY_SIZE(test); i++) { + brw_builder bld = make_shader(); - brw_calculate_cfg(*v); + enum brw_conditional_mod cmod = test[i].conditional_mod; + brw_reg imm = brw_imm_f(test[i].immediate); - bblock_t *block0 = v->cfg->blocks[0]; + brw_reg v0 = bld.vgrf(BRW_TYPE_F); + brw_reg v1 = bld.vgrf(BRW_TYPE_F); + brw_reg v2 = bld.vgrf(BRW_TYPE_F); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + bld.MOV(v0, v1)->saturate = true; + bld.SEL(v2, v0, imm)->conditional_mod = cmod; - EXPECT_EQ(test[i].expected_result, copy_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode); - EXPECT_TRUE(mov->saturate); - EXPECT_TRUE(mov->dst.equals(vgrf0)); - EXPECT_TRUE(mov->src[0].equals(vgrf1)); - - EXPECT_EQ(BRW_OPCODE_SEL, sel->opcode); - EXPECT_EQ(test[i].conditional_mod, sel->conditional_mod); - EXPECT_EQ(test[i].expected_result, sel->saturate); - EXPECT_TRUE(sel->dst.equals(vgrf2)); - if (test[i].expected_result) { - EXPECT_TRUE(sel->src[0].equals(vgrf1)); - } else { - EXPECT_TRUE(sel->src[0].equals(vgrf0)); - } - EXPECT_TRUE(sel->src[1].equals(brw_imm_f(test[i].immediate))); - - delete v->cfg; - v->cfg = NULL; + EXPECT_PROGRESS_RESULT(test[i].expected_result, + brw_opt_copy_propagation, bld); } } TEST_F(copy_propagation_test, mixed_integer_sign) { - brw_reg vgrf0 = bld.vgrf(BRW_TYPE_UD); - brw_reg vgrf1 = bld.vgrf(BRW_TYPE_D); - brw_reg vgrf2 = bld.vgrf(BRW_TYPE_UD); - brw_reg vgrf3 = bld.vgrf(BRW_TYPE_UD); - brw_reg vgrf4 = bld.vgrf(BRW_TYPE_UD); + brw_builder bld = make_shader(); + brw_builder exp = make_shader(); - bld.MOV(vgrf1, vgrf0); - bld.BFE(vgrf2, vgrf3, vgrf4, retype(vgrf1, BRW_TYPE_UD)); + brw_reg v0 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg v1 = vgrf(bld, exp, BRW_TYPE_D); + brw_reg v2 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg v3 = vgrf(bld, exp, BRW_TYPE_UD); + brw_reg v4 = vgrf(bld, exp, BRW_TYPE_UD); - /* = Before = - * - * 0: mov(8) vgrf1:D vgrf0:UD - * 1: bfe(8) vgrf2:UD vgrf3:UD vgrf4:UD vgrf1:UD - * - * = After = - * 0: mov(8) vgrf1:D vgrf0:UD - * 1: bfe(8) vgrf2:UD vgrf3:UD vgrf4:UD vgrf0:UD - */ + bld.MOV(v1, v0); + bld.BFE(v2, v3, v4, retype(v1, BRW_TYPE_UD)); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + /* Propagation makes BFE use v0 as source. */ + EXPECT_PROGRESS(brw_opt_copy_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + exp.MOV(v1, v0); + exp.BFE(v2, v3, v4, v0); - EXPECT_TRUE(copy_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - brw_inst *mov = instruction(block0, 0); - EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode); - EXPECT_TRUE(mov->dst.equals(vgrf1)); - EXPECT_TRUE(mov->src[0].equals(vgrf0)); - - brw_inst *bfe = instruction(block0, 1); - EXPECT_EQ(BRW_OPCODE_BFE, bfe->opcode); - EXPECT_TRUE(bfe->dst.equals(vgrf2)); - EXPECT_TRUE(bfe->src[0].equals(vgrf3)); - EXPECT_TRUE(bfe->src[1].equals(vgrf4)); - EXPECT_TRUE(bfe->src[2].equals(vgrf0)); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(copy_propagation_test, mixed_integer_sign_with_vector_imm) { - brw_reg vgrf0 = bld.vgrf(BRW_TYPE_W); - brw_reg vgrf1 = bld.vgrf(BRW_TYPE_UD); - brw_reg vgrf2 = bld.vgrf(BRW_TYPE_UD); + brw_builder bld = make_shader(); - bld.MOV(vgrf0, brw_imm_uv(0xffff)); - bld.ADD(vgrf1, vgrf2, retype(vgrf0, BRW_TYPE_UW)); + brw_reg v0 = bld.vgrf(BRW_TYPE_W); + brw_reg v1 = bld.vgrf(BRW_TYPE_UD); + brw_reg v2 = bld.vgrf(BRW_TYPE_UD); - /* = Before = - * - * 0: mov(8) vgrf0:W ...:UV - * 1: add(8) vgrf1:UD vgrf2:UD vgrf0:UW - * - * = After = - * No change - */ + bld.MOV(v0, brw_imm_uv(0xffff)); + bld.ADD(v1, v2, retype(v0, BRW_TYPE_UW)); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - const brw_reg src1 = instruction(block0, 1)->src[1]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(copy_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - brw_inst *mov = instruction(block0, 0); - EXPECT_EQ(BRW_OPCODE_MOV, mov->opcode); - EXPECT_TRUE(mov->dst.equals(vgrf0)); - EXPECT_TRUE(mov->src[0].file == IMM); - - brw_inst *add = instruction(block0, 1); - EXPECT_EQ(BRW_OPCODE_ADD, add->opcode); - EXPECT_TRUE(add->dst.equals(vgrf1)); - EXPECT_TRUE(add->src[0].equals(vgrf2)); - EXPECT_TRUE(add->src[1].equals(src1)); + EXPECT_NO_PROGRESS(brw_opt_copy_propagation, bld); } diff --git a/src/intel/compiler/test_opt_cse.cpp b/src/intel/compiler/test_opt_cse.cpp index cba8b45e979..2c49a9c0657 100644 --- a/src/intel/compiler/test_opt_cse.cpp +++ b/src/intel/compiler/test_opt_cse.cpp @@ -3,91 +3,17 @@ * SPDX-License-Identifier: MIT */ -#include -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -class cse_test : public ::testing::Test { -protected: - cse_test(); - ~cse_test() override; - - struct brw_compiler *compiler; - struct brw_compile_params params; - struct intel_device_info *devinfo; - void *ctx; - struct brw_wm_prog_data *prog_data; - struct gl_shader_program *shader_prog; - brw_shader *v; - brw_builder bld; -}; - -cse_test::cse_test() -{ - ctx = ralloc_context(NULL); - compiler = rzalloc(ctx, struct brw_compiler); - devinfo = rzalloc(ctx, struct intel_device_info); - compiler->devinfo = devinfo; - - params = {}; - params.mem_ctx = ctx; - - prog_data = ralloc(ctx, struct brw_wm_prog_data); - nir_shader *shader = - nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL); - - v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader, - 16, false, false); - - bld = brw_builder(v); - - devinfo->verx10 = 125; - devinfo->ver = devinfo->verx10 / 10; -} - -cse_test::~cse_test() -{ - delete v; - v = NULL; - - ralloc_free(ctx); - ctx = NULL; -} - - -static brw_inst * -instruction(bblock_t *block, int num) -{ - brw_inst *inst = (brw_inst *)block->start(); - for (int i = 0; i < num; i++) { - inst = (brw_inst *)inst->next; - } - return inst; -} - -static bool -cse(brw_shader *v) -{ - const bool print = false; - - if (print) { - fprintf(stderr, "= Before =\n"); - v->cfg->dump(); - } - - bool ret = brw_opt_cse_defs(*v); - - if (print) { - fprintf(stderr, "\n= After =\n"); - v->cfg->dump(); - } - - return ret; -} +class cse_test : public brw_shader_pass_test {}; TEST_F(cse_test, add3_invalid) { + set_gfx_verx10(125); + + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst0 = bld.null_reg_d(); brw_reg src0 = bld.vgrf(BRW_TYPE_D); brw_reg src1 = bld.vgrf(BRW_TYPE_D); @@ -99,24 +25,5 @@ TEST_F(cse_test, add3_invalid) bld.ADD3(dst0, src0, src1, src3) ->conditional_mod = BRW_CONDITIONAL_NZ; - /* = Before = - * - * 0: add3.nz(16) null src0 src1 src2 - * 1: add3.nz(16) null src0 src1 src3 - * - * = After = - * Same - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(cse(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD3, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_ADD3, instruction(block0, 1)->opcode); + EXPECT_NO_PROGRESS(brw_opt_cse_defs, bld); } diff --git a/src/intel/compiler/test_opt_saturate_propagation.cpp b/src/intel/compiler/test_opt_saturate_propagation.cpp index 003cf0d1e88..6fa09cdc84d 100644 --- a/src/intel/compiler/test_opt_saturate_propagation.cpp +++ b/src/intel/compiler/test_opt_saturate_propagation.cpp @@ -1,631 +1,302 @@ /* * Copyright © 2015 Intel 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. + * SPDX-License-Identifier: MIT */ -#include -#include "brw_shader.h" +#include "test_helpers.h" #include "brw_builder.h" -#include "brw_cfg.h" -class saturate_propagation_test : public ::testing::Test { -protected: - saturate_propagation_test(); - ~saturate_propagation_test() override; - - struct brw_compiler *compiler; - struct brw_compile_params params; - struct intel_device_info *devinfo; - void *ctx; - struct brw_wm_prog_data *prog_data; - struct gl_shader_program *shader_prog; - brw_shader *v; - brw_builder bld; -}; - -saturate_propagation_test::saturate_propagation_test() -{ - ctx = ralloc_context(NULL); - compiler = rzalloc(ctx, struct brw_compiler); - devinfo = rzalloc(ctx, struct intel_device_info); - compiler->devinfo = devinfo; - - params = {}; - params.mem_ctx = ctx; - - prog_data = ralloc(ctx, struct brw_wm_prog_data); - nir_shader *shader = - nir_shader_create(ctx, MESA_SHADER_FRAGMENT, NULL, NULL); - - v = new brw_shader(compiler, ¶ms, NULL, &prog_data->base, shader, - 16, false, false); - - bld = brw_builder(v); - - devinfo->ver = 9; - devinfo->verx10 = devinfo->ver * 10; -} - -saturate_propagation_test::~saturate_propagation_test() -{ - delete v; - v = NULL; - - ralloc_free(ctx); - ctx = NULL; -} - - -static brw_inst * -instruction(bblock_t *block, int num) -{ - brw_inst *inst = (brw_inst *)block->start(); - for (int i = 0; i < num; i++) { - inst = (brw_inst *)inst->next; - } - return inst; -} - -static bool -saturate_propagation(brw_shader *v) -{ - const bool print = false; - - if (print) { - fprintf(stderr, "= Before =\n"); - v->cfg->dump(); - } - - bool ret = brw_opt_saturate_propagation(*v); - - if (print) { - fprintf(stderr, "\n= After =\n"); - v->cfg->dump(); - } - - return ret; -} +class saturate_propagation_test : public brw_shader_pass_test {}; TEST_F(saturate_propagation_test, basic) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, src1); - set_saturate(true, bld.MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * - * = After = - * 0: add.sat(16) dst0 src0 src1 - * 1: mov(16) dst1 dst0 - */ + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.ADD(dst0, src0, src1); + bld.MOV(dst1, dst0)->saturate = true; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); + exp.ADD(dst0, src0, src1)->saturate = true; + exp.MOV(dst1, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, other_non_saturated_use) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); + brw_reg dst2 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, src1); - set_saturate(true, bld.MOV(dst1, dst0)); - bld.ADD(dst0, src0); - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * 2: add(16) dst2 dst0 src0 - * - * = After = - * (no changes) - */ + bld.ADD(dst0, src0, src1); + bld.MOV(dst1, dst0)->saturate = true; + bld.ADD(dst2, dst0, src0); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 2)->opcode); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, predicated_instruction) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); - bld.ADD(dst0, src0, src1) - ->predicate = BRW_PREDICATE_NORMAL; - set_saturate(true, bld.MOV(dst1, dst0)); - /* = Before = - * - * 0: (+f0) add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * - * = After = - * (no changes) - */ + bld.ADD(dst0, src0, src1)->predicate = BRW_PREDICATE_NORMAL; + bld.MOV(dst1, dst0)->saturate = true; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, neg_mov_sat) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg dst0 = bld.RNDU(src0); dst0.negate = true; set_saturate(true, bld.MOV(dst1, dst0)); - /* = Before = - * - * 0: rndu(16) dst0 src0 - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_RNDU, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, add_neg_mov_sat) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, src1); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * 0: add.sat(16) dst0 -src0 -src1 - * 1: mov(16) dst1 dst0 - */ + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.ADD(dst0, src0, src1); + bld.MOV(dst1, negate(dst0))->saturate = true; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_TRUE(instruction(block0, 0)->src[0].negate); - EXPECT_TRUE(instruction(block0, 0)->src[1].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); + exp.ADD(dst0, negate(src0), negate(src1))->saturate = true; + exp.MOV(dst1, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, add_imm_float_neg_mov_sat) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, brw_imm_f(1.0f)); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: add(16) dst0 src0 1.0f - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * 0: add.sat(16) dst0 -src0 -1.0f - * 1: mov(16) dst1 dst0 - */ + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.ADD(dst0, src0, brw_imm_f(1.0f)); + bld.MOV(dst1, negate(dst0))->saturate = true; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_TRUE(instruction(block0, 0)->src[0].negate); - EXPECT_EQ(instruction(block0, 0)->src[1].f, -1.0f); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); + exp.ADD(dst0, negate(src0), brw_imm_f(-1.0f))->saturate = true; + exp.MOV(dst1, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, mul_neg_mov_sat) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.MUL(src0, src1); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: mul(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * 0: mul.sat(16) dst0 src0 -src1 - * 1: mov(16) dst1 dst0 - */ + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.MUL(dst0, src0, src1); + bld.MOV(dst1, negate(dst0))->saturate = true; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MUL, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_TRUE(instruction(block0, 0)->src[0].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_FALSE(instruction(block0, 1)->src[0].negate); + exp.MUL(dst0, negate(src0), src1)->saturate = true; + exp.MOV(dst1, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, mad_neg_mov_sat) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.MAD(src0, src1, src2); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: mad(16) dst0 src0 src1 src2 - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * 0: mad.sat(16) dst0 -src0 -src1 src2 - * 1: mov(16) dst1 dst0 - */ + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + bld.MAD(dst0, src0, src1, src2); + bld.MOV(dst1, negate(dst0))->saturate = true; - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MAD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_TRUE(instruction(block0, 0)->src[0].negate); - EXPECT_TRUE(instruction(block0, 0)->src[1].negate); - EXPECT_FALSE(instruction(block0, 0)->src[2].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_FALSE(instruction(block0, 1)->src[0].negate); + exp.MAD(dst0, negate(src0), negate(src1), src2)->saturate = true; + exp.MOV(dst1, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, mad_imm_float_neg_mov_sat) { - brw_reg dst0 = bld.vgrf(BRW_TYPE_F); - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src2 = bld.vgrf(BRW_TYPE_F); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src2 = vgrf(bld, exp, BRW_TYPE_F); + /* The builder for MAD tries to be helpful and not put immediates as direct * sources. We want to test specifically that case. */ - brw_inst *mad = bld.MAD(dst0, src2, src2, src2); - mad->src[0] = brw_imm_f(1.0f); - mad->src[1] = brw_imm_f(-2.0f); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); - /* = Before = - * - * 0: mad(16) dst0 1.0f -2.0f src2 - * 1: mov.sat(16) dst1 -dst0 - * - * = After = - * 0: mad.sat(16) dst0 -1.0f 2.0f src2 - * 1: mov(16) dst1 dst0 - */ + { + brw_inst *mad = bld.MAD(dst0, src2, src2, src2); + mad->src[0] = brw_imm_f(1.0f); + mad->src[1] = brw_imm_f(-2.0f); + bld.MOV(dst1, negate(dst0))->saturate = true; + } - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); + { + brw_inst *mad = exp.MAD(dst0, src2, src2, src2); + mad->saturate = true; + mad->src[0] = brw_imm_f(-1.0f); + mad->src[1] = brw_imm_f(2.0f); + exp.MOV(dst1, dst0); + } - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MAD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_EQ(instruction(block0, 0)->src[0].f, -1.0f); - EXPECT_EQ(instruction(block0, 0)->src[1].f, 2.0f); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_FALSE(instruction(block0, 1)->src[0].negate); + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, mul_mov_sat_neg_mov_sat) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst2 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.MUL(src0, src1); - set_saturate(true, bld.MOV(dst1, dst0)); - dst0.negate = true; - set_saturate(true, bld.MOV(dst2, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: mul(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * 2: mov.sat(16) dst2 -dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MUL, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_FALSE(instruction(block0, 0)->src[1].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_TRUE(instruction(block0, 2)->src[0].negate); - EXPECT_TRUE(instruction(block0, 2)->saturate); -} - -TEST_F(saturate_propagation_test, mul_neg_mov_sat_neg_mov_sat) -{ - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst2 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.MUL(src0, src1); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); - set_saturate(true, bld.MOV(dst2, dst0)); - - /* = Before = - * - * 0: mul(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 -dst0 - * 2: mov.sat(16) dst2 -dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MUL, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_FALSE(instruction(block0, 0)->src[1].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->src[0].negate); - EXPECT_TRUE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_TRUE(instruction(block0, 2)->src[0].negate); - EXPECT_TRUE(instruction(block0, 2)->saturate); -} - -TEST_F(saturate_propagation_test, abs_mov_sat) -{ - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, src1); - dst0.abs = true; - set_saturate(true, bld.MOV(dst1, dst0)); - - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 (abs)dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); -} - -TEST_F(saturate_propagation_test, producer_saturates) -{ brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg dst2 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); - set_saturate(true, bld.ADD(dst0, src0, src1)); - set_saturate(true, bld.MOV(dst1, dst0)); - bld.MOV(dst2, dst0); - /* = Before = - * - * 0: add.sat(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * 2: mov(16) dst2 dst0 - * - * = After = - * 0: add.sat(16) dst0 src0 src1 - * 1: mov(16) dst1 dst0 - * 2: mov(16) dst2 dst0 - */ + bld.MUL(dst0, src0, src1); + bld.MOV(dst1, dst0)->saturate = true; + bld.MOV(dst2, negate(dst0))->saturate = true; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } -TEST_F(saturate_propagation_test, intervening_saturating_copy) +TEST_F(saturate_propagation_test, mul_neg_mov_sat_neg_mov_sat) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg dst2 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + + brw_reg dst0 = bld.MUL(src0, src1); + bld.MOV(dst1, negate(dst0))->saturate = true; + bld.MOV(dst2, negate(dst0))->saturate = true; + + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); +} + +TEST_F(saturate_propagation_test, abs_mov_sat) +{ + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst1 = bld.vgrf(BRW_TYPE_F); + brw_reg src0 = bld.vgrf(BRW_TYPE_F); + brw_reg src1 = bld.vgrf(BRW_TYPE_F); + brw_reg dst0 = bld.ADD(src0, src1); - set_saturate(true, bld.MOV(dst1, dst0)); - set_saturate(true, bld.MOV(dst2, dst0)); + bld.MOV(dst1, brw_abs(dst0))->saturate = true; - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * 2: mov.sat(16) dst2 dst0 - * - * = After = - * 0: add.sat(16) dst0 src0 src1 - * 1: mov(16) dst1 dst0 - * 2: mov(16) dst2 dst0 - */ + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); +} - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; +TEST_F(saturate_propagation_test, producer_saturates) +{ + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); - EXPECT_TRUE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_TRUE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_FALSE(instruction(block0, 2)->saturate); + bld.ADD(dst0, src0, src1)->saturate = true; + bld.MOV(dst1, dst0)->saturate = true; + bld.MOV(dst2, dst0); + + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); + + exp.ADD(dst0, src0, src1)->saturate = true; + exp.MOV(dst1, dst0); + exp.MOV(dst2, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); +} + +TEST_F(saturate_propagation_test, intervening_saturating_copy) +{ + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_builder exp = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst1 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg dst2 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src0 = vgrf(bld, exp, BRW_TYPE_F); + brw_reg src1 = vgrf(bld, exp, BRW_TYPE_F); + + bld.ADD(dst0, src0, src1); + bld.MOV(dst1, dst0)->saturate = true; + bld.MOV(dst2, dst0)->saturate = true; + + EXPECT_PROGRESS(brw_opt_saturate_propagation, bld); + + exp.ADD(dst0, src0, src1)->saturate = true; + exp.MOV(dst1, dst0); + exp.MOV(dst2, dst0); + + EXPECT_SHADERS_MATCH(bld, exp); } TEST_F(saturate_propagation_test, intervening_dest_write) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst0 = bld.vgrf(BRW_TYPE_F, 4); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); brw_reg src2 = bld.vgrf(BRW_TYPE_F, 2); - brw_reg tex_srcs[TEX_LOGICAL_NUM_SRCS]; + brw_reg tex_srcs[TEX_LOGICAL_NUM_SRCS] = {}; tex_srcs[TEX_LOGICAL_SRC_COORDINATE] = src2; tex_srcs[TEX_LOGICAL_SRC_SURFACE] = brw_imm_ud(0); tex_srcs[TEX_LOGICAL_SRC_COORD_COMPONENTS] = brw_imm_ud(2); @@ -635,175 +306,71 @@ TEST_F(saturate_propagation_test, intervening_dest_write) bld.ADD(offset(dst0, bld, 2), src0, src1); bld.emit(SHADER_OPCODE_TEX_LOGICAL, dst0, tex_srcs, TEX_LOGICAL_NUM_SRCS) ->size_written = 8 * REG_SIZE; - set_saturate(true, bld.MOV(dst1, offset(dst0, bld, 2))); + bld.MOV(dst1, offset(dst0, bld, 2))->saturate = true; - /* = Before = - * - * 0: add(16) dst0+2 src0 src1 - * 1: tex(16) rlen 4 dst0+0 src2 - * 2: mov.sat(16) dst1 dst0+2 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(SHADER_OPCODE_TEX_LOGICAL, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_TRUE(instruction(block0, 2)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, mul_neg_mov_sat_mov_sat) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg dst2 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.MUL(src0, src1); - dst0.negate = true; - set_saturate(true, bld.MOV(dst1, dst0)); - dst0.negate = false; - set_saturate(true, bld.MOV(dst2, dst0)); - /* = Before = - * - * 0: mul(16) dst0 src0 src1 - * 1: mov.sat(16) dst1 -dst0 - * 2: mov.sat(16) dst2 dst0 - * - * = After = - * (no changes) - */ + bld.MUL(dst0, src0, src1); + bld.MOV(dst1, negate(dst0))->saturate = true; + bld.MOV(dst2, dst0)->saturate = true; - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_MUL, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_FALSE(instruction(block0, 0)->src[1].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); - EXPECT_TRUE(instruction(block0, 1)->src[0].negate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_TRUE(instruction(block0, 2)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, smaller_exec_size_consumer) { - brw_reg dst1 = bld.vgrf(BRW_TYPE_F); - brw_reg src0 = bld.vgrf(BRW_TYPE_F); - brw_reg src1 = bld.vgrf(BRW_TYPE_F); - brw_reg dst0 = bld.ADD(src0, src1); - set_saturate(true, bld.group(8, 0).MOV(dst1, dst0)); + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: mov.sat(8) dst1 dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); -} - -TEST_F(saturate_propagation_test, larger_exec_size_consumer) -{ brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + + bld .ADD(src0, src1); + bld.group(8, 0).MOV(dst1, dst0)->saturate = true; + + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); +} + +TEST_F(saturate_propagation_test, larger_exec_size_consumer) +{ + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); + brw_reg dst1 = bld.vgrf(BRW_TYPE_F); + brw_reg src0 = bld.vgrf(BRW_TYPE_F); + brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.group(8, 0).ADD(dst0, src0, src1); - set_saturate(true, bld.MOV(dst1, dst0)); + bld .MOV(dst1, dst0)->saturate = true; - /* = Before = - * - * 0: add(8) dst0 src0 src1 - * 1: mov.sat(16) dst1 dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(1, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 1)->opcode); - EXPECT_TRUE(instruction(block0, 1)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); } TEST_F(saturate_propagation_test, offset_source_barrier) { + brw_builder bld = make_shader(MESA_SHADER_FRAGMENT, 16); + brw_reg dst0 = bld.vgrf(BRW_TYPE_F); brw_reg dst1 = bld.vgrf(BRW_TYPE_F); brw_reg dst2 = bld.vgrf(BRW_TYPE_F); brw_reg src0 = bld.vgrf(BRW_TYPE_F); brw_reg src1 = bld.vgrf(BRW_TYPE_F); + bld.group(16, 0).ADD(dst0, src0, src1); - bld.group(1, 0).ADD(dst1, component(dst0, 8), brw_imm_f(1.0f)); - set_saturate(true, bld.group(16, 0).MOV(dst2, dst0)); + bld.group(1, 0) .ADD(dst1, component(dst0, 8), brw_imm_f(1.0f)); + bld.group(16, 0).MOV(dst2, dst0)->saturate = true; - /* = Before = - * - * 0: add(16) dst0 src0 src1 - * 1: add(1) dst1 dst0+8 1.0f - * 2: mov.sat(16) dst2 dst0 - * - * = After = - * (no changes) - */ - - brw_calculate_cfg(*v); - bblock_t *block0 = v->cfg->blocks[0]; - - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - - EXPECT_FALSE(saturate_propagation(v)); - EXPECT_EQ(0, block0->start_ip); - EXPECT_EQ(2, block0->end_ip); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode); - EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 1)->opcode); - EXPECT_FALSE(instruction(block0, 0)->saturate); - EXPECT_FALSE(instruction(block0, 1)->saturate); - EXPECT_EQ(BRW_OPCODE_MOV, instruction(block0, 2)->opcode); - EXPECT_TRUE(instruction(block0, 2)->saturate); + EXPECT_NO_PROGRESS(brw_opt_saturate_propagation, bld); }