← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/mesa/state_tracker/tests/st_tests_common.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/state_tracker/tests/st_tests_common.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
 
#include "st_tests_common.h"
25
 
 
26
 
#include "mesa/program/prog_instruction.h"
27
 
#include "tgsi/tgsi_info.h"
28
 
#include "tgsi/tgsi_ureg.h"
29
 
#include "compiler/glsl/list.h"
30
 
#include "gtest/gtest.h"
31
 
 
32
 
#include <utility>
33
 
#include <algorithm>
34
 
 
35
 
using std::vector;
36
 
using std::pair;
37
 
using std::make_pair;
38
 
using std::transform;
39
 
using std::copy;
40
 
using std::tuple;
41
 
 
42
 
 
43
 
/* Implementation of helper and test classes */
44
 
void *FakeCodeline::mem_ctx = nullptr;
45
 
 
46
 
FakeCodeline::FakeCodeline(tgsi_opcode _op, const vector<int>& _dst,
47
 
                           const vector<int>& _src, const vector<int>&_to):
48
 
   op(_op),
49
 
   max_temp_id(0),
50
 
   max_array_id(0)
51
 
{
52
 
   transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
53
 
             [this](int i) { return create_dst_register(i);});
54
 
 
55
 
   transform(_src.begin(), _src.end(), std::back_inserter(src),
56
 
             [this](int i) { return create_src_register(i);});
57
 
 
58
 
   transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
59
 
             [this](int i) { return create_src_register(i);});
60
 
 
61
 
}
62
 
 
63
 
FakeCodeline::FakeCodeline(tgsi_opcode _op, const vector<pair<int,int>>& _dst,
64
 
                           const vector<pair<int, const char *>>& _src,
65
 
                           const vector<pair<int, const char *>>&_to,
66
 
                           SWZ with_swizzle):
67
 
   op(_op),
68
 
   max_temp_id(0),
69
 
   max_array_id(0)
70
 
{
71
 
   (void)with_swizzle;
72
 
 
73
 
   transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
74
 
             [this](pair<int,int> r) {
75
 
      return create_dst_register(r.first, r.second);
76
 
   });
77
 
 
78
 
   transform(_src.begin(), _src.end(), std::back_inserter(src),
79
 
             [this](const pair<int,const char *>& r) {
80
 
      return create_src_register(r.first, r.second);
81
 
   });
82
 
 
83
 
   transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
84
 
             [this](const pair<int,const char *>& r) {
85
 
      return create_src_register(r.first, r.second);
86
 
   });
87
 
}
88
 
 
89
 
FakeCodeline::FakeCodeline(tgsi_opcode _op, const vector<tuple<int,int,int>>& _dst,
90
 
                           const vector<tuple<int,int,int>>& _src,
91
 
                           const vector<tuple<int,int,int>>&_to, RA with_reladdr):
92
 
   op(_op),
93
 
   max_temp_id(0),
94
 
   max_array_id(0)
95
 
{
96
 
   (void)with_reladdr;
97
 
 
98
 
   transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
99
 
             [this](const tuple<int,int,int>& r) {
100
 
      return create_dst_register(r);
101
 
   });
102
 
 
103
 
   transform(_src.begin(), _src.end(), std::back_inserter(src),
104
 
             [this](const tuple<int,int,int>& r) {
105
 
      return create_src_register(r);
106
 
   });
107
 
 
108
 
   transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
109
 
             [this](const tuple<int,int,int>& r) {
110
 
      return create_src_register(r);
111
 
   });
112
 
}
113
 
 
114
 
FakeCodeline::FakeCodeline(tgsi_opcode _op, const vector<tuple<int,int,int>>& _dst,
115
 
                           const vector<tuple<int,int, const char*>>& _src,
116
 
                           const vector<tuple<int,int, const char*>>&_to,
117
 
                           ARR with_array):
118
 
   FakeCodeline(_op)
119
 
{
120
 
   (void)with_array;
121
 
 
122
 
   transform(_dst.begin(), _dst.end(), std::back_inserter(dst),
123
 
             [this](const tuple<int,int,int>& r) {
124
 
      return create_array_dst_register(r);
125
 
   });
126
 
 
127
 
   transform(_src.begin(), _src.end(), std::back_inserter(src),
128
 
             [this](const tuple<int,int,const char*>& r) {
129
 
      return create_array_src_register(r);
130
 
   });
131
 
 
132
 
   transform(_to.begin(), _to.end(), std::back_inserter(tex_offsets),
133
 
             [this](const tuple<int,int,const char*>& r) {
134
 
      return create_array_src_register(r);
135
 
   });
136
 
 
137
 
}
138
 
 
139
 
FakeCodeline::FakeCodeline(const glsl_to_tgsi_instruction& instr):
140
 
   op(instr.op),
141
 
   max_temp_id(0),
142
 
   max_array_id(0)
143
 
{
144
 
   int nsrc = num_inst_src_regs(&instr);
145
 
   int ndst = num_inst_dst_regs(&instr);
146
 
 
147
 
   copy(instr.src, instr.src + nsrc, std::back_inserter(src));
148
 
   copy(instr.dst, instr.dst + ndst, std::back_inserter(dst));
149
 
 
150
 
   for (auto& s: src)
151
 
      read_reg(s);
152
 
 
153
 
   for (auto& d: dst)
154
 
      read_reg(d);
155
 
 
156
 
}
157
 
 
158
 
template <typename st_reg>
159
 
void FakeCodeline::read_reg(const st_reg& s)
160
 
{
161
 
   if (s.file == PROGRAM_ARRAY) {
162
 
      if (s.array_id > max_array_id)
163
 
         max_array_id = s.array_id;
164
 
      if (s.reladdr)
165
 
         read_reg(*s.reladdr);
166
 
      if (s.reladdr2)
167
 
         read_reg(*s.reladdr2);
168
 
   } else  if (s.file == PROGRAM_TEMPORARY) {
169
 
      if (s.index > max_temp_id)
170
 
         max_temp_id = s.index;
171
 
   }
172
 
}
173
 
 
174
 
void FakeCodeline::print(std::ostream& os) const
175
 
{
176
 
   const struct tgsi_opcode_info *info = tgsi_get_opcode_info(op);
177
 
   os << tgsi_get_opcode_name(info->opcode) << " ";
178
 
 
179
 
   for (auto d: dst) {
180
 
      os << d << " ";
181
 
   }
182
 
   os << " <- ";
183
 
   for (auto s: src) {
184
 
      os << s << " ";
185
 
   }
186
 
   os << "\n";
187
 
}
188
 
 
189
 
bool operator == (const FakeCodeline& lhs, const FakeCodeline& rhs)
190
 
{
191
 
   if  ((lhs.op != rhs.op) ||
192
 
        (lhs.src.size() != rhs.src.size()) ||
193
 
        (lhs.dst.size() != rhs.dst.size()))
194
 
      return false;
195
 
 
196
 
   return std::equal(lhs.src.begin(), lhs.src.end(), rhs.src.begin()) &&
197
 
         std::equal(lhs.dst.begin(), lhs.dst.end(), rhs.dst.begin());
198
 
}
199
 
 
200
 
st_src_reg FakeCodeline::create_src_register(int src_idx)
201
 
{
202
 
   return create_src_register(src_idx,
203
 
                              src_idx < 0 ? PROGRAM_INPUT : PROGRAM_TEMPORARY);
204
 
}
205
 
 
206
 
static int swizzle_from_char(const char *sw)
207
 
{
208
 
   int swizzle = 0;
209
 
   if (!sw || sw[0] == 0)
210
 
       return SWIZZLE_XYZW;
211
 
 
212
 
   const char *isw = sw;
213
 
   for (int i = 0; i < 4; ++i) {
214
 
      switch (*isw) {
215
 
      case 'x': break; /* is zero */
216
 
      case 'y': swizzle |= SWIZZLE_Y << 3 * i; break;
217
 
      case 'z': swizzle |= SWIZZLE_Z << 3 * i; break;
218
 
      case 'w': swizzle |= SWIZZLE_W << 3 * i; break;
219
 
      default:
220
 
         assert(!"This test uses an unknown swizzle character");
221
 
      }
222
 
      if (isw[1] != 0)
223
 
         ++isw;
224
 
   }
225
 
   return swizzle;
226
 
}
227
 
 
228
 
st_src_reg FakeCodeline::create_src_register(int src_idx, const char *sw)
229
 
{
230
 
   st_src_reg result = create_src_register(src_idx);
231
 
   result.swizzle = swizzle_from_char(sw);
232
 
   return result;
233
 
}
234
 
 
235
 
st_src_reg FakeCodeline::create_src_register(int src_idx, gl_register_file file)
236
 
{
237
 
   st_src_reg retval;
238
 
   retval.file = file;
239
 
   retval.index = src_idx >= 0 ? src_idx  : 1 - src_idx;
240
 
 
241
 
   if (file == PROGRAM_TEMPORARY) {
242
 
      if (max_temp_id < src_idx)
243
 
         max_temp_id = src_idx;
244
 
   } else if (file == PROGRAM_ARRAY) {
245
 
      retval.array_id = 1;
246
 
      if (max_array_id < 1)
247
 
          max_array_id = 1;
248
 
   }
249
 
   retval.swizzle = SWIZZLE_XYZW;
250
 
   retval.type = GLSL_TYPE_INT;
251
 
 
252
 
   return retval;
253
 
}
254
 
 
255
 
st_src_reg *FakeCodeline::create_rel_src_register(int idx)
256
 
{
257
 
   st_src_reg *retval = ralloc(mem_ctx, st_src_reg);
258
 
   *retval = st_src_reg(PROGRAM_TEMPORARY, idx, GLSL_TYPE_INT);
259
 
   if (max_temp_id < idx)
260
 
      max_temp_id = idx;
261
 
   return retval;
262
 
}
263
 
 
264
 
st_src_reg FakeCodeline::create_array_src_register(const tuple<int,int, const char*>& r)
265
 
{
266
 
 
267
 
   int array_id = std::get<0>(r);
268
 
   int idx = std::get<1>(r);
269
 
 
270
 
   st_src_reg retval = create_src_register(idx, std::get<2>(r));
271
 
 
272
 
   if (array_id > 0) {
273
 
      retval.file = PROGRAM_ARRAY;
274
 
 
275
 
      retval.array_id = array_id;
276
 
      if (max_array_id < array_id)
277
 
         max_array_id = array_id;
278
 
   } else {
279
 
      if (max_temp_id < idx)
280
 
         max_temp_id = idx;
281
 
   }
282
 
 
283
 
   return retval;
284
 
}
285
 
 
286
 
st_dst_reg FakeCodeline::create_array_dst_register(const tuple<int,int,int>& r)
287
 
{
288
 
 
289
 
   int array_id = std::get<0>(r);
290
 
   int idx = std::get<1>(r);
291
 
 
292
 
   st_dst_reg retval = create_dst_register(idx, std::get<2>(r));
293
 
 
294
 
   if (array_id > 0) {
295
 
      retval.file = PROGRAM_ARRAY;
296
 
      retval.array_id = array_id;
297
 
      if (max_array_id < array_id)
298
 
         max_array_id = array_id;
299
 
   } else {
300
 
      if (max_temp_id < idx)
301
 
         max_temp_id = idx;
302
 
   }
303
 
   return retval;
304
 
}
305
 
 
306
 
st_src_reg FakeCodeline::create_src_register(const tuple<int,int,int>& src)
307
 
{
308
 
   int src_idx = std::get<0>(src);
309
 
   int relidx1 = std::get<1>(src);
310
 
   int relidx2 = std::get<2>(src);
311
 
 
312
 
   gl_register_file file = PROGRAM_TEMPORARY;
313
 
   if (src_idx < 0)
314
 
      file = PROGRAM_OUTPUT;
315
 
   else if (relidx1 || relidx2) {
316
 
      file = PROGRAM_ARRAY;
317
 
   }
318
 
 
319
 
   st_src_reg retval = create_src_register(src_idx, file);
320
 
   if (src_idx >= 0) {
321
 
      if (relidx1 || relidx2) {
322
 
         retval.array_id = 1;
323
 
 
324
 
         if (relidx1)
325
 
            retval.reladdr = create_rel_src_register(relidx1);
326
 
         if (relidx2) {
327
 
            retval.reladdr2 = create_rel_src_register(relidx2);
328
 
            retval.has_index2 = true;
329
 
            retval.index2D = 10;
330
 
         }
331
 
      }
332
 
   }
333
 
   return retval;
334
 
}
335
 
 
336
 
st_dst_reg FakeCodeline::create_dst_register(int dst_idx,int writemask)
337
 
{
338
 
   gl_register_file file;
339
 
   int idx = 0;
340
 
   if (dst_idx >= 0) {
341
 
      file = PROGRAM_TEMPORARY;
342
 
      idx = dst_idx;
343
 
      if (max_temp_id < idx)
344
 
         max_temp_id = idx;
345
 
   } else {
346
 
      file = PROGRAM_OUTPUT;
347
 
      idx = 1 - dst_idx;
348
 
   }
349
 
   return st_dst_reg(file, writemask, GLSL_TYPE_INT, idx);
350
 
}
351
 
 
352
 
st_dst_reg FakeCodeline::create_dst_register(int dst_idx)
353
 
{
354
 
   return create_dst_register(dst_idx, dst_idx < 0 ?
355
 
                                 PROGRAM_OUTPUT : PROGRAM_TEMPORARY);
356
 
}
357
 
 
358
 
st_dst_reg FakeCodeline::create_dst_register(int dst_idx, gl_register_file file)
359
 
{
360
 
   st_dst_reg retval;
361
 
   retval.file = file;
362
 
   retval.index = dst_idx >= 0 ? dst_idx  : 1 - dst_idx;
363
 
 
364
 
   if (file == PROGRAM_TEMPORARY) {
365
 
      if (max_temp_id < dst_idx)
366
 
         max_temp_id = dst_idx;
367
 
   } else if (file == PROGRAM_ARRAY) {
368
 
      retval.array_id = 1;
369
 
      if (max_array_id < 1)
370
 
          max_array_id = 1;
371
 
   }
372
 
   retval.writemask = 0xF;
373
 
   retval.type = GLSL_TYPE_INT;
374
 
 
375
 
   return retval;
376
 
}
377
 
 
378
 
st_dst_reg FakeCodeline::create_dst_register(const tuple<int,int,int>& dst)
379
 
{
380
 
   int dst_idx = std::get<0>(dst);
381
 
   int relidx1 = std::get<1>(dst);
382
 
   int relidx2 = std::get<2>(dst);
383
 
 
384
 
   gl_register_file file = PROGRAM_TEMPORARY;
385
 
   if (dst_idx < 0)
386
 
      file = PROGRAM_OUTPUT;
387
 
   else if (relidx1 || relidx2) {
388
 
      file = PROGRAM_ARRAY;
389
 
   }
390
 
   st_dst_reg retval = create_dst_register(dst_idx, file);
391
 
 
392
 
   if (relidx1 || relidx2) {
393
 
      if (relidx1)
394
 
         retval.reladdr = create_rel_src_register(relidx1);
395
 
      if (relidx2) {
396
 
         retval.reladdr2 = create_rel_src_register(relidx2);
397
 
         retval.has_index2 = true;
398
 
         retval.index2D = 10;
399
 
      }
400
 
   }
401
 
   return retval;
402
 
}
403
 
 
404
 
glsl_to_tgsi_instruction *FakeCodeline::get_codeline() const
405
 
{
406
 
   glsl_to_tgsi_instruction *next_instr = new(mem_ctx) glsl_to_tgsi_instruction();
407
 
   next_instr->op = op;
408
 
   next_instr->info = tgsi_get_opcode_info(op);
409
 
 
410
 
   assert(src.size() == num_inst_src_regs(next_instr));
411
 
   assert(dst.size() == num_inst_dst_regs(next_instr));
412
 
   assert(tex_offsets.size() < 3);
413
 
 
414
 
   copy(src.begin(), src.end(), next_instr->src);
415
 
   copy(dst.begin(), dst.end(), next_instr->dst);
416
 
 
417
 
   next_instr->tex_offset_num_offset = tex_offsets.size();
418
 
 
419
 
   if (next_instr->tex_offset_num_offset > 0) {
420
 
      next_instr->tex_offsets = ralloc_array(mem_ctx, st_src_reg, tex_offsets.size());
421
 
      copy(tex_offsets.begin(), tex_offsets.end(), next_instr->tex_offsets);
422
 
   } else {
423
 
      next_instr->tex_offsets = nullptr;
424
 
   }
425
 
   return next_instr;
426
 
}
427
 
 
428
 
void FakeCodeline::set_mem_ctx(void *ctx)
429
 
{
430
 
   mem_ctx = ctx;
431
 
}
432
 
 
433
 
FakeShader::FakeShader(const vector<FakeCodeline>& source):
434
 
   program(source),
435
 
   num_temps(0),
436
 
   num_arrays(0)
437
 
{
438
 
   for (const FakeCodeline& i: source) {
439
 
      int t = i.get_max_reg_id();
440
 
      if (t > num_temps)
441
 
         num_temps = t;
442
 
 
443
 
      int a = i.get_max_array_id();
444
 
      if (a > num_arrays)
445
 
         num_arrays = a;
446
 
   }
447
 
   ++num_temps;
448
 
}
449
 
 
450
 
FakeShader::FakeShader(exec_list *tgsi_prog):
451
 
   num_temps(0),
452
 
   num_arrays(0)
453
 
{
454
 
   FakeCodeline nop(TGSI_OPCODE_NOP);
455
 
   FakeCodeline& last = nop;
456
 
 
457
 
   foreach_in_list(glsl_to_tgsi_instruction, inst, tgsi_prog) {
458
 
      program.push_back(last = FakeCodeline(*inst));
459
 
      if (last.get_max_array_id() > num_arrays)
460
 
         num_arrays = last.get_max_array_id();
461
 
      if (num_temps < last.get_max_reg_id())
462
 
         num_temps = last.get_max_reg_id();
463
 
   }
464
 
   ++num_temps;
465
 
}
466
 
 
467
 
int FakeShader::get_num_arrays() const
468
 
{
469
 
   return num_arrays;
470
 
}
471
 
 
472
 
int FakeShader::get_num_temps() const
473
 
{
474
 
   return num_temps;
475
 
}
476
 
 
477
 
exec_list* FakeShader::get_program(void *ctx) const
478
 
{
479
 
   exec_list *prog = new(ctx) exec_list();
480
 
 
481
 
   for (const FakeCodeline& i: program) {
482
 
      prog->push_tail(i.get_codeline());
483
 
   }
484
 
 
485
 
   return prog;
486
 
}
487
 
 
488
 
size_t FakeShader::length() const
489
 
{
490
 
   return program.size();
491
 
}
492
 
 
493
 
const FakeCodeline& FakeShader::line(unsigned i) const
494
 
{
495
 
   return program[i];
496
 
}
497
 
 
498
 
void MesaTestWithMemCtx::SetUp()
499
 
{
500
 
   mem_ctx = ralloc_context(nullptr);
501
 
   FakeCodeline::set_mem_ctx(mem_ctx);
502
 
}
503
 
 
504
 
void MesaTestWithMemCtx::TearDown()
505
 
{
506
 
   ralloc_free(mem_ctx);
507
 
   FakeCodeline::set_mem_ctx(nullptr);
508
 
   mem_ctx = nullptr;
509
 
}
510
 
 
511
 
 
512
 
LifetimeEvaluatorTest::life_range_result
513
 
LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, bool& success)
514
 
{
515
 
   FakeShader shader(code);
516
 
   life_range_result result = make_pair(life_range_result::first_type(shader.get_num_temps()),
517
 
                                        life_range_result::second_type(shader.get_num_arrays()));
518
 
 
519
 
   success =
520
 
         get_temp_registers_required_live_ranges(mem_ctx, shader.get_program(mem_ctx),
521
 
                                                 shader.get_num_temps(),&result.first[0],
522
 
                                                 shader.get_num_arrays(), &result.second[0]);
523
 
   return result;
524
 
}
525
 
 
526
 
void LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, const temp_lt_expect& e)
527
 
{
528
 
   bool success = false;
529
 
   auto result = run(code, success);
530
 
   ASSERT_TRUE(success);
531
 
   ASSERT_EQ(result.first.size(), e.size());
532
 
   check(result.first, e);
533
 
}
534
 
 
535
 
void LifetimeEvaluatorTest::run(const vector<FakeCodeline>& code, const array_lt_expect& e)
536
 
{
537
 
   bool success = false;
538
 
   auto result = run(code, success);
539
 
   ASSERT_TRUE(success);
540
 
   ASSERT_EQ(result.second.size(), e.size());
541
 
   check(result.second, e);
542
 
}
543
 
 
544
 
void LifetimeEvaluatorExactTest::check( const vector<register_live_range>& lifetimes,
545
 
                                        const temp_lt_expect& e)
546
 
{
547
 
   for (unsigned i = 1; i < lifetimes.size(); ++i) {
548
 
      EXPECT_EQ(lifetimes[i].begin, e[i][0]);
549
 
      EXPECT_EQ(lifetimes[i].end, e[i][1]);
550
 
   }
551
 
}
552
 
 
553
 
void LifetimeEvaluatorExactTest::check(const vector<array_live_range>& lifetimes,
554
 
                                       const array_lt_expect& e)
555
 
{
556
 
   for (unsigned i = 0; i < lifetimes.size(); ++i) {
557
 
      EXPECT_EQ(lifetimes[i].begin(), e[i].begin());
558
 
      EXPECT_EQ(lifetimes[i].end(), e[i].end());
559
 
      EXPECT_EQ(lifetimes[i].access_mask(), e[i].access_mask());
560
 
   }
561
 
}
562
 
 
563
 
void LifetimeEvaluatorAtLeastTest::check( const vector<register_live_range>& lifetimes,
564
 
                                          const temp_lt_expect& e)
565
 
{
566
 
   for (unsigned i = 1; i < lifetimes.size(); ++i) {
567
 
      EXPECT_LE(lifetimes[i].begin, e[i][0]);
568
 
      EXPECT_GE(lifetimes[i].end, e[i][1]);
569
 
   }
570
 
}
571
 
 
572
 
void LifetimeEvaluatorAtLeastTest::check(const vector<array_live_range>& lifetimes,
573
 
                                         const array_lt_expect& e)
574
 
{
575
 
   for (unsigned i = 0; i < lifetimes.size(); ++i) {
576
 
      EXPECT_LE(lifetimes[i].begin(), e[i].begin());
577
 
      EXPECT_GE(lifetimes[i].end(), e[i].end());
578
 
 
579
 
      /* Tests that lifetimes doesn't add unexpected swizzles */
580
 
      EXPECT_EQ(lifetimes[i].access_mask()| e[i].access_mask(),
581
 
                e[i].access_mask());
582
 
   }
583
 
}
584
 
 
585
 
 
586
 
void RegisterRemappingTest::run(const vector<register_live_range>& lt,
587
 
                                const vector<int>& expect)
588
 
{
589
 
   rename_reg_pair proto{false,0};
590
 
   vector<rename_reg_pair> result(lt.size(), proto);
591
 
 
592
 
   get_temp_registers_remapping(mem_ctx, lt.size(), &lt[0], &result[0]);
593
 
 
594
 
   vector<int> remap(lt.size());
595
 
   for (unsigned i = 0; i < lt.size(); ++i) {
596
 
      remap[i] = result[i].valid ? result[i].new_reg : i;
597
 
   }
598
 
 
599
 
   std::transform(remap.begin(), remap.end(), result.begin(), remap.begin(),
600
 
                  [](int x, const rename_reg_pair& rn) {
601
 
                     return rn.valid ? rn.new_reg : x;
602
 
                  });
603
 
 
604
 
   for(unsigned i = 1; i < remap.size(); ++i) {
605
 
      EXPECT_EQ(remap[i], expect[i]);
606
 
   }
607
 
}
608
 
 
609
 
void RegisterLifetimeAndRemappingTest::run(const vector<FakeCodeline>& code,
610
 
                                           const vector<int>& expect)
611
 
{
612
 
     FakeShader shader(code);
613
 
     std::vector<register_live_range> lt(shader.get_num_temps());
614
 
     std::vector<array_live_range> alt(shader.get_num_arrays());
615
 
     get_temp_registers_required_live_ranges(mem_ctx, shader.get_program(mem_ctx),
616
 
                                             shader.get_num_temps(), &lt[0],
617
 
                                             shader.get_num_arrays(), &alt[0]);
618
 
     this->run(lt, expect);
619
 
}