src/compiler/nir/tests/comparison_pre_tests.cpp

   1 /*
   2  * Copyright © 2019 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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23 #include <gtest/gtest.h>
  24 #include "nir.h"
  25 #include "nir_builder.h"
  26
  27 class comparison_pre_test : public ::testing::Test {
  28 protected:
  29    comparison_pre_test()
  30    {
  31       glsl_type_singleton_init_or_ref();
  32
  33       static const nir_shader_compiler_options options = { };
  34       nir_builder_init_simple_shader(&bld, NULL, MESA_SHADER_VERTEX, &options);
  35
  36       v1 = nir_imm_vec4(&bld, -2.0, -1.0,  1.0,  2.0);
  37       v2 = nir_imm_vec4(&bld,  2.0,  1.0, -1.0, -2.0);
  38       v3 = nir_imm_vec4(&bld,  3.0,  4.0,  5.0,  6.0);
  39    }
  40
  41    ~comparison_pre_test()
  42    {
  43       ralloc_free(bld.shader);
  44       glsl_type_singleton_decref();
  45    }
  46
  47    struct nir_builder bld;
  48
  49    nir_ssa_def *v1;
  50    nir_ssa_def *v2;
  51    nir_ssa_def *v3;
  52
  53    const uint8_t xxxx[4] = { 0, 0, 0, 0 };
  54    const uint8_t wwww[4] = { 3, 3, 3, 3 };
  55 };
  56
  57 TEST_F(comparison_pre_test, a_lt_b_vs_neg_a_plus_b)
  58 {
  59    /* Before:
  60     *
  61     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
  62     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
  63     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
  64     * vec1 32 ssa_3 = load_const ( 1.0)
  65     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
  66     * vec1 32 ssa_5 = mov ssa_4.x
  67     * vec1 1 ssa_6 = flt ssa_5, ssa_3
  68     *
  69     * if ssa_6 {
  70     *    vec1 32 ssa_7 = fneg ssa_5
  71     *    vec1 32 ssa_8 = fadd ssa_7, ssa_3
  72     * } else {
  73     * }
  74     *
  75     * After:
  76     *
  77     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
  78     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
  79     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
  80     * vec1 32 ssa_3 = load_const ( 1.0)
  81     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
  82     * vec1 32 ssa_5 = mov ssa_4.x
  83     * vec1 32 ssa_9 = fneg ssa_5
  84     * vec1 32 ssa_10 = fadd ssa_3, ssa_9
  85     * vec1 32 ssa_11 = load_const (0.0)
  86     * vec1 1 ssa_12 = flt ssa_11, ssa_10
  87     * vec1 32 ssa_13 = mov ssa_10
  88     * vec1 1 ssa_14 = mov ssa_12
  89     *
  90     * if ssa_14 {
  91     *    vec1 32 ssa_7 = fneg ssa_5
  92     * } else {
  93     * }
  94     */
  95    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
  96    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
  97
  98    nir_ssa_def *flt = nir_flt(&bld, a, one);
  99
 100    nir_if *nif = nir_push_if(&bld, flt);
 101
 102    nir_fadd(&bld, nir_fneg(&bld, a), one);
 103
 104    nir_pop_if(&bld, nif);
 105
 106    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 107 }
 108
 109 TEST_F(comparison_pre_test, a_lt_b_vs_a_minus_b)
 110 {
 111    /* Before:
 112     *
 113     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 114     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 115     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 116     * vec1 32 ssa_3 = load_const ( 1.0)
 117     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 118     * vec1 32 ssa_5 = mov ssa_4.x
 119     * vec1 1 ssa_6 = flt ssa_3, ssa_5
 120     *
 121     * if ssa_6 {
 122     *    vec1 32 ssa_7 = fneg ssa_5
 123     *    vec1 32 ssa_8 = fadd ssa_3, ssa_7
 124     * } else {
 125     * }
 126     *
 127     * After:
 128     *
 129     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 130     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 131     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 132     * vec1 32 ssa_3 = load_const ( 1.0)
 133     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 134     * vec1 32 ssa_5 = mov ssa_4.x
 135     * vec1 32 ssa_9 = fneg ssa_5
 136     * vec1 32 ssa_10 = fadd ssa_3, ssa_9
 137     * vec1 32 ssa_11 = load_const (0.0)
 138     * vec1 1 ssa_12 = flt ssa_10, ssa_11
 139     * vec1 32 ssa_13 = mov ssa_10
 140     * vec1 1 ssa_14 = mov ssa_12
 141     *
 142     * if ssa_14 {
 143     *    vec1 32 ssa_7 = fneg ssa_5
 144     * } else {
 145     * }
 146     */
 147    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 148    nir_ssa_def *b = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 149
 150    nir_ssa_def *flt = nir_flt(&bld, one, b);
 151
 152    nir_if *nif = nir_push_if(&bld, flt);
 153
 154    nir_fadd(&bld, one, nir_fneg(&bld, b));
 155
 156    nir_pop_if(&bld, nif);
 157
 158    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 159 }
 160
 161 TEST_F(comparison_pre_test, neg_a_lt_b_vs_a_plus_b)
 162 {
 163    /* Before:
 164     *
 165     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 166     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 167     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 168     * vec1 32 ssa_3 = load_const ( 1.0)
 169     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 170     * vec1 32 ssa_5 = mov ssa_4.x
 171     * vec1 32 ssa_6 = fneg ssa_5
 172     * vec1 1 ssa_7 = flt ssa_6, ssa_3
 173     *
 174     * if ssa_7 {
 175     *    vec1 32 ssa_8 = fadd ssa_5, ssa_3
 176     * } else {
 177     * }
 178     *
 179     * After:
 180     *
 181     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 182     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 183     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 184     * vec1 32 ssa_3 = load_const ( 1.0)
 185     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 186     * vec1 32 ssa_5 = mov ssa_4.x
 187     * vec1 32 ssa_9 = fneg ssa_5
 188     * vec1 32 ssa_9 = fneg ssa_6
 189     * vec1 32 ssa_10 = fadd ssa_3, ssa_9
 190     * vec1 32 ssa_11 = load_const ( 0.0)
 191     * vec1 1 ssa_12 = flt ssa_11, ssa_10
 192     * vec1 32 ssa_13 = mov ssa_10
 193     * vec1 1 ssa_14 = mov ssa_12
 194     *
 195     * if ssa_14 {
 196     * } else {
 197     * }
 198     */
 199
 200    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 201    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 202
 203    nir_ssa_def *flt = nir_flt(&bld, nir_fneg(&bld, a), one);
 204
 205    nir_if *nif = nir_push_if(&bld, flt);
 206
 207    nir_fadd(&bld, a, one);
 208
 209    nir_pop_if(&bld, nif);
 210
 211    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 212 }
 213
 214 TEST_F(comparison_pre_test, a_lt_neg_b_vs_a_plus_b)
 215 {
 216    /* Before:
 217     *
 218     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 219     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 220     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 221     * vec1 32 ssa_3 = load_const ( 1.0)
 222     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 223     * vec1 32 ssa_5 = mov ssa_4.x
 224     * vec1 32 ssa_6 = fneg ssa_5
 225     * vec1 1 ssa_7 = flt ssa_3, ssa_6
 226     *
 227     * if ssa_7 {
 228     *    vec1 32 ssa_8 = fadd ssa_3, ssa_5
 229     * } else {
 230     * }
 231     *
 232     * After:
 233     *
 234     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 235     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 236     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 237     * vec1 32 ssa_3 = load_const ( 1.0)
 238     * vec4 32 ssa_4 = fadd ssa_0, ssa_2
 239     * vec1 32 ssa_5 = mov ssa_4.x
 240     * vec1 32 ssa_9 = fneg ssa_5
 241     * vec1 32 ssa_9 = fneg ssa_6
 242     * vec1 32 ssa_10 = fadd ssa_3, ssa_9
 243     * vec1 32 ssa_11 = load_const ( 0.0)
 244     * vec1 1 ssa_12 = flt ssa_10, ssa_11
 245     * vec1 32 ssa_13 = mov ssa_10
 246     * vec1 1 ssa_14 = mov ssa_12
 247     *
 248     * if ssa_14 {
 249     * } else {
 250     * }
 251     */
 252    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 253    nir_ssa_def *b = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 254
 255    nir_ssa_def *flt = nir_flt(&bld, one, nir_fneg(&bld, b));
 256
 257    nir_if *nif = nir_push_if(&bld, flt);
 258
 259    nir_fadd(&bld, one, b);
 260
 261    nir_pop_if(&bld, nif);
 262
 263    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 264 }
 265
 266 TEST_F(comparison_pre_test, imm_lt_b_vs_neg_imm_plus_b)
 267 {
 268    /* Before:
 269     *
 270     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 271     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 272     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 273     * vec1 32 ssa_3 = load_const ( 1.0)
 274     * vec1 32 ssa_4 = load_const (-1.0)
 275     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 276     * vec1 32 ssa_6 = mov ssa_5.x
 277     * vec1 1 ssa_7 = flt ssa_3, ssa_6
 278     *
 279     * if ssa_7 {
 280     *    vec1 32 ssa_8 = fadd ssa_4, ssa_6
 281     * } else {
 282     * }
 283     *
 284     * After:
 285     *
 286     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 287     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 288     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 289     * vec1 32 ssa_3 = load_const ( 1.0)
 290     * vec1 32 ssa_4 = load_const (-1.0)
 291     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 292     * vec1 32 ssa_6 = mov ssa_5.x
 293     * vec1 32 ssa_9 = fneg ssa_3
 294     * vec1 32 ssa_10 = fadd ssa_6, ssa_9
 295     * vec1 32 ssa_11 = load_const ( 0.0)
 296     * vec1 1 ssa_12 = flt ssa_11, ssa_10
 297     * vec1 32 ssa_13 = mov ssa_10
 298     * vec1 1 ssa_14 = mov ssa_12
 299     *
 300     * if ssa_14 {
 301     * } else {
 302     * }
 303     */
 304    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 305    nir_ssa_def *neg_one = nir_imm_float(&bld, -1.0f);
 306    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 307
 308    nir_ssa_def *flt = nir_flt(&bld, one, a);
 309
 310    nir_if *nif = nir_push_if(&bld, flt);
 311
 312    nir_fadd(&bld, neg_one, a);
 313
 314    nir_pop_if(&bld, nif);
 315
 316    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 317 }
 318
 319 TEST_F(comparison_pre_test, a_lt_imm_vs_a_minus_imm)
 320 {
 321    /* Before:
 322     *
 323     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 324     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 325     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 326     * vec1 32 ssa_3 = load_const ( 1.0)
 327     * vec1 32 ssa_4 = load_const (-1.0)
 328     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 329     * vec1 32 ssa_6 = mov ssa_5.x
 330     * vec1 1 ssa_7 = flt ssa_6, ssa_3
 331     *
 332     * if ssa_6 {
 333     *    vec1 32 ssa_8 = fadd ssa_6, ssa_4
 334     * } else {
 335     * }
 336     *
 337     * After:
 338     *
 339     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 340     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 341     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 342     * vec1 32 ssa_3 = load_const ( 1.0)
 343     * vec1 32 ssa_4 = load_const (-1.0)
 344     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 345     * vec1 32 ssa_6 = mov ssa_5.x
 346     * vec1 32 ssa_9 = fneg ssa_3
 347     * vec1 32 ssa_10 = fadd ssa_6, ssa_9
 348     * vec1 32 ssa_11 = load_const ( 0.0)
 349     * vec1 1 ssa_12 = flt ssa_10, ssa_11
 350     * vec1 32 ssa_13 = mov ssa_10
 351     * vec1 1 ssa_14 = mov ssa_12
 352     *
 353     * if ssa_14 {
 354     * } else {
 355     * }
 356     */
 357    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 358    nir_ssa_def *neg_one = nir_imm_float(&bld, -1.0f);
 359    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 360
 361    nir_ssa_def *flt = nir_flt(&bld, a, one);
 362
 363    nir_if *nif = nir_push_if(&bld, flt);
 364
 365    nir_fadd(&bld, a, neg_one);
 366
 367    nir_pop_if(&bld, nif);
 368
 369    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 370 }
 371
 372 TEST_F(comparison_pre_test, neg_imm_lt_a_vs_a_plus_imm)
 373 {
 374    /* Before:
 375     *
 376     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 377     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 378     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 379     * vec1 32 ssa_3 = load_const ( 1.0)
 380     * vec1 32 ssa_4 = load_const (-1.0)
 381     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 382     * vec1 32 ssa_6 = mov ssa_5.x
 383     * vec1 1 ssa_7 = flt ssa_4, ssa_6
 384     *
 385     * if ssa_7 {
 386     *    vec1 32 ssa_8 = fadd ssa_6, ssa_3
 387     * } else {
 388     * }
 389     *
 390     * After:
 391     *
 392     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 393     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 394     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 395     * vec1 32 ssa_3 = load_const ( 1.0)
 396     * vec1 32 ssa_4 = load_const (-1.0)
 397     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 398     * vec1 32 ssa_6 = mov ssa_5.x
 399     * vec1 32 ssa_9 = fneg ssa_4
 400     * vec1 32 ssa_10 = fadd ssa_6, ssa_9
 401     * vec1 32 ssa_11 = load_const ( 0.0)
 402     * vec1 1 ssa_12 = flt ssa_11, ssa_10
 403     * vec1 32 ssa_13 = mov ssa_10
 404     * vec1 1 ssa_14 = mov ssa_12
 405     *
 406     * if ssa_14 {
 407     * } else {
 408     * }
 409     */
 410
 411    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 412    nir_ssa_def *neg_one = nir_imm_float(&bld, -1.0f);
 413    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 414
 415    nir_ssa_def *flt = nir_flt(&bld, neg_one, a);
 416
 417    nir_if *nif = nir_push_if(&bld, flt);
 418
 419    nir_fadd(&bld, a, one);
 420
 421    nir_pop_if(&bld, nif);
 422
 423    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 424 }
 425
 426 TEST_F(comparison_pre_test, a_lt_neg_imm_vs_a_plus_imm)
 427 {
 428    /* Before:
 429     *
 430     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 431     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 432     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 433     * vec1 32 ssa_3 = load_const ( 1.0)
 434     * vec1 32 ssa_4 = load_const (-1.0)
 435     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 436     * vec1 32 ssa_6 = mov ssa_5.x
 437     * vec1 1 ssa_7 = flt ssa_6, ssa_4
 438     *
 439     * if ssa_7 {
 440     *    vec1 32 ssa_8 = fadd ssa_6, ssa_3
 441     * } else {
 442     * }
 443     *
 444     * After:
 445     *
 446     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 447     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 448     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 449     * vec1 32 ssa_3 = load_const ( 1.0)
 450     * vec1 32 ssa_4 = load_const (-1.0)
 451     * vec4 32 ssa_5 = fadd ssa_0, ssa_2
 452     * vec1 32 ssa_6 = mov ssa_5.x
 453     * vec1 32 ssa_9 = fneg ssa_4
 454     * vec1 32 ssa_10 = fadd ssa_6, ssa_9
 455     * vec1 32 ssa_11 = load_const ( 0.0)
 456     * vec1 1 ssa_12 = flt ssa_10, ssa_11
 457     * vec1 32 ssa_13 = mov ssa_10
 458     * vec1 1 ssa_14 = mov ssa_12
 459     *
 460     * if ssa_14 {
 461     * } else {
 462     * }
 463     */
 464    nir_ssa_def *one = nir_imm_float(&bld, 1.0f);
 465    nir_ssa_def *neg_one = nir_imm_float(&bld, -1.0f);
 466    nir_ssa_def *a = nir_channel(&bld, nir_fadd(&bld, v1, v3), 0);
 467
 468    nir_ssa_def *flt = nir_flt(&bld, a, neg_one);
 469
 470    nir_if *nif = nir_push_if(&bld, flt);
 471
 472    nir_fadd(&bld, a, one);
 473
 474    nir_pop_if(&bld, nif);
 475
 476    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 477 }
 478
 479 TEST_F(comparison_pre_test, swizzle_of_same_immediate_vector)
 480 {
 481    /* Before:
 482     *
 483     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 484     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 485     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 486     * vec4 32 ssa_3 = fadd ssa_0, ssa_2
 487     * vec1 1 ssa_4 = flt ssa_0.x, ssa_3.x
 488     *
 489     * if ssa_4 {
 490     *    vec1 32 ssa_5 = fadd ssa_0.w, ssa_3.x
 491     * } else {
 492     * }
 493     */
 494    nir_ssa_def *a = nir_fadd(&bld, v1, v3);
 495
 496    nir_alu_instr *flt = nir_alu_instr_create(bld.shader, nir_op_flt);
 497
 498    flt->src[0].src = nir_src_for_ssa(v1);
 499    flt->src[1].src = nir_src_for_ssa(a);
 500
 501    memcpy(&flt->src[0].swizzle, xxxx, sizeof(xxxx));
 502    memcpy(&flt->src[1].swizzle, xxxx, sizeof(xxxx));
 503
 504    nir_builder_alu_instr_finish_and_insert(&bld, flt);
 505
 506    flt->dest.dest.ssa.num_components = 1;
 507    flt->dest.write_mask = 1;
 508
 509    nir_if *nif = nir_push_if(&bld, &flt->dest.dest.ssa);
 510
 511    nir_alu_instr *fadd = nir_alu_instr_create(bld.shader, nir_op_fadd);
 512
 513    fadd->src[0].src = nir_src_for_ssa(v1);
 514    fadd->src[1].src = nir_src_for_ssa(a);
 515
 516    memcpy(&fadd->src[0].swizzle, wwww, sizeof(wwww));
 517    memcpy(&fadd->src[1].swizzle, xxxx, sizeof(xxxx));
 518
 519    nir_builder_alu_instr_finish_and_insert(&bld, fadd);
 520
 521    fadd->dest.dest.ssa.num_components = 1;
 522    fadd->dest.write_mask = 1;
 523
 524    nir_pop_if(&bld, nif);
 525
 526    EXPECT_TRUE(nir_opt_comparison_pre_impl(bld.impl));
 527 }
 528
 529 TEST_F(comparison_pre_test, non_scalar_add_result)
 530 {
 531    /* The optimization pass should not do anything because the result of the
 532     * fadd is not a scalar.
 533     *
 534     * Before:
 535     *
 536     * vec4 32 ssa_0 = load_const (-2.0, -1.0,  1.0,  2.0)
 537     * vec4 32 ssa_1 = load_const ( 2.0,  1.0, -1.0, -2.0)
 538     * vec4 32 ssa_2 = load_const ( 3.0,  4.0,  5.0,  6.0)
 539     * vec4 32 ssa_3 = fadd ssa_0, ssa_2
 540     * vec1 1 ssa_4 = flt ssa_0.x, ssa_3.x
 541     *
 542     * if ssa_4 {
 543     *    vec2 32 ssa_5 = fadd ssa_1.xx, ssa_3.xx
 544     * } else {
 545     * }
 546     *
 547     * After:
 548     *
 549     * No change.
 550     */
 551    nir_ssa_def *a = nir_fadd(&bld, v1, v3);
 552
 553    nir_alu_instr *flt = nir_alu_instr_create(bld.shader, nir_op_flt);
 554
 555    flt->src[0].src = nir_src_for_ssa(v1);
 556    flt->src[1].src = nir_src_for_ssa(a);
 557
 558    memcpy(&flt->src[0].swizzle, xxxx, sizeof(xxxx));
 559    memcpy(&flt->src[1].swizzle, xxxx, sizeof(xxxx));
 560
 561    nir_builder_alu_instr_finish_and_insert(&bld, flt);
 562
 563    flt->dest.dest.ssa.num_components = 1;
 564    flt->dest.write_mask = 1;
 565
 566    nir_if *nif = nir_push_if(&bld, &flt->dest.dest.ssa);
 567
 568    nir_alu_instr *fadd = nir_alu_instr_create(bld.shader, nir_op_fadd);
 569
 570    fadd->src[0].src = nir_src_for_ssa(v2);
 571    fadd->src[1].src = nir_src_for_ssa(a);
 572
 573    memcpy(&fadd->src[0].swizzle, xxxx, sizeof(xxxx));
 574    memcpy(&fadd->src[1].swizzle, xxxx, sizeof(xxxx));
 575
 576    nir_builder_alu_instr_finish_and_insert(&bld, fadd);
 577
 578    fadd->dest.dest.ssa.num_components = 2;
 579    fadd->dest.write_mask = 3;
 580
 581    nir_pop_if(&bld, nif);
 582
 583    EXPECT_FALSE(nir_opt_comparison_pre_impl(bld.impl));
 584 }