src/mesa/state_tracker/tests/test_glsl_to_tgsi_array_merge.cpp

   1 /*
   2  * Copyright © 2017 Gert Wollny
   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
  24
  25 #include "st_tests_common.h"
  26
  27 #include "tgsi/tgsi_ureg.h"
  28 #include "tgsi/tgsi_info.h"
  29 #include "mesa/program/prog_instruction.h"
  30 #include "gtest/gtest.h"
  31
  32 #include <utility>
  33 #include <algorithm>
  34 #include <iostream>
  35
  36 using std::vector;
  37
  38 using namespace tgsi_array_merge;
  39 using ArrayLiveRangeMerge=testing::Test;
  40
  41 TEST_F(ArrayLiveRangeMerge, SimpleLiveRange)
  42 {
  43    array_live_range a1(1, 10, 1, 5, WRITEMASK_X);
  44    array_live_range a2(2, 5, 6, 10, WRITEMASK_X);
  45
  46    array_live_range::merge(&a1, &a2);
  47
  48    EXPECT_EQ(a1.array_id(), 1);
  49    EXPECT_EQ(a1.begin(), 1);
  50    EXPECT_EQ(a1.end(), 10);
  51    EXPECT_EQ(a1.target_array_id(), 0);
  52    EXPECT_EQ(a1.used_components(), 1);
  53    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
  54
  55    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
  56    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
  57    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
  58    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
  59
  60    EXPECT_EQ(a2.array_id(), 2);
  61    EXPECT_EQ(a2.begin(), 6);
  62    EXPECT_EQ(a2.end(), 10);
  63    EXPECT_EQ(a2.target_array_id(), 1);
  64    EXPECT_EQ(a2.used_components(), 1);
  65    EXPECT_EQ(a2.access_mask(), WRITEMASK_X);
  66
  67    EXPECT_EQ(a2.remap_one_swizzle(0), 0);
  68    EXPECT_EQ(a2.remap_one_swizzle(1), 1);
  69    EXPECT_EQ(a2.remap_one_swizzle(2), 2);
  70    EXPECT_EQ(a2.remap_one_swizzle(3), 3);
  71 }
  72
  73 TEST_F(ArrayLiveRangeMerge, SimpleLiveRangeInverse)
  74 {
  75    array_live_range a1(1, 5, 1, 5, WRITEMASK_X);
  76    array_live_range a2(2, 10, 6, 10, WRITEMASK_X);
  77
  78    array_live_range::merge(&a1, &a2);
  79
  80    EXPECT_EQ(a1.array_id(), 1);
  81    EXPECT_EQ(a1.begin(), 1);
  82    EXPECT_EQ(a1.end(), 5);
  83    EXPECT_EQ(a1.target_array_id(), 2);
  84    EXPECT_EQ(a1.used_components(), 1);
  85    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
  86
  87    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
  88    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
  89    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
  90    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
  91
  92    EXPECT_EQ(a2.array_id(), 2);
  93    EXPECT_EQ(a2.begin(), 1);
  94    EXPECT_EQ(a2.end(), 10);
  95    EXPECT_EQ(a2.target_array_id(), 0);
  96    EXPECT_EQ(a2.used_components(), 1);
  97    EXPECT_EQ(a2.access_mask(), WRITEMASK_X);
  98
  99    EXPECT_EQ(a2.remap_one_swizzle(0), 0);
 100    EXPECT_EQ(a2.remap_one_swizzle(1), 1);
 101    EXPECT_EQ(a2.remap_one_swizzle(2), 2);
 102    EXPECT_EQ(a2.remap_one_swizzle(3), 3);
 103 }
 104
 105
 106 TEST_F(ArrayLiveRangeMerge, Interleave_x_xyz)
 107 {
 108    array_live_range a1(1, 10, 1, 10, WRITEMASK_X);
 109    array_live_range a2(2, 9, 1, 10, WRITEMASK_XYZ);
 110
 111    array_live_range::interleave(&a1, &a2);
 112
 113    EXPECT_EQ(a1.array_id(), 1);
 114    EXPECT_EQ(a1.begin(), 1);
 115    EXPECT_EQ(a1.end(), 10);
 116    EXPECT_EQ(a1.array_length(), 10u);
 117    EXPECT_EQ(a1.target_array_id(), 0);
 118    EXPECT_EQ(a1.used_components(), 4);
 119    EXPECT_EQ(a1.access_mask(), WRITEMASK_XYZW);
 120
 121    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
 122    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
 123    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
 124    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
 125
 126    EXPECT_EQ(a2.array_id(), 2);
 127    EXPECT_EQ(a2.begin(), 1);
 128    EXPECT_EQ(a2.end(), 10);
 129    EXPECT_EQ(a2.target_array_id(), 1);
 130
 131    EXPECT_EQ(a2.remap_one_swizzle(0), 1);
 132    EXPECT_EQ(a2.remap_one_swizzle(1), 2);
 133    EXPECT_EQ(a2.remap_one_swizzle(2), 3);
 134    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 135 }
 136
 137 TEST_F(ArrayLiveRangeMerge, Interleave_xyz_x)
 138 {
 139    array_live_range a1(1, 10, 1, 10, WRITEMASK_XYZ);
 140    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 141
 142    array_live_range::interleave(&a1, &a2);
 143
 144    EXPECT_EQ(a1.array_id(), 1);
 145    EXPECT_EQ(a1.begin(), 1);
 146    EXPECT_EQ(a1.end(), 10);
 147    EXPECT_EQ(a1.array_length(), 10u);
 148    EXPECT_EQ(a1.target_array_id(), 0);
 149    EXPECT_EQ(a1.used_components(), 4);
 150    EXPECT_EQ(a1.access_mask(), WRITEMASK_XYZW);
 151
 152    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
 153    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
 154    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
 155    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
 156
 157    EXPECT_EQ(a2.array_id(), 2);
 158    EXPECT_EQ(a2.begin(), 1);
 159    EXPECT_EQ(a2.end(), 10);
 160    EXPECT_EQ(a2.target_array_id(), 1);
 161
 162    EXPECT_EQ(a2.remap_one_swizzle(0), 3);
 163    EXPECT_EQ(a2.remap_one_swizzle(1), -1);
 164    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 165    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 166 }
 167
 168
 169 TEST_F(ArrayLiveRangeMerge, SimpleInterleave)
 170 {
 171    array_live_range a1(1, 10, 1, 10, WRITEMASK_X);
 172    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 173
 174    array_live_range::interleave(&a1, &a2);
 175
 176    EXPECT_EQ(a1.array_id(), 1);
 177    EXPECT_EQ(a1.begin(), 1);
 178    EXPECT_EQ(a1.end(), 10);
 179    EXPECT_EQ(a1.array_length(), 10u);
 180    EXPECT_EQ(a1.target_array_id(), 0);
 181    EXPECT_EQ(a1.used_components(), 2);
 182    EXPECT_EQ(a1.access_mask(), WRITEMASK_XY);
 183
 184    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
 185    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
 186    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
 187    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
 188
 189    EXPECT_EQ(a2.array_id(), 2);
 190    EXPECT_EQ(a2.begin(), 1);
 191    EXPECT_EQ(a2.end(), 10);
 192    EXPECT_EQ(a2.target_array_id(), 1);
 193
 194    EXPECT_EQ(a2.remap_one_swizzle(0), 1);
 195    EXPECT_EQ(a2.remap_one_swizzle(1), -1);
 196    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 197    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 198 }
 199
 200
 201 TEST_F(ArrayLiveRangeMerge, SimpleInterleaveInverse)
 202 {
 203    array_live_range a1(1, 8, 1, 10, WRITEMASK_X);
 204    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 205
 206    array_live_range::interleave(&a1, &a2);
 207
 208    EXPECT_EQ(a1.array_id(), 1);
 209    EXPECT_EQ(a1.begin(), 1);
 210    EXPECT_EQ(a1.end(), 10);
 211    EXPECT_EQ(a1.target_array_id(), 2);
 212
 213    EXPECT_EQ(a1.remap_one_swizzle(0), 1);
 214    EXPECT_EQ(a1.remap_one_swizzle(1), -1);
 215    EXPECT_EQ(a1.remap_one_swizzle(2), -1);
 216    EXPECT_EQ(a1.remap_one_swizzle(3), -1);
 217
 218    EXPECT_EQ(a2.array_id(), 2);
 219    EXPECT_EQ(a2.target_array_id(), 0);
 220    EXPECT_EQ(a2.begin(), 1);
 221    EXPECT_EQ(a2.end(), 10);
 222    EXPECT_EQ(a2.array_length(), 9u);
 223    EXPECT_EQ(a2.used_components(), 2);
 224    EXPECT_EQ(a2.access_mask(), WRITEMASK_XY);
 225 }
 226
 227
 228 TEST_F(ArrayLiveRangeMerge, InterleaveRiveRangeExtend)
 229 {
 230    array_live_range a1(1, 10, 2, 9, WRITEMASK_X);
 231    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 232
 233    array_live_range::interleave(&a1, &a2);
 234
 235    EXPECT_EQ(a1.array_id(), 1);
 236    EXPECT_EQ(a1.begin(), 1);
 237    EXPECT_EQ(a1.end(), 10);
 238    EXPECT_EQ(a1.array_length(), 10u);
 239    EXPECT_EQ(a1.target_array_id(), 0);
 240    EXPECT_EQ(a1.used_components(), 2);
 241    EXPECT_EQ(a1.access_mask(), WRITEMASK_XY);
 242
 243    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
 244    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
 245    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
 246    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
 247
 248    EXPECT_EQ(a2.array_id(), 2);
 249    EXPECT_EQ(a2.begin(), 1);
 250    EXPECT_EQ(a2.end(), 10);
 251    EXPECT_EQ(a2.target_array_id(), 1);
 252
 253    EXPECT_EQ(a2.remap_one_swizzle(0), 1);
 254    EXPECT_EQ(a2.remap_one_swizzle(1), -1);
 255    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 256    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 257 }
 258
 259 TEST_F(ArrayLiveRangeMerge, InterleaveLiveRangeExtendInverse)
 260 {
 261    array_live_range a1(1, 8, 2, 11, WRITEMASK_X);
 262    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 263
 264    array_live_range::interleave(&a1, &a2);
 265
 266    EXPECT_EQ(a1.array_id(), 1);
 267    EXPECT_EQ(a1.begin(), 2);
 268    EXPECT_EQ(a1.end(), 11);
 269    EXPECT_EQ(a1.target_array_id(), 2);
 270    EXPECT_EQ(a1.used_components(), 1);
 271    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
 272
 273    EXPECT_EQ(a1.remap_one_swizzle(0), 1);
 274    EXPECT_EQ(a1.remap_one_swizzle(1), -1);
 275    EXPECT_EQ(a1.remap_one_swizzle(2), -1);
 276    EXPECT_EQ(a1.remap_one_swizzle(3), -1);
 277
 278    EXPECT_EQ(a2.array_id(), 2);
 279    EXPECT_EQ(a2.begin(), 1);
 280    EXPECT_EQ(a2.end(), 11);
 281    EXPECT_EQ(a2.target_array_id(), 0);
 282    EXPECT_EQ(a2.used_components(), 2);
 283    EXPECT_EQ(a2.access_mask(), WRITEMASK_XY);
 284
 285    EXPECT_EQ(a2.remap_one_swizzle(0), 0);
 286    EXPECT_EQ(a2.remap_one_swizzle(1), 1);
 287    EXPECT_EQ(a2.remap_one_swizzle(2), 2);
 288    EXPECT_EQ(a2.remap_one_swizzle(3), 3);
 289 }
 290
 291 TEST_F(ArrayLiveRangeMerge, InterleaveChained)
 292 {
 293    array_live_range a1(1, 8, 2, 11, WRITEMASK_X);
 294    array_live_range a2(2, 9, 1, 10, WRITEMASK_X);
 295    array_live_range a3(3, 10, 1, 10, WRITEMASK_X);
 296
 297    array_live_range::interleave(&a1, &a2);
 298    array_live_range::interleave(&a2, &a3);
 299
 300    EXPECT_EQ(a1.array_id(), 1);
 301    EXPECT_EQ(a1.begin(), 2);
 302    EXPECT_EQ(a1.end(), 11);
 303    EXPECT_EQ(a1.target_array_id(), 2);
 304    EXPECT_EQ(a1.used_components(), 1);
 305    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
 306
 307    EXPECT_EQ(a1.remap_one_swizzle(0), 2);
 308    EXPECT_EQ(a1.remap_one_swizzle(1), -1);
 309    EXPECT_EQ(a1.remap_one_swizzle(2), -1);
 310    EXPECT_EQ(a1.remap_one_swizzle(3), -1);
 311
 312    EXPECT_EQ(a2.array_id(), 2);
 313    EXPECT_EQ(a2.begin(), 1);
 314    EXPECT_EQ(a2.end(), 11);
 315    EXPECT_EQ(a2.target_array_id(), 3);
 316    EXPECT_EQ(a2.used_components(), 2);
 317    EXPECT_EQ(a2.access_mask(), WRITEMASK_XY);
 318
 319    EXPECT_EQ(a2.remap_one_swizzle(0), 1);
 320    EXPECT_EQ(a2.remap_one_swizzle(1), 2);
 321    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 322    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 323
 324    EXPECT_EQ(a3.array_id(), 3);
 325    EXPECT_EQ(a3.begin(), 1);
 326    EXPECT_EQ(a3.end(), 11);
 327    EXPECT_EQ(a3.target_array_id(), 0);
 328    EXPECT_EQ(a3.used_components(), 3);
 329    EXPECT_EQ(a3.access_mask(), WRITEMASK_XYZ);
 330
 331    EXPECT_EQ(a3.remap_one_swizzle(0), 0);
 332    EXPECT_EQ(a3.remap_one_swizzle(1), 1);
 333    EXPECT_EQ(a3.remap_one_swizzle(2), 2);
 334    EXPECT_EQ(a3.remap_one_swizzle(3), 3);
 335 }
 336
 337 TEST_F(ArrayLiveRangeMerge, MergeInterleaveChained)
 338 {
 339    array_live_range a1(1, 8, 1, 5, WRITEMASK_X);
 340    array_live_range a2(2, 9, 6, 10, WRITEMASK_X);
 341    array_live_range a3(3, 10, 1, 10, WRITEMASK_X);
 342
 343    array_live_range::merge(&a1, &a2);
 344    array_live_range::interleave(&a2, &a3);
 345
 346    EXPECT_EQ(a1.array_id(), 1);
 347    EXPECT_EQ(a1.begin(), 1);
 348    EXPECT_EQ(a1.end(), 5);
 349    EXPECT_EQ(a1.target_array_id(), 2);
 350    EXPECT_EQ(a1.used_components(), 1);
 351    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
 352
 353    EXPECT_EQ(a1.remap_one_swizzle(0), 1);
 354    EXPECT_EQ(a1.remap_one_swizzle(1), -1);
 355    EXPECT_EQ(a1.remap_one_swizzle(2), -1);
 356    EXPECT_EQ(a1.remap_one_swizzle(3), -1);
 357
 358    EXPECT_EQ(a2.array_id(), 2);
 359    EXPECT_EQ(a2.begin(), 1);
 360    EXPECT_EQ(a2.end(), 10);
 361    EXPECT_EQ(a2.target_array_id(), 3);
 362    EXPECT_EQ(a2.used_components(), 1);
 363    EXPECT_EQ(a2.access_mask(), WRITEMASK_X);
 364
 365    EXPECT_EQ(a2.remap_one_swizzle(0), 1);
 366    EXPECT_EQ(a2.remap_one_swizzle(1), -1);
 367    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 368    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 369
 370    EXPECT_EQ(a3.array_id(), 3);
 371    EXPECT_EQ(a3.begin(), 1);
 372    EXPECT_EQ(a3.end(), 10);
 373    EXPECT_EQ(a3.target_array_id(), 0);
 374    EXPECT_EQ(a3.used_components(), 2);
 375    EXPECT_EQ(a3.access_mask(), WRITEMASK_XY);
 376
 377    EXPECT_EQ(a3.remap_one_swizzle(0), 0);
 378    EXPECT_EQ(a3.remap_one_swizzle(1), 1);
 379    EXPECT_EQ(a3.remap_one_swizzle(2), 2);
 380    EXPECT_EQ(a3.remap_one_swizzle(3), 3);
 381 }
 382
 383 TEST_F(ArrayLiveRangeMerge, MergeMergeAndInterleave)
 384 {
 385    array_live_range a1(1, 5, 1, 5, WRITEMASK_X);
 386    array_live_range a2(2, 4, 6, 7, WRITEMASK_X);
 387    array_live_range a3(3, 3, 1, 5, WRITEMASK_X);
 388    array_live_range a4(4, 2, 6, 8, WRITEMASK_X);
 389
 390    array_live_range::merge(&a1, &a2);
 391    array_live_range::merge(&a3, &a4);
 392    array_live_range::interleave(&a1, &a3);
 393
 394    EXPECT_EQ(a1.array_id(), 1);
 395    EXPECT_EQ(a1.begin(), 1);
 396    EXPECT_EQ(a1.end(), 8);
 397    EXPECT_EQ(a1.target_array_id(), 0);
 398    EXPECT_EQ(a1.used_components(), 2);
 399    EXPECT_EQ(a1.access_mask(), WRITEMASK_XY);
 400
 401    EXPECT_EQ(a1.remap_one_swizzle(0), 0);
 402    EXPECT_EQ(a1.remap_one_swizzle(1), 1);
 403    EXPECT_EQ(a1.remap_one_swizzle(2), 2);
 404    EXPECT_EQ(a1.remap_one_swizzle(3), 3);
 405
 406    EXPECT_EQ(a2.array_id(), 2);
 407    EXPECT_EQ(a2.begin(), 6);
 408    EXPECT_EQ(a2.end(), 7);
 409    EXPECT_EQ(a2.target_array_id(), 1);
 410    EXPECT_EQ(a2.used_components(), 1);
 411    EXPECT_EQ(a2.access_mask(), WRITEMASK_X);
 412
 413    EXPECT_EQ(a2.remap_one_swizzle(0), 0);
 414    EXPECT_EQ(a2.remap_one_swizzle(1), 1);
 415    EXPECT_EQ(a2.remap_one_swizzle(2), 2);
 416    EXPECT_EQ(a2.remap_one_swizzle(3), 3);
 417
 418    EXPECT_EQ(a3.array_id(), 3);
 419    EXPECT_EQ(a3.begin(), 1);
 420    EXPECT_EQ(a3.end(), 8);
 421    EXPECT_EQ(a3.target_array_id(), 1);
 422    EXPECT_EQ(a3.used_components(), 1);
 423    EXPECT_EQ(a3.access_mask(), WRITEMASK_X);
 424
 425    EXPECT_EQ(a3.remap_one_swizzle(0), 1);
 426    EXPECT_EQ(a3.remap_one_swizzle(1), -1);
 427    EXPECT_EQ(a3.remap_one_swizzle(2), -1);
 428    EXPECT_EQ(a3.remap_one_swizzle(3), -1);
 429
 430    EXPECT_EQ(a4.array_id(), 4);
 431    EXPECT_EQ(a4.begin(), 6);
 432    EXPECT_EQ(a4.end(), 8);
 433    EXPECT_EQ(a4.target_array_id(), 3);
 434    EXPECT_EQ(a4.used_components(), 1);
 435    EXPECT_EQ(a4.access_mask(), WRITEMASK_X);
 436
 437    EXPECT_EQ(a4.remap_one_swizzle(0), 1);
 438    EXPECT_EQ(a4.remap_one_swizzle(1), -1);
 439    EXPECT_EQ(a4.remap_one_swizzle(2), -1);
 440    EXPECT_EQ(a4.remap_one_swizzle(3), -1);
 441
 442 }
 443
 444
 445 TEST_F(ArrayLiveRangeMerge, MergeInterleaveMergeInterleaveChained)
 446 {
 447    array_live_range a1(1, 8, 1, 5, WRITEMASK_X);
 448    array_live_range a2(2, 9, 6, 10, WRITEMASK_X);
 449    array_live_range a3(3, 10, 1, 10, WRITEMASK_X);
 450    array_live_range a4(4, 11, 11, 20, WRITEMASK_XY);
 451    array_live_range a5(5, 15, 5, 20, WRITEMASK_XY);
 452
 453    array_live_range::merge(&a1, &a2);
 454    array_live_range::interleave(&a2, &a3);    // a2 -> a3
 455    array_live_range::merge(&a3, &a4);
 456    array_live_range::interleave(&a4, &a5);    // a4 -> a5
 457
 458
 459    EXPECT_EQ(a1.array_id(), 1);
 460    EXPECT_EQ(a1.begin(), 1);
 461    EXPECT_EQ(a1.end(), 5);
 462    EXPECT_EQ(a1.target_array_id(), 2);
 463    EXPECT_EQ(a1.used_components(), 1);
 464    EXPECT_EQ(a1.access_mask(), WRITEMASK_X);
 465
 466    EXPECT_EQ(a1.remap_one_swizzle(0), 3);
 467    EXPECT_EQ(a1.remap_one_swizzle(1), -1);
 468    EXPECT_EQ(a1.remap_one_swizzle(2), -1);
 469    EXPECT_EQ(a1.remap_one_swizzle(3), -1);
 470
 471    EXPECT_EQ(a2.array_id(), 2);
 472    EXPECT_EQ(a2.begin(), 1);
 473    EXPECT_EQ(a2.end(), 10);
 474    EXPECT_EQ(a2.target_array_id(), 3);
 475    EXPECT_EQ(a2.used_components(), 1);
 476    EXPECT_EQ(a2.access_mask(), WRITEMASK_X);
 477
 478    EXPECT_EQ(a2.remap_one_swizzle(0), 3);
 479    EXPECT_EQ(a2.remap_one_swizzle(1), -1);
 480    EXPECT_EQ(a2.remap_one_swizzle(2), -1);
 481    EXPECT_EQ(a2.remap_one_swizzle(3), -1);
 482
 483    EXPECT_EQ(a3.array_id(), 3);
 484    EXPECT_EQ(a3.begin(), 1);
 485    EXPECT_EQ(a3.end(), 10);
 486    EXPECT_EQ(a3.target_array_id(), 4);
 487    EXPECT_EQ(a3.used_components(), 2);
 488    EXPECT_EQ(a3.access_mask(), WRITEMASK_XY);
 489
 490    EXPECT_EQ(a3.remap_one_swizzle(0), 2);
 491    EXPECT_EQ(a3.remap_one_swizzle(1), 3);
 492    EXPECT_EQ(a3.remap_one_swizzle(2), -1);
 493    EXPECT_EQ(a3.remap_one_swizzle(3), -1);
 494
 495    EXPECT_EQ(a4.array_id(), 4);
 496    EXPECT_EQ(a4.begin(), 1);
 497    EXPECT_EQ(a4.end(), 20);
 498    EXPECT_EQ(a4.target_array_id(), 5);
 499    EXPECT_EQ(a4.used_components(), 2);
 500    EXPECT_EQ(a4.access_mask(), WRITEMASK_XY);
 501
 502    EXPECT_EQ(a4.remap_one_swizzle(0), 2);
 503    EXPECT_EQ(a4.remap_one_swizzle(1), 3);
 504    EXPECT_EQ(a4.remap_one_swizzle(2), -1);
 505    EXPECT_EQ(a4.remap_one_swizzle(3), -1);
 506
 507    EXPECT_EQ(a5.array_id(), 5);
 508    EXPECT_EQ(a5.begin(), 1);
 509    EXPECT_EQ(a5.end(), 20);
 510    EXPECT_EQ(a5.target_array_id(), 0);
 511    EXPECT_EQ(a5.used_components(), 4);
 512    EXPECT_EQ(a5.access_mask(), WRITEMASK_XYZW);
 513
 514    EXPECT_EQ(a5.remap_one_swizzle(0), 0);
 515    EXPECT_EQ(a5.remap_one_swizzle(1), 1);
 516    EXPECT_EQ(a5.remap_one_swizzle(2), 2);
 517    EXPECT_EQ(a5.remap_one_swizzle(3), 3);
 518 }
 519
 520 using ArrayMergeTest=testing::Test;
 521
 522 TEST_F(ArrayMergeTest, ArrayMergeTwoSwizzles)
 523 {
 524    vector<array_live_range> alt = {
 525       {1, 4, 1, 5, WRITEMASK_X},
 526       {2, 4, 2, 5, WRITEMASK_X},
 527    };
 528
 529    int8_t expect_swizzle[] = {1, -1, -1, -1};
 530    vector<array_remapping> expect = {
 531       {},
 532       {1, expect_swizzle},
 533    };
 534
 535    vector<array_remapping> result(alt.size() + 1);
 536
 537    get_array_remapping(2, &alt[0], &result[0]);
 538
 539    EXPECT_EQ(result[1], expect[0]);
 540    EXPECT_EQ(result[2], expect[1]);
 541
 542 }
 543
 544 TEST_F(ArrayMergeTest, ArrayMergeFourSwizzles)
 545 {
 546    vector<array_live_range> alt = {
 547       {1, 8, 1, 7, WRITEMASK_X},
 548       {2, 7, 2, 7, WRITEMASK_X},
 549       {3, 6, 3, 7, WRITEMASK_X},
 550       {4, 5, 4, 7, WRITEMASK_X},
 551    };
 552    int8_t expect_swizzle1[] = {1, -1, -1, -1};
 553    int8_t expect_swizzle2[] = {2, -1, -1, -1};
 554    int8_t expect_swizzle3[] = {3, -1, -1, -1};
 555
 556    vector<array_remapping> expect = {
 557       {},
 558       {1, expect_swizzle1},
 559       {1, expect_swizzle2},
 560       {1, expect_swizzle3},
 561    };
 562
 563    vector<array_remapping> result(alt.size() + 1);
 564
 565    get_array_remapping(4, &alt[0], &result[0]);
 566
 567    EXPECT_EQ(result[1], expect[0]);
 568    EXPECT_EQ(result[2], expect[1]);
 569    EXPECT_EQ(result[3], expect[2]);
 570    EXPECT_EQ(result[4], expect[3]);
 571
 572 }
 573
 574
 575 TEST_F(ArrayMergeTest, SimpleChainMerge)
 576 {
 577    vector<array_live_range> input = {
 578       {1, 3, 1, 5, WRITEMASK_XYZW},
 579       {2, 2, 6, 7, WRITEMASK_XYZW},
 580    };
 581
 582    int8_t expect_swizzle[] = {0, 1, 2, 3};
 583    vector<array_remapping> expect = {
 584       {},
 585       {1, expect_swizzle},
 586    };
 587
 588    vector<array_remapping> result(3);
 589    get_array_remapping(2, &input[0], &result[0]);
 590
 591    EXPECT_EQ(result[1], expect[0]);
 592    EXPECT_EQ(result[2], expect[1]);
 593 }
 594
 595 TEST_F(ArrayMergeTest, MergeAndInterleave)
 596 {
 597    vector<array_live_range> input = {
 598       {1, 5, 1, 5, WRITEMASK_X},
 599       {2, 4, 6, 7, WRITEMASK_X},
 600       {3, 3, 1, 5, WRITEMASK_X},
 601       {4, 2, 6, 7, WRITEMASK_X},
 602    };
 603
 604    int8_t expect_swizzle1[] = {0,  1,  2,  3};
 605    int8_t expect_swizzle2[] = {1, -1, -1, -1};
 606    int8_t expect_swizzle3[] = {1, -1, -1, -1};
 607
 608    vector<array_remapping> expect = {
 609       {},
 610       {1, expect_swizzle1},
 611       {1, expect_swizzle2},
 612       {1, expect_swizzle3}
 613    };
 614    vector<array_remapping> result(input.size() + 1);
 615    get_array_remapping(input.size(), &input[0], &result[0]);
 616
 617    EXPECT_EQ(result[1], expect[0]);
 618    EXPECT_EQ(result[2], expect[1]);
 619    EXPECT_EQ(result[3], expect[2]);
 620    EXPECT_EQ(result[4], expect[3]);
 621 }
 622
 623 TEST_F(ArrayMergeTest, MergeAndInterleave2)
 624 {
 625    vector<array_live_range> input = {
 626       {1, 5, 1, 5, WRITEMASK_X},
 627       {2, 4, 6, 7, WRITEMASK_X},
 628       {3, 3, 1, 8, WRITEMASK_XY},
 629       {4, 2, 6, 7, WRITEMASK_X},
 630    };
 631
 632    int8_t expect_swizzle1[] = {0,  1,  2,  3};
 633    int8_t expect_swizzle2[] = {1,  2, -1, -1};
 634    int8_t expect_swizzle3[] = {3, -1, -1, -1};
 635
 636    vector<array_remapping> expect = {
 637       {},
 638       {1, expect_swizzle1},
 639       {1, expect_swizzle2},
 640       {1, expect_swizzle3}
 641    };
 642    vector<array_remapping> result(input.size() + 1);
 643    get_array_remapping(input.size(), &input[0], &result[0]);
 644
 645    EXPECT_EQ(result[1], expect[0]);
 646    EXPECT_EQ(result[2], expect[1]);
 647    EXPECT_EQ(result[3], expect[2]);
 648    EXPECT_EQ(result[4], expect[3]);
 649 }
 650
 651
 652 TEST_F(ArrayMergeTest, MergeAndInterleave3)
 653 {
 654    vector<array_live_range> input = {
 655       {1, 5, 1, 5, WRITEMASK_X},
 656       {2, 4, 6, 7, WRITEMASK_XY},
 657       {3, 3, 1, 5, WRITEMASK_X}
 658    };
 659
 660    int8_t expect_swizzle1[] = {0, 1, 2, 3};
 661    int8_t expect_swizzle2[] = {1, -1, -1, -1};
 662
 663    vector<array_remapping> expect = {
 664       {},
 665       {1, expect_swizzle1},
 666       {1, expect_swizzle2}
 667    };
 668    vector<array_remapping> result(input.size() + 1);
 669    get_array_remapping(input.size(), &input[0], &result[0]);
 670
 671    EXPECT_EQ(result[1], expect[0]);
 672    EXPECT_EQ(result[2], expect[1]);
 673    EXPECT_EQ(result[3], expect[2]);
 674 }
 675
 676 TEST_F(ArrayMergeTest, MergeAndInterleave4)
 677 {
 678    vector<array_live_range> input = {
 679       {1, 7, 1, 5, WRITEMASK_X},
 680       {2, 6, 6, 7, WRITEMASK_XY},
 681       {3, 5, 1, 5, WRITEMASK_X},
 682       {4, 4, 8, 9, WRITEMASK_XYZ},
 683       {5, 3, 8, 9, WRITEMASK_W},
 684       {6, 2, 10, 11, WRITEMASK_XYZW},
 685    };
 686
 687    int8_t expect_swizzle1[] = {0, 1,  2,  3};
 688    int8_t expect_swizzle2[] = {1, -1, -1, -1};
 689    int8_t expect_swizzle3[] = {0, 1, 2, 3};
 690    int8_t expect_swizzle4[] = {-1, -1, -1, 3};
 691    int8_t expect_swizzle5[] = {0, 1, 2, 3};
 692
 693    vector<array_remapping> expect = {
 694       {},
 695       {1, expect_swizzle1},
 696       {1, expect_swizzle2},
 697       {1, expect_swizzle3}, /* W from below will be interleaved in */
 698       {1, expect_swizzle4},
 699       {1, expect_swizzle5}
 700    };
 701    vector<array_remapping> result(input.size() + 1);
 702    get_array_remapping(input.size(), &input[0], &result[0]);
 703
 704    EXPECT_EQ(result[1], expect[0]);
 705    EXPECT_EQ(result[2], expect[1]);
 706    EXPECT_EQ(result[3], expect[2]);
 707    EXPECT_EQ(result[4], expect[3]);
 708    EXPECT_EQ(result[5], expect[4]);
 709    EXPECT_EQ(result[6], expect[5]);
 710
 711 }
 712
 713 TEST_F(ArrayMergeTest, MergeAndInterleave5)
 714 {
 715    vector<array_live_range> input = {
 716       {1, 7, 1, 5, WRITEMASK_X},
 717       {2, 6, 1, 3, WRITEMASK_X},
 718       {3, 5, 4, 5, WRITEMASK_X},
 719       {4, 4, 6, 10, WRITEMASK_XY},
 720       {5, 8, 1, 10, WRITEMASK_XY}
 721    };
 722
 723    /* 1. merge 3 into 2
 724     * 2. interleave 2 into 1 (x -> y) --- (y -> w)
 725     * 3. merge 4 into 1                 /
 726     * 4. interleave 1 into 5 (x,y - z,w)
 727     */
 728
 729    /* swizzle1 holds the summary mask */
 730    int8_t expect_swizzle1[] = {2,  3, -1, -1};
 731    int8_t expect_swizzle2[] = {3, -1, -1, -1};
 732    int8_t expect_swizzle3[] = {3, -1, -1, -1};
 733    int8_t expect_swizzle4[] = {2,  3, -1, -1};
 734
 735    vector<array_remapping> expect = {
 736       {5, expect_swizzle1},
 737       {5, expect_swizzle2},
 738       {5, expect_swizzle3},
 739       {5, expect_swizzle4},
 740       {}
 741    };
 742    vector<array_remapping> result(input.size() + 1);
 743    get_array_remapping(input.size(), &input[0], &result[0]);
 744
 745    EXPECT_EQ(result[1], expect[0]);
 746    EXPECT_EQ(result[2], expect[1]);
 747    EXPECT_EQ(result[3], expect[2]);
 748    EXPECT_EQ(result[4], expect[3]);
 749    EXPECT_EQ(result[5], expect[4]);
 750
 751 }
 752
 753 /* Test two arrays life time simple */
 754 TEST_F(LifetimeEvaluatorExactTest, TwoArraysSimple)
 755 {
 756    const vector<FakeCodeline> code = {
 757       { TGSI_OPCODE_MOV , {MT(1, 1, WRITEMASK_XYZW)}, {MT(0, in0, "")}, {}, ARR()},
 758       { TGSI_OPCODE_MOV , {MT(2, 1, WRITEMASK_XYZW)}, {MT(0, in1, "")}, {}, ARR()},
 759       { TGSI_OPCODE_ADD , {MT(0,out0, WRITEMASK_XYZW)}, {MT(1,1,"xyzw"), MT(2,1,"xyzw")}, {}, ARR()},
 760       { TGSI_OPCODE_END}
 761    };
 762    run (code, array_lt_expect({{1,2,0,2, WRITEMASK_XYZW}, {2,2,1,2, WRITEMASK_XYZW}}));
 763 }
 764
 765 /* Test two arrays life time simple */
 766 TEST_F(LifetimeEvaluatorExactTest, TwoArraysSimpleSwizzleX_Y)
 767 {
 768    const vector<FakeCodeline> code = {
 769       { TGSI_OPCODE_MOV , {MT(1, 1, WRITEMASK_X)}, {MT(0, in0, "")}, {}, ARR()},
 770       { TGSI_OPCODE_MOV , {MT(2, 1, WRITEMASK_Y)}, {MT(0, in1, "")}, {}, ARR()},
 771       { TGSI_OPCODE_ADD , {MT(0,out0,1)}, {MT(1,1,"x"), MT(2,1,"y")}, {}, ARR()},
 772       { TGSI_OPCODE_END}
 773    };
 774    run (code, array_lt_expect({{1, 2, 0, 2, WRITEMASK_X}, {2, 2, 1, 2, WRITEMASK_Y}}));
 775 }
 776
 777 /* Test array written before loop and read inside, must survive the loop */
 778 TEST_F(LifetimeEvaluatorExactTest, ArraysWriteBeforLoopReadInside)
 779 {
 780    const vector<FakeCodeline> code = {
 781       { TGSI_OPCODE_MOV, {1}, {in1}, {}},
 782       { TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_X)}, {MT(0, in0, "")}, {}, ARR()},
 783       { TGSI_OPCODE_BGNLOOP },
 784       { TGSI_OPCODE_ADD, {MT(0,1, WRITEMASK_X)}, {MT(1,1,"x"), {MT(0,1, "x")}}, {}, ARR()},
 785       { TGSI_OPCODE_ENDLOOP },
 786       { TGSI_OPCODE_MOV, {out0}, {1}, {}},
 787       { TGSI_OPCODE_END}
 788    };
 789    run (code, array_lt_expect({{1, 1, 1, 4, WRITEMASK_X}}));
 790 }
 791
 792 /* Test array written conditionally in loop must survive the whole loop */
 793 TEST_F(LifetimeEvaluatorExactTest, ArraysConditionalWriteInNestedLoop)
 794 {
 795    const vector<FakeCodeline> code = {
 796       { TGSI_OPCODE_MOV, {1}, {in1}, {}},
 797       { TGSI_OPCODE_BGNLOOP },
 798       {   TGSI_OPCODE_BGNLOOP },
 799       {     TGSI_OPCODE_IF, {}, {1}, {}},
 800       {       TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_Z)}, {MT(0, in0, "")}, {}, ARR()},
 801       {     TGSI_OPCODE_ENDIF },
 802       {     TGSI_OPCODE_ADD, {MT(0,1, WRITEMASK_X)}, {MT(1,1,"z"), {MT(0,1, "x")}}, {}, ARR()},
 803       {   TGSI_OPCODE_ENDLOOP },
 804       { TGSI_OPCODE_ENDLOOP },
 805       { TGSI_OPCODE_MOV, {out0}, {1}, {}},
 806       { TGSI_OPCODE_END}
 807    };
 808    run (code, array_lt_expect({{1, 1, 1, 8, WRITEMASK_Z}}));
 809 }
 810
 811 /* Test array read conditionally in loop before write must
 812  * survive the whole loop
 813  */
 814 TEST_F(LifetimeEvaluatorExactTest, ArraysConditionalReadBeforeWriteInNestedLoop)
 815 {
 816    const vector<FakeCodeline> code = {
 817       { TGSI_OPCODE_MOV, {1}, {in1}, {}},
 818       { TGSI_OPCODE_BGNLOOP },
 819       {   TGSI_OPCODE_BGNLOOP },
 820       {     TGSI_OPCODE_IF, {}, {1}, {}},
 821       {     TGSI_OPCODE_ADD, {MT(0,1, WRITEMASK_X)}, {MT(1,1,"z"), {MT(0,1, "x")}}, {}, ARR()},
 822       {     TGSI_OPCODE_ENDIF },
 823       {       TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_Z)}, {MT(0, in0, "")}, {}, ARR()},
 824       {   TGSI_OPCODE_ENDLOOP },
 825       { TGSI_OPCODE_ENDLOOP },
 826       { TGSI_OPCODE_MOV, {out0}, {1}, {}},
 827       { TGSI_OPCODE_END}
 828    };
 829    run (code, array_lt_expect({{1, 1, 1, 8, WRITEMASK_Z}}));
 830 }
 831
 832
 833 /* Test array written conditionally in loop must survive the whole loop */
 834 TEST_F(LifetimeEvaluatorExactTest, ArraysConditionalWriteInNestedLoop2)
 835 {
 836    const vector<FakeCodeline> code = {
 837       { TGSI_OPCODE_MOV, {1}, {in1}, {}},
 838       { TGSI_OPCODE_BGNLOOP },
 839       {   TGSI_OPCODE_BGNLOOP },
 840       {     TGSI_OPCODE_IF, {}, {1}, {}},
 841       {       TGSI_OPCODE_BGNLOOP },
 842       {         TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_Z)}, {MT(0, in0, "")}, {}, ARR()},
 843       {       TGSI_OPCODE_ENDLOOP },
 844       {     TGSI_OPCODE_ENDIF },
 845       {     TGSI_OPCODE_ADD, {MT(0,1, WRITEMASK_X)}, {MT(1,1,"z"), {MT(0,1, "x")}}, {}, ARR()},
 846       {   TGSI_OPCODE_ENDLOOP },
 847       { TGSI_OPCODE_ENDLOOP },
 848       { TGSI_OPCODE_MOV, {out0}, {1}, {}},
 849       { TGSI_OPCODE_END}
 850    };
 851    run (code, array_lt_expect({{1, 1, 1, 10, WRITEMASK_Z}}));
 852 }
 853
 854
 855 /* Test distinct loops */
 856 TEST_F(LifetimeEvaluatorExactTest, ArraysReadWriteInSeparateScopes)
 857 {
 858    const vector<FakeCodeline> code = {
 859       { TGSI_OPCODE_MOV, {1}, {in1}, {}},
 860       { TGSI_OPCODE_BGNLOOP },
 861       {   TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_W)}, {MT(0, in0, "")}, {}, ARR()},
 862       { TGSI_OPCODE_ENDLOOP },
 863       { TGSI_OPCODE_BGNLOOP },
 864       {   TGSI_OPCODE_ADD, {MT(0,1, WRITEMASK_X)}, {MT(1,1,"w"), {MT(0,1, "x")}}, {}, ARR()},
 865       { TGSI_OPCODE_ENDLOOP },
 866       { TGSI_OPCODE_MOV, {out0}, {1}, {}},
 867       { TGSI_OPCODE_END}
 868    };
 869    run (code, array_lt_expect({{1, 1, 2, 6, WRITEMASK_W}}));
 870 }
 871
 872 class ArrayRemapTest: public MesaTestWithMemCtx {
 873
 874 public:
 875    void run (const vector<FakeCodeline>& code,
 876              const vector<FakeCodeline>& expect,
 877              vector<unsigned> array_sizes,
 878              vector<array_remapping>& remapping) const;
 879
 880
 881 };
 882
 883 TEST_F(ArrayRemapTest, ApplyMerge)
 884 {
 885    vector<unsigned> array_sizes{0, 12, 11, 10, 9, 8, 7};
 886
 887    int8_t set_swizzle3[] = {1, -1, -1, -1};
 888    int8_t set_swizzle5[] = {3, -1, -1, -1};
 889    int8_t set_no_reswizzle[] = {0, 1, 2, 3};
 890
 891    vector<array_remapping> remapping = {
 892       {},
 893       array_remapping(),
 894       {1, set_no_reswizzle},
 895       {1, set_swizzle3},
 896       {1, set_no_reswizzle},
 897       {1, set_swizzle5},
 898       {1, set_no_reswizzle}
 899    };
 900
 901    const vector<FakeCodeline> code = {
 902       { TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_X)}, {MT(0, in0, "x")}, {}, ARR()},
 903       { TGSI_OPCODE_MOV, {MT(2, 2, WRITEMASK_XY)}, {MT(0, in0, "xy")}, {}, ARR()},
 904       { TGSI_OPCODE_MOV, {MT(3, 3, WRITEMASK_X)}, {MT(0, in0, "x")}, {}, ARR()},
 905       { TGSI_OPCODE_MOV, {MT(4, 4, WRITEMASK_XYZ)}, {MT(0, in0, "xyz")}, {}, ARR()},
 906       { TGSI_OPCODE_MOV, {MT(5, 5, WRITEMASK_X)}, {MT(0, in0, "x")}, {}, ARR()},
 907       { TGSI_OPCODE_MOV, {MT(6, 6, WRITEMASK_XYZW)}, {MT(0, in0, "xyzw")}, {}, ARR()},
 908
 909       { TGSI_OPCODE_ADD, {MT(0, out0, WRITEMASK_X)}, {MT(1, 1, "x"), MT(0, in0, "y")}, {}, ARR()},
 910       { TGSI_OPCODE_ADD, {MT(0, out0, WRITEMASK_YZ)}, {MT(2, 2, "xy"), MT(0, in0, "yz")}, {}, ARR()},
 911       { TGSI_OPCODE_MUL, {MT(0, out0, WRITEMASK_W)}, {MT(3, 3, "x"), MT(0, in0, "x")}, {}, ARR()},
 912       { TGSI_OPCODE_ADD, {MT(0, out1, WRITEMASK_XYZ)}, {MT(4, 4, "xyz"), MT(0, in0, "xyz")}, {}, ARR()},
 913       { TGSI_OPCODE_MAD, {MT(0, out1, WRITEMASK_W)}, {MT(5, 5, "x"), MT(3, 1, "x"), MT(1, 1, "x")}, {}, ARR()},
 914       { TGSI_OPCODE_ADD, {MT(0, out2, WRITEMASK_XYZW)}, {MT(6, 6, "xyzw"), MT(0, in0, "xyzw")}, {}, ARR()},
 915
 916       { TGSI_OPCODE_END}
 917    };
 918
 919    const vector<FakeCodeline> expect = {
 920       { TGSI_OPCODE_MOV, {MT(1, 1, WRITEMASK_X)}, {MT(0, in0, "x")}, {}, ARR()},
 921       { TGSI_OPCODE_MOV, {MT(1, 2, WRITEMASK_XY)}, {MT(0, in0, "xy")}, {}, ARR()},
 922       { TGSI_OPCODE_MOV, {MT(1, 3, WRITEMASK_Y)}, {MT(0, in0, "xx")}, {}, ARR()},
 923       { TGSI_OPCODE_MOV, {MT(1, 4, WRITEMASK_XYZ)}, {MT(0, in0, "xyz")}, {}, ARR()},
 924       { TGSI_OPCODE_MOV, {MT(1, 5, WRITEMASK_W)}, {MT(0, in0, "xxxx")}, {}, ARR()},
 925       { TGSI_OPCODE_MOV, {MT(1, 6, WRITEMASK_XYZW)}, {MT(0, in0, "xyzw")}, {}, ARR()},
 926
 927       { TGSI_OPCODE_ADD, {MT(0, out0, WRITEMASK_X)}, {MT(1, 1, "x"), MT(0, in0, "y")}, {}, ARR()},
 928       { TGSI_OPCODE_ADD, {MT(0, out0, WRITEMASK_YZ)}, {MT(1, 2, "xy"), MT(0, in0, "yz")}, {}, ARR()},
 929       { TGSI_OPCODE_MUL, {MT(0, out0, WRITEMASK_W)}, {MT(1, 3, "y"), MT(0, in0, "xx")}, {}, ARR()},
 930       { TGSI_OPCODE_ADD, {MT(0, out1, WRITEMASK_XYZ)}, {MT(1, 4, "xyz"), MT(0, in0, "xyz")}, {}, ARR()},
 931       { TGSI_OPCODE_MAD, {MT(0, out1, WRITEMASK_W)}, {MT(1, 5, "w"), MT(1, 1, "yyyy"), MT(1, 1, "xxxx")}, {}, ARR()},
 932       { TGSI_OPCODE_ADD, {MT(0, out2, WRITEMASK_XYZW)}, {MT(1, 6, "xyzw"), MT(0, in0, "xyzw")}, {}, ARR()},
 933       { TGSI_OPCODE_END}
 934    };
 935
 936    run(code, expect, array_sizes, remapping);
 937
 938 }
 939
 940 void ArrayRemapTest::run (const vector<FakeCodeline>& code,
 941                           const vector<FakeCodeline>& expect,
 942                           vector<unsigned> array_sizes,
 943                           vector<array_remapping>& remapping) const
 944 {
 945    FakeShader input(code);
 946    FakeShader expect_shader(expect);
 947    exec_list *program = input.get_program(mem_ctx);
 948
 949    int n_arrays = remap_arrays(array_sizes.size() - 1, &array_sizes[0],
 950          program, &remapping[0]);
 951
 952    EXPECT_EQ(n_arrays, expect_shader.get_num_arrays());
 953
 954    FakeShader remapped_program(program);
 955
 956    ASSERT_EQ(remapped_program.length(), expect_shader.length());
 957
 958    for (size_t i = 0; i < expect_shader.length(); i++) {
 959       EXPECT_EQ(remapped_program.line(i), expect_shader.line(i));
 960    }
 961
 962 }