Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright © 2015 Intel Corporation
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21.  * IN THE SOFTWARE.
  22.  */
  23.  
  24. #include <gtest/gtest.h>
  25. #include "brw_fs.h"
  26. #include "brw_cfg.h"
  27. #include "program/program.h"
  28.  
  29. class cmod_propagation_test : public ::testing::Test {
  30.    virtual void SetUp();
  31.  
  32. public:
  33.    struct brw_context *brw;
  34.    struct brw_device_info *devinfo;
  35.    struct gl_context *ctx;
  36.    struct brw_wm_prog_data *prog_data;
  37.    struct gl_shader_program *shader_prog;
  38.    struct brw_fragment_program *fp;
  39.    fs_visitor *v;
  40. };
  41.  
  42. class cmod_propagation_fs_visitor : public fs_visitor
  43. {
  44. public:
  45.    cmod_propagation_fs_visitor(struct brw_context *brw,
  46.                                struct brw_wm_prog_data *prog_data,
  47.                                struct gl_shader_program *shader_prog)
  48.       : fs_visitor(brw, NULL, MESA_SHADER_FRAGMENT, NULL, &prog_data->base,
  49.                    shader_prog, (struct gl_program *) NULL, 8) {}
  50. };
  51.  
  52.  
  53. void cmod_propagation_test::SetUp()
  54. {
  55.    brw = (struct brw_context *)calloc(1, sizeof(*brw));
  56.    devinfo = (struct brw_device_info *)calloc(1, sizeof(*brw));
  57.    brw->intelScreen = (struct intel_screen *)calloc(1, sizeof(*brw->intelScreen));
  58.    brw->intelScreen->devinfo = devinfo;
  59.    ctx = &brw->ctx;
  60.  
  61.    fp = ralloc(NULL, struct brw_fragment_program);
  62.    prog_data = ralloc(NULL, struct brw_wm_prog_data);
  63.    shader_prog = ralloc(NULL, struct gl_shader_program);
  64.  
  65.    v = new cmod_propagation_fs_visitor(brw, prog_data, shader_prog);
  66.  
  67.    _mesa_init_fragment_program(ctx, &fp->program, GL_FRAGMENT_SHADER, 0);
  68.  
  69.    brw->gen = devinfo->gen = 4;
  70. }
  71.  
  72. static fs_inst *
  73. instruction(bblock_t *block, int num)
  74. {
  75.    fs_inst *inst = (fs_inst *)block->start();
  76.    for (int i = 0; i < num; i++) {
  77.       inst = (fs_inst *)inst->next;
  78.    }
  79.    return inst;
  80. }
  81.  
  82. static bool
  83. cmod_propagation(fs_visitor *v)
  84. {
  85.    const bool print = false;
  86.  
  87.    if (print) {
  88.       fprintf(stderr, "= Before =\n");
  89.       v->cfg->dump(v);
  90.    }
  91.  
  92.    bool ret = v->opt_cmod_propagation();
  93.  
  94.    if (print) {
  95.       fprintf(stderr, "\n= After =\n");
  96.       v->cfg->dump(v);
  97.    }
  98.  
  99.    return ret;
  100. }
  101.  
  102. TEST_F(cmod_propagation_test, basic)
  103. {
  104.    fs_reg dest = v->vgrf(glsl_type::float_type);
  105.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  106.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  107.    fs_reg zero(0.0f);
  108.    v->emit(BRW_OPCODE_ADD, dest, src0, src1);
  109.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest, zero)
  110.       ->conditional_mod = BRW_CONDITIONAL_GE;
  111.  
  112.    /* = Before =
  113.     *
  114.     * 0: add(8)        dest  src0  src1
  115.     * 1: cmp.ge.f0(8)  null  dest  0.0f
  116.     *
  117.     * = After =
  118.     * 0: add.ge.f0(8)  dest  src0  src1
  119.     */
  120.  
  121.    v->calculate_cfg();
  122.    bblock_t *block0 = v->cfg->blocks[0];
  123.  
  124.    EXPECT_EQ(0, block0->start_ip);
  125.    EXPECT_EQ(1, block0->end_ip);
  126.  
  127.    EXPECT_TRUE(cmod_propagation(v));
  128.    EXPECT_EQ(0, block0->start_ip);
  129.    EXPECT_EQ(0, block0->end_ip);
  130.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  131.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod);
  132. }
  133.  
  134. TEST_F(cmod_propagation_test, cmp_nonzero)
  135. {
  136.    fs_reg dest = v->vgrf(glsl_type::float_type);
  137.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  138.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  139.    fs_reg nonzero(1.0f);
  140.    v->emit(BRW_OPCODE_ADD, dest, src0, src1);
  141.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest, nonzero)
  142.       ->conditional_mod = BRW_CONDITIONAL_GE;
  143.  
  144.    /* = Before =
  145.     *
  146.     * 0: add(8)        dest  src0  src1
  147.     * 1: cmp.ge.f0(8)  null  dest  1.0f
  148.     *
  149.     * = After =
  150.     * (no changes)
  151.     */
  152.  
  153.    v->calculate_cfg();
  154.    bblock_t *block0 = v->cfg->blocks[0];
  155.  
  156.    EXPECT_EQ(0, block0->start_ip);
  157.    EXPECT_EQ(1, block0->end_ip);
  158.  
  159.    EXPECT_FALSE(cmod_propagation(v));
  160.    EXPECT_EQ(0, block0->start_ip);
  161.    EXPECT_EQ(1, block0->end_ip);
  162.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  163.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode);
  164.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod);
  165. }
  166.  
  167. TEST_F(cmod_propagation_test, non_cmod_instruction)
  168. {
  169.    fs_reg dest = v->vgrf(glsl_type::uint_type);
  170.    fs_reg src0 = v->vgrf(glsl_type::uint_type);
  171.    fs_reg zero(0u);
  172.    v->emit(BRW_OPCODE_FBL, dest, src0);
  173.    v->emit(BRW_OPCODE_CMP, v->reg_null_ud, dest, zero)
  174.       ->conditional_mod = BRW_CONDITIONAL_GE;
  175.  
  176.    /* = Before =
  177.     *
  178.     * 0: fbl(8)        dest  src0
  179.     * 1: cmp.ge.f0(8)  null  dest  0u
  180.     *
  181.     * = After =
  182.     * (no changes)
  183.     */
  184.  
  185.    v->calculate_cfg();
  186.    bblock_t *block0 = v->cfg->blocks[0];
  187.  
  188.    EXPECT_EQ(0, block0->start_ip);
  189.    EXPECT_EQ(1, block0->end_ip);
  190.  
  191.    EXPECT_FALSE(cmod_propagation(v));
  192.    EXPECT_EQ(0, block0->start_ip);
  193.    EXPECT_EQ(1, block0->end_ip);
  194.    EXPECT_EQ(BRW_OPCODE_FBL, instruction(block0, 0)->opcode);
  195.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode);
  196.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod);
  197. }
  198.  
  199. TEST_F(cmod_propagation_test, intervening_flag_write)
  200. {
  201.    fs_reg dest = v->vgrf(glsl_type::float_type);
  202.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  203.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  204.    fs_reg src2 = v->vgrf(glsl_type::float_type);
  205.    fs_reg zero(0.0f);
  206.    v->emit(BRW_OPCODE_ADD, dest, src0, src1);
  207.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, src2, zero)
  208.       ->conditional_mod = BRW_CONDITIONAL_GE;
  209.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest, zero)
  210.       ->conditional_mod = BRW_CONDITIONAL_GE;
  211.  
  212.    /* = Before =
  213.     *
  214.     * 0: add(8)        dest  src0  src1
  215.     * 1: cmp.ge.f0(8)  null  src2  0.0f
  216.     * 2: cmp.ge.f0(8)  null  dest  0.0f
  217.     *
  218.     * = After =
  219.     * (no changes)
  220.     */
  221.  
  222.    v->calculate_cfg();
  223.    bblock_t *block0 = v->cfg->blocks[0];
  224.  
  225.    EXPECT_EQ(0, block0->start_ip);
  226.    EXPECT_EQ(2, block0->end_ip);
  227.  
  228.    EXPECT_FALSE(cmod_propagation(v));
  229.    EXPECT_EQ(0, block0->start_ip);
  230.    EXPECT_EQ(2, block0->end_ip);
  231.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  232.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode);
  233.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod);
  234.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode);
  235.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod);
  236. }
  237.  
  238. TEST_F(cmod_propagation_test, intervening_flag_read)
  239. {
  240.    fs_reg dest0 = v->vgrf(glsl_type::float_type);
  241.    fs_reg dest1 = v->vgrf(glsl_type::float_type);
  242.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  243.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  244.    fs_reg src2 = v->vgrf(glsl_type::float_type);
  245.    fs_reg zero(0.0f);
  246.    v->emit(BRW_OPCODE_ADD, dest0, src0, src1);
  247.    v->emit(BRW_OPCODE_SEL, dest1, src2, zero)
  248.       ->predicate = BRW_PREDICATE_NORMAL;
  249.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest0, zero)
  250.       ->conditional_mod = BRW_CONDITIONAL_GE;
  251.  
  252.    /* = Before =
  253.     *
  254.     * 0: add(8)        dest0 src0  src1
  255.     * 1: (+f0) sel(8)  dest1 src2  0.0f
  256.     * 2: cmp.ge.f0(8)  null  dest0 0.0f
  257.     *
  258.     * = After =
  259.     * (no changes)
  260.     */
  261.  
  262.    v->calculate_cfg();
  263.    bblock_t *block0 = v->cfg->blocks[0];
  264.  
  265.    EXPECT_EQ(0, block0->start_ip);
  266.    EXPECT_EQ(2, block0->end_ip);
  267.  
  268.    EXPECT_FALSE(cmod_propagation(v));
  269.    EXPECT_EQ(0, block0->start_ip);
  270.    EXPECT_EQ(2, block0->end_ip);
  271.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  272.    EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode);
  273.    EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate);
  274.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode);
  275.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod);
  276. }
  277.  
  278. TEST_F(cmod_propagation_test, intervening_dest_write)
  279. {
  280.    fs_reg dest = v->vgrf(glsl_type::vec4_type);
  281.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  282.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  283.    fs_reg src2 = v->vgrf(glsl_type::vec2_type);
  284.    fs_reg zero(0.0f);
  285.    v->emit(BRW_OPCODE_ADD, offset(dest, 2), src0, src1);
  286.    v->emit(SHADER_OPCODE_TEX, dest, src2)
  287.       ->regs_written = 4;
  288.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, offset(dest, 2), zero)
  289.       ->conditional_mod = BRW_CONDITIONAL_GE;
  290.  
  291.    /* = Before =
  292.     *
  293.     * 0: add(8)        dest+2  src0    src1
  294.     * 1: tex(8) rlen 4 dest+0  src2
  295.     * 2: cmp.ge.f0(8)  null    dest+2  0.0f
  296.     *
  297.     * = After =
  298.     * (no changes)
  299.     */
  300.  
  301.    v->calculate_cfg();
  302.    bblock_t *block0 = v->cfg->blocks[0];
  303.  
  304.    EXPECT_EQ(0, block0->start_ip);
  305.    EXPECT_EQ(2, block0->end_ip);
  306.  
  307.    EXPECT_FALSE(cmod_propagation(v));
  308.    EXPECT_EQ(0, block0->start_ip);
  309.    EXPECT_EQ(2, block0->end_ip);
  310.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  311.    EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod);
  312.    EXPECT_EQ(SHADER_OPCODE_TEX, instruction(block0, 1)->opcode);
  313.    EXPECT_EQ(BRW_CONDITIONAL_NONE, instruction(block0, 0)->conditional_mod);
  314.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 2)->opcode);
  315.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 2)->conditional_mod);
  316. }
  317.  
  318. TEST_F(cmod_propagation_test, intervening_flag_read_same_value)
  319. {
  320.    fs_reg dest0 = v->vgrf(glsl_type::float_type);
  321.    fs_reg dest1 = v->vgrf(glsl_type::float_type);
  322.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  323.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  324.    fs_reg src2 = v->vgrf(glsl_type::float_type);
  325.    fs_reg zero(0.0f);
  326.    v->emit(BRW_OPCODE_ADD, dest0, src0, src1)
  327.       ->conditional_mod = BRW_CONDITIONAL_GE;
  328.    v->emit(BRW_OPCODE_SEL, dest1, src2, zero)
  329.       ->predicate = BRW_PREDICATE_NORMAL;
  330.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest0, zero)
  331.       ->conditional_mod = BRW_CONDITIONAL_GE;
  332.  
  333.    /* = Before =
  334.     *
  335.     * 0: add.ge.f0(8)  dest0 src0  src1
  336.     * 1: (+f0) sel(8)  dest1 src2  0.0f
  337.     * 2: cmp.ge.f0(8)  null  dest0 0.0f
  338.     *
  339.     * = After =
  340.     * 0: add.ge.f0(8)  dest0 src0  src1
  341.     * 1: (+f0) sel(8)  dest1 src2  0.0f
  342.     */
  343.  
  344.    v->calculate_cfg();
  345.    bblock_t *block0 = v->cfg->blocks[0];
  346.  
  347.    EXPECT_EQ(0, block0->start_ip);
  348.    EXPECT_EQ(2, block0->end_ip);
  349.  
  350.    EXPECT_TRUE(cmod_propagation(v));
  351.    EXPECT_EQ(0, block0->start_ip);
  352.    EXPECT_EQ(1, block0->end_ip);
  353.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  354.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod);
  355.    EXPECT_EQ(BRW_OPCODE_SEL, instruction(block0, 1)->opcode);
  356.    EXPECT_EQ(BRW_PREDICATE_NORMAL, instruction(block0, 1)->predicate);
  357. }
  358.  
  359. TEST_F(cmod_propagation_test, negate)
  360. {
  361.    fs_reg dest = v->vgrf(glsl_type::float_type);
  362.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  363.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  364.    fs_reg zero(0.0f);
  365.    v->emit(BRW_OPCODE_ADD, dest, src0, src1);
  366.    dest.negate = true;
  367.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, dest, zero)
  368.       ->conditional_mod = BRW_CONDITIONAL_GE;
  369.  
  370.    /* = Before =
  371.     *
  372.     * 0: add(8)        dest  src0  src1
  373.     * 1: cmp.ge.f0(8)  null  -dest 0.0f
  374.     *
  375.     * = After =
  376.     * 0: add.le.f0(8)  dest  src0  src1
  377.     */
  378.  
  379.    v->calculate_cfg();
  380.    bblock_t *block0 = v->cfg->blocks[0];
  381.  
  382.    EXPECT_EQ(0, block0->start_ip);
  383.    EXPECT_EQ(1, block0->end_ip);
  384.  
  385.    EXPECT_TRUE(cmod_propagation(v));
  386.    EXPECT_EQ(0, block0->start_ip);
  387.    EXPECT_EQ(0, block0->end_ip);
  388.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  389.    EXPECT_EQ(BRW_CONDITIONAL_LE, instruction(block0, 0)->conditional_mod);
  390. }
  391.  
  392. TEST_F(cmod_propagation_test, movnz)
  393. {
  394.    fs_reg dest = v->vgrf(glsl_type::float_type);
  395.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  396.    fs_reg src1 = v->vgrf(glsl_type::float_type);
  397.    v->emit(BRW_OPCODE_CMP, dest, src0, src1)
  398.       ->conditional_mod = BRW_CONDITIONAL_GE;
  399.    v->emit(BRW_OPCODE_MOV, v->reg_null_f, dest)
  400.       ->conditional_mod = BRW_CONDITIONAL_NZ;
  401.  
  402.    /* = Before =
  403.     *
  404.     * 0: cmp.ge.f0(8)  dest  src0  src1
  405.     * 1: mov.nz.f0(8)  null  dest
  406.     *
  407.     * = After =
  408.     * 0: cmp.ge.f0(8)  dest  src0  src1
  409.     */
  410.  
  411.    v->calculate_cfg();
  412.    bblock_t *block0 = v->cfg->blocks[0];
  413.  
  414.    EXPECT_EQ(0, block0->start_ip);
  415.    EXPECT_EQ(1, block0->end_ip);
  416.  
  417.    EXPECT_TRUE(cmod_propagation(v));
  418.    EXPECT_EQ(0, block0->start_ip);
  419.    EXPECT_EQ(0, block0->end_ip);
  420.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode);
  421.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 0)->conditional_mod);
  422. }
  423.  
  424. TEST_F(cmod_propagation_test, different_types_cmod_with_zero)
  425. {
  426.    fs_reg dest = v->vgrf(glsl_type::int_type);
  427.    fs_reg src0 = v->vgrf(glsl_type::int_type);
  428.    fs_reg src1 = v->vgrf(glsl_type::int_type);
  429.    fs_reg zero(0.0f);
  430.    v->emit(BRW_OPCODE_ADD, dest, src0, src1);
  431.    v->emit(BRW_OPCODE_CMP, v->reg_null_f, retype(dest, BRW_REGISTER_TYPE_F),
  432.                                           zero)
  433.       ->conditional_mod = BRW_CONDITIONAL_GE;
  434.  
  435.    /* = Before =
  436.     *
  437.     * 0: add(8)        dest:D  src0:D  src1:D
  438.     * 1: cmp.ge.f0(8)  null:F  dest:F  0.0f
  439.     *
  440.     * = After =
  441.     * (no changes)
  442.     */
  443.  
  444.    v->calculate_cfg();
  445.    bblock_t *block0 = v->cfg->blocks[0];
  446.  
  447.    EXPECT_EQ(0, block0->start_ip);
  448.    EXPECT_EQ(1, block0->end_ip);
  449.  
  450.    EXPECT_FALSE(cmod_propagation(v));
  451.    EXPECT_EQ(0, block0->start_ip);
  452.    EXPECT_EQ(1, block0->end_ip);
  453.    EXPECT_EQ(BRW_OPCODE_ADD, instruction(block0, 0)->opcode);
  454.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 1)->opcode);
  455.    EXPECT_EQ(BRW_CONDITIONAL_GE, instruction(block0, 1)->conditional_mod);
  456. }
  457.  
  458. TEST_F(cmod_propagation_test, andnz_one)
  459. {
  460.    fs_reg dest = v->vgrf(glsl_type::int_type);
  461.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  462.    fs_reg zero(0.0f);
  463.    fs_reg one(1);
  464.  
  465.    v->emit(BRW_OPCODE_CMP, retype(dest, BRW_REGISTER_TYPE_F), src0, zero)
  466.       ->conditional_mod = BRW_CONDITIONAL_L;
  467.    v->emit(BRW_OPCODE_AND, v->reg_null_d, dest, one)
  468.       ->conditional_mod = BRW_CONDITIONAL_NZ;
  469.  
  470.    /* = Before =
  471.     * 0: cmp.l.f0(8)     dest:F  src0:F  0F
  472.     * 1: and.nz.f0(8)    null:D  dest:D  1D
  473.     *
  474.     * = After =
  475.     * 0: cmp.l.f0(8)     dest:F  src0:F  0F
  476.     */
  477.  
  478.    v->calculate_cfg();
  479.    bblock_t *block0 = v->cfg->blocks[0];
  480.  
  481.    EXPECT_EQ(0, block0->start_ip);
  482.    EXPECT_EQ(1, block0->end_ip);
  483.  
  484.    EXPECT_TRUE(cmod_propagation(v));
  485.    EXPECT_EQ(0, block0->start_ip);
  486.    EXPECT_EQ(0, block0->end_ip);
  487.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode);
  488.    EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod);
  489.    EXPECT_TRUE(retype(dest, BRW_REGISTER_TYPE_F)
  490.                .equals(instruction(block0, 0)->dst));
  491. }
  492.  
  493. TEST_F(cmod_propagation_test, andnz_non_one)
  494. {
  495.    fs_reg dest = v->vgrf(glsl_type::int_type);
  496.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  497.    fs_reg zero(0.0f);
  498.    fs_reg nonone(38);
  499.  
  500.    v->emit(BRW_OPCODE_CMP, retype(dest, BRW_REGISTER_TYPE_F), src0, zero)
  501.       ->conditional_mod = BRW_CONDITIONAL_L;
  502.    v->emit(BRW_OPCODE_AND, v->reg_null_d, dest, nonone)
  503.       ->conditional_mod = BRW_CONDITIONAL_NZ;
  504.  
  505.    /* = Before =
  506.     * 0: cmp.l.f0(8)     dest:F  src0:F  0F
  507.     * 1: and.nz.f0(8)    null:D  dest:D  38D
  508.     *
  509.     * = After =
  510.     * (no changes)
  511.     */
  512.  
  513.    v->calculate_cfg();
  514.    bblock_t *block0 = v->cfg->blocks[0];
  515.  
  516.    EXPECT_EQ(0, block0->start_ip);
  517.    EXPECT_EQ(1, block0->end_ip);
  518.  
  519.    EXPECT_FALSE(cmod_propagation(v));
  520.    EXPECT_EQ(0, block0->start_ip);
  521.    EXPECT_EQ(1, block0->end_ip);
  522.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode);
  523.    EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod);
  524.    EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 1)->opcode);
  525.    EXPECT_EQ(BRW_CONDITIONAL_NZ, instruction(block0, 1)->conditional_mod);
  526. }
  527.  
  528. TEST_F(cmod_propagation_test, andz_one)
  529. {
  530.    fs_reg dest = v->vgrf(glsl_type::int_type);
  531.    fs_reg src0 = v->vgrf(glsl_type::float_type);
  532.    fs_reg zero(0.0f);
  533.    fs_reg one(1);
  534.  
  535.    v->emit(BRW_OPCODE_CMP, retype(dest, BRW_REGISTER_TYPE_F), src0, zero)
  536.       ->conditional_mod = BRW_CONDITIONAL_L;
  537.    v->emit(BRW_OPCODE_AND, v->reg_null_d, dest, one)
  538.       ->conditional_mod = BRW_CONDITIONAL_Z;
  539.  
  540.    /* = Before =
  541.     * 0: cmp.l.f0(8)     dest:F  src0:F  0F
  542.     * 1: and.z.f0(8)     null:D  dest:D  1D
  543.     *
  544.     * = After =
  545.     * (no changes)
  546.     */
  547.  
  548.    v->calculate_cfg();
  549.    bblock_t *block0 = v->cfg->blocks[0];
  550.  
  551.    EXPECT_EQ(0, block0->start_ip);
  552.    EXPECT_EQ(1, block0->end_ip);
  553.  
  554.    EXPECT_FALSE(cmod_propagation(v));
  555.    EXPECT_EQ(0, block0->start_ip);
  556.    EXPECT_EQ(1, block0->end_ip);
  557.    EXPECT_EQ(BRW_OPCODE_CMP, instruction(block0, 0)->opcode);
  558.    EXPECT_EQ(BRW_CONDITIONAL_L, instruction(block0, 0)->conditional_mod);
  559.    EXPECT_EQ(BRW_OPCODE_AND, instruction(block0, 1)->opcode);
  560.    EXPECT_EQ(BRW_CONDITIONAL_EQ, instruction(block0, 1)->conditional_mod);
  561. }
  562.