nir_validate.c 40.8 KB
Newer Older
Connor Abbott's avatar
Connor Abbott committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 * Copyright © 2014 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Authors:
 *    Connor Abbott (cwabbott0@gmail.com)
 *
 */

#include "nir.h"
29
#include "c11/threads.h"
Connor Abbott's avatar
Connor Abbott committed
30
31
32
33
34
35
#include <assert.h>

/*
 * This file checks for invalid IR indicating a bug somewhere in the compiler.
 */

36
37
38
/* Since this file is just a pile of asserts, don't bother compiling it if
 * we're not building a debug build.
 */
39
#ifndef NDEBUG
40

Connor Abbott's avatar
Connor Abbott committed
41
42
43
44
45
46
47
48
49
/*
 * Per-register validation state.
 */

typedef struct {
   /*
    * equivalent to the uses and defs in nir_register, but built up by the
    * validator. At the end, we verify that the sets have the same entries.
    */
50
   struct set *uses, *if_uses, *defs;
Connor Abbott's avatar
Connor Abbott committed
51
52
53
54
   nir_function_impl *where_defined; /* NULL for global registers */
} reg_validate_state;

typedef struct {
55
56
   void *mem_ctx;

Connor Abbott's avatar
Connor Abbott committed
57
58
59
   /* map of register -> validation state (struct above) */
   struct hash_table *regs;

60
61
62
   /* the current shader being validated */
   nir_shader *shader;

Connor Abbott's avatar
Connor Abbott committed
63
64
65
   /* the current instruction being validated */
   nir_instr *instr;

66
67
68
   /* the current variable being validated */
   nir_variable *var;

Connor Abbott's avatar
Connor Abbott committed
69
70
71
72
73
74
   /* the current basic block being validated */
   nir_block *block;

   /* the current if statement being validated */
   nir_if *if_stmt;

75
76
77
   /* the current loop being visited */
   nir_loop *loop;

Connor Abbott's avatar
Connor Abbott committed
78
79
80
81
82
83
   /* the parent of the current cf node being visited */
   nir_cf_node *parent_node;

   /* the current function implementation being validated */
   nir_function_impl *impl;

84
85
   /* Set of seen SSA sources */
   struct set *ssa_srcs;
Connor Abbott's avatar
Connor Abbott committed
86

87
88
89
90
91
92
   /* bitset of ssa definitions we have found; used to check uniqueness */
   BITSET_WORD *ssa_defs_found;

   /* bitset of registers we have currently found; used to check uniqueness */
   BITSET_WORD *regs_found;

93
94
95
   /* map of variable -> function implementation where it is defined or NULL
    * if it is a global variable
    */
Connor Abbott's avatar
Connor Abbott committed
96
   struct hash_table *var_defs;
97
98
99

   /* map of instruction/var/etc to failed assert string */
   struct hash_table *errors;
Connor Abbott's avatar
Connor Abbott committed
100
101
} validate_state;

102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
static void
log_error(validate_state *state, const char *cond, const char *file, int line)
{
   const void *obj;

   if (state->instr)
      obj = state->instr;
   else if (state->var)
      obj = state->var;
   else
      obj = cond;

   char *msg = ralloc_asprintf(state->errors, "error: %s (%s:%d)",
                               cond, file, line);

   _mesa_hash_table_insert(state->errors, obj, msg);
}

#define validate_assert(state, cond) do {             \
      if (!(cond))                                    \
         log_error(state, #cond, __FILE__, __LINE__); \
   } while (0)
124

125
static void validate_src(nir_src *src, validate_state *state,
126
                         unsigned bit_sizes, unsigned num_components);
Connor Abbott's avatar
Connor Abbott committed
127
128

static void
129
validate_reg_src(nir_src *src, validate_state *state,
130
                 unsigned bit_sizes, unsigned num_components)
Connor Abbott's avatar
Connor Abbott committed
131
{
132
   validate_assert(state, src->reg.reg != NULL);
Connor Abbott's avatar
Connor Abbott committed
133

134
   struct hash_entry *entry;
135
   entry = _mesa_hash_table_search(state->regs, src->reg.reg);
136
   validate_assert(state, entry);
Connor Abbott's avatar
Connor Abbott committed
137

138
   reg_validate_state *reg_state = (reg_validate_state *) entry->data;
Connor Abbott's avatar
Connor Abbott committed
139

140
   if (state->instr) {
141
      _mesa_set_add(reg_state->uses, src);
142
   } else {
143
      validate_assert(state, state->if_stmt);
144
      _mesa_set_add(reg_state->if_uses, src);
145
   }
Connor Abbott's avatar
Connor Abbott committed
146

147
148
   validate_assert(state, reg_state->where_defined == state->impl &&
          "using a register declared in a different function");
Connor Abbott's avatar
Connor Abbott committed
149

150
151
152
153
   if (bit_sizes)
      validate_assert(state, src->reg.reg->bit_size & bit_sizes);
   if (num_components)
      validate_assert(state, src->reg.reg->num_components == num_components);
154

155
   validate_assert(state, (src->reg.reg->num_array_elems == 0 ||
156
          src->reg.base_offset < src->reg.reg->num_array_elems) &&
Connor Abbott's avatar
Connor Abbott committed
157
158
          "definitely out-of-bounds array access");

159
   if (src->reg.indirect) {
160
161
      validate_assert(state, src->reg.reg->num_array_elems != 0);
      validate_assert(state, (src->reg.indirect->is_ssa ||
162
              src->reg.indirect->reg.indirect == NULL) &&
Connor Abbott's avatar
Connor Abbott committed
163
             "only one level of indirection allowed");
164
      validate_src(src->reg.indirect, state, 32, 1);
Connor Abbott's avatar
Connor Abbott committed
165
166
167
   }
}

168
169
170
#define SET_PTR_BIT(ptr, bit) \
   (void *)(((uintptr_t)(ptr)) | (((uintptr_t)1) << bit))

Connor Abbott's avatar
Connor Abbott committed
171
static void
172
validate_ssa_src(nir_src *src, validate_state *state,
173
                 unsigned bit_sizes, unsigned num_components)
Connor Abbott's avatar
Connor Abbott committed
174
{
175
   validate_assert(state, src->ssa != NULL);
Connor Abbott's avatar
Connor Abbott committed
176

177
178
179
180
   /* As we walk SSA defs, we add every use to this set.  We need to make sure
    * our use is seen in a use list.
    */
   struct set_entry *entry;
181
   if (state->instr) {
182
      entry = _mesa_set_search(state->ssa_srcs, src);
183
   } else {
184
      entry = _mesa_set_search(state->ssa_srcs, SET_PTR_BIT(src, 0));
185
   }
186
187
188
189
190
   validate_assert(state, entry);

   /* This will let us prove that we've seen all the sources */
   if (entry)
      _mesa_set_remove(state->ssa_srcs, entry);
Connor Abbott's avatar
Connor Abbott committed
191

192
193
   if (bit_sizes)
      validate_assert(state, src->ssa->bit_size & bit_sizes);
194
195
196
   if (num_components)
      validate_assert(state, src->ssa->num_components == num_components);

Connor Abbott's avatar
Connor Abbott committed
197
198
199
200
   /* TODO validate that the use is dominated by the definition */
}

static void
201
validate_src(nir_src *src, validate_state *state,
202
             unsigned bit_sizes, unsigned num_components)
Connor Abbott's avatar
Connor Abbott committed
203
{
204
   if (state->instr)
205
      validate_assert(state, src->parent_instr == state->instr);
206
   else
207
      validate_assert(state, src->parent_if == state->if_stmt);
208

Connor Abbott's avatar
Connor Abbott committed
209
   if (src->is_ssa)
210
      validate_ssa_src(src, state, bit_sizes, num_components);
Connor Abbott's avatar
Connor Abbott committed
211
   else
212
      validate_reg_src(src, state, bit_sizes, num_components);
Connor Abbott's avatar
Connor Abbott committed
213
214
215
216
217
218
219
}

static void
validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
{
   nir_alu_src *src = &instr->src[index];

220
   if (instr->op == nir_op_mov)
221
222
      assert(!src->abs && !src->negate);

223
   unsigned num_components = nir_src_num_components(src->src);
224
225
   for (unsigned i = 0; i < NIR_MAX_VEC_COMPONENTS; i++) {
      validate_assert(state, src->swizzle[i] < NIR_MAX_VEC_COMPONENTS);
Connor Abbott's avatar
Connor Abbott committed
226
227

      if (nir_alu_instr_channel_used(instr, index, i))
228
         validate_assert(state, src->swizzle[i] < num_components);
Connor Abbott's avatar
Connor Abbott committed
229
230
   }

231
   validate_src(&src->src, state, 0, 0);
Connor Abbott's avatar
Connor Abbott committed
232
233
234
}

static void
235
validate_reg_dest(nir_reg_dest *dest, validate_state *state,
236
                  unsigned bit_sizes, unsigned num_components)
Connor Abbott's avatar
Connor Abbott committed
237
{
238
   validate_assert(state, dest->reg != NULL);
Connor Abbott's avatar
Connor Abbott committed
239

240
   validate_assert(state, dest->parent_instr == state->instr);
Connor Abbott's avatar
Connor Abbott committed
241
242
243
244

   struct hash_entry *entry2;
   entry2 = _mesa_hash_table_search(state->regs, dest->reg);

245
   validate_assert(state, entry2);
Connor Abbott's avatar
Connor Abbott committed
246
247

   reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
248
   _mesa_set_add(reg_state->defs, dest);
Connor Abbott's avatar
Connor Abbott committed
249

250
251
   validate_assert(state, reg_state->where_defined == state->impl &&
          "writing to a register declared in a different function");
Connor Abbott's avatar
Connor Abbott committed
252

253
254
255
256
   if (bit_sizes)
      validate_assert(state, dest->reg->bit_size & bit_sizes);
   if (num_components)
      validate_assert(state, dest->reg->num_components == num_components);
257

258
   validate_assert(state, (dest->reg->num_array_elems == 0 ||
Connor Abbott's avatar
Connor Abbott committed
259
260
261
262
          dest->base_offset < dest->reg->num_array_elems) &&
          "definitely out-of-bounds array access");

   if (dest->indirect) {
263
264
      validate_assert(state, dest->reg->num_array_elems != 0);
      validate_assert(state, (dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
Connor Abbott's avatar
Connor Abbott committed
265
             "only one level of indirection allowed");
266
      validate_src(dest->indirect, state, 32, 1);
Connor Abbott's avatar
Connor Abbott committed
267
268
269
270
271
272
   }
}

static void
validate_ssa_def(nir_ssa_def *def, validate_state *state)
{
273
274
   validate_assert(state, def->index < state->impl->ssa_alloc);
   validate_assert(state, !BITSET_TEST(state->ssa_defs_found, def->index));
275
276
   BITSET_SET(state->ssa_defs_found, def->index);

277
   validate_assert(state, def->parent_instr == state->instr);
278

Rob Clark's avatar
Rob Clark committed
279
280
281
   validate_assert(state, (def->num_components <= 4) ||
                          (def->num_components == 8) ||
                          (def->num_components == 16));
282

283
   list_validate(&def->uses);
284
285
286
287
288
289
290
291
   nir_foreach_use(src, def) {
      validate_assert(state, src->is_ssa);
      validate_assert(state, src->ssa == def);
      bool already_seen = false;
      _mesa_set_search_and_add(state->ssa_srcs, src, &already_seen);
      /* A nir_src should only appear once and only in one SSA def use list */
      validate_assert(state, !already_seen);
   }
292

293
294
295
296
297
298
299
300
301
302
   list_validate(&def->if_uses);
   nir_foreach_if_use(src, def) {
      validate_assert(state, src->is_ssa);
      validate_assert(state, src->ssa == def);
      bool already_seen = false;
      _mesa_set_search_and_add(state->ssa_srcs, SET_PTR_BIT(src, 0),
                               &already_seen);
      /* A nir_src should only appear once and only in one SSA def use list */
      validate_assert(state, !already_seen);
   }
Connor Abbott's avatar
Connor Abbott committed
303
304
305
}

static void
306
validate_dest(nir_dest *dest, validate_state *state,
307
              unsigned bit_sizes, unsigned num_components)
Connor Abbott's avatar
Connor Abbott committed
308
{
309
   if (dest->is_ssa) {
310
311
      if (bit_sizes)
         validate_assert(state, dest->ssa.bit_size & bit_sizes);
312
313
      if (num_components)
         validate_assert(state, dest->ssa.num_components == num_components);
Connor Abbott's avatar
Connor Abbott committed
314
      validate_ssa_def(&dest->ssa, state);
315
   } else {
316
      validate_reg_dest(&dest->reg, state, bit_sizes, num_components);
317
   }
Connor Abbott's avatar
Connor Abbott committed
318
319
320
}

static void
321
validate_alu_dest(nir_alu_instr *instr, validate_state *state)
Connor Abbott's avatar
Connor Abbott committed
322
{
323
324
   nir_alu_dest *dest = &instr->dest;

325
   if (instr->op == nir_op_mov)
326
327
      assert(!dest->saturate);

328
   unsigned dest_size = nir_dest_num_components(dest->dest);
Connor Abbott's avatar
Connor Abbott committed
329
330
331
332
   /*
    * validate that the instruction doesn't write to components not in the
    * register/SSA value
    */
333
   validate_assert(state, !(dest->write_mask & ~((1 << dest_size) - 1)));
334
335
336
337
338

   /* validate that saturate is only ever used on instructions with
    * destinations of type float
    */
   nir_alu_instr *alu = nir_instr_as_alu(state->instr);
339
340
341
   validate_assert(state,
          (nir_alu_type_get_base_type(nir_op_infos[alu->op].output_type) ==
           nir_type_float) ||
342
343
          !dest->saturate);

344
   validate_dest(&dest->dest, state, 0, 0);
Connor Abbott's avatar
Connor Abbott committed
345
346
347
348
349
}

static void
validate_alu_instr(nir_alu_instr *instr, validate_state *state)
{
350
   validate_assert(state, instr->op < nir_num_opcodes);
Connor Abbott's avatar
Connor Abbott committed
351

352
   unsigned instr_bit_size = 0;
Connor Abbott's avatar
Connor Abbott committed
353
   for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
      nir_alu_type src_type = nir_op_infos[instr->op].input_types[i];
      unsigned src_bit_size = nir_src_bit_size(instr->src[i].src);
      if (nir_alu_type_get_type_size(src_type)) {
         validate_assert(state, src_bit_size == nir_alu_type_get_type_size(src_type));
      } else if (instr_bit_size) {
         validate_assert(state, src_bit_size == instr_bit_size);
      } else {
         instr_bit_size = src_bit_size;
      }

      if (nir_alu_type_get_base_type(src_type) == nir_type_float) {
         /* 8-bit float isn't a thing */
         validate_assert(state, src_bit_size == 16 || src_bit_size == 32 ||
                                src_bit_size == 64);
      }

Connor Abbott's avatar
Connor Abbott committed
370
371
      validate_alu_src(instr, i, state);
   }
372

373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
   nir_alu_type dest_type = nir_op_infos[instr->op].output_type;
   unsigned dest_bit_size = nir_dest_bit_size(instr->dest.dest);
   if (nir_alu_type_get_type_size(dest_type)) {
      validate_assert(state, dest_bit_size == nir_alu_type_get_type_size(dest_type));
   } else if (instr_bit_size) {
      validate_assert(state, dest_bit_size == instr_bit_size);
   } else {
      /* The only unsized thing is the destination so it's vacuously valid */
   }

   if (nir_alu_type_get_base_type(dest_type) == nir_type_float) {
      /* 8-bit float isn't a thing */
      validate_assert(state, dest_bit_size == 16 || dest_bit_size == 32 ||
                             dest_bit_size == 64);
   }

389
   validate_alu_dest(instr, state);
Connor Abbott's avatar
Connor Abbott committed
390
391
392
393
394
}

static void
validate_var_use(nir_variable *var, validate_state *state)
{
395
396
   struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
   validate_assert(state, entry);
397
   if (entry && var->data.mode == nir_var_function_temp)
398
      validate_assert(state, (nir_function_impl *) entry->data == state->impl);
Connor Abbott's avatar
Connor Abbott committed
399
400
}

401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
static void
validate_deref_instr(nir_deref_instr *instr, validate_state *state)
{
   if (instr->deref_type == nir_deref_type_var) {
      /* Variable dereferences are stupid simple. */
      validate_assert(state, instr->mode == instr->var->data.mode);
      validate_assert(state, instr->type == instr->var->type);
      validate_var_use(instr->var, state);
   } else if (instr->deref_type == nir_deref_type_cast) {
      /* For cast, we simply have to trust the instruction.  It's up to
       * lowering passes and front/back-ends to make them sane.
       */
      validate_src(&instr->parent, state, 0, 0);

      /* We just validate that the type and mode are there */
      validate_assert(state, instr->mode);
      validate_assert(state, instr->type);
   } else {
      /* We require the parent to be SSA.  This may be lifted in the future */
      validate_assert(state, instr->parent.is_ssa);

      /* The parent pointer value must have the same number of components
       * as the destination.
       */
      validate_src(&instr->parent, state, nir_dest_bit_size(instr->dest),
                   nir_dest_num_components(instr->dest));

      nir_instr *parent_instr = instr->parent.ssa->parent_instr;

      /* The parent must come from another deref instruction */
      validate_assert(state, parent_instr->type == nir_instr_type_deref);

      nir_deref_instr *parent = nir_instr_as_deref(parent_instr);

      validate_assert(state, instr->mode == parent->mode);

      switch (instr->deref_type) {
      case nir_deref_type_struct:
439
         validate_assert(state, glsl_type_is_struct_or_ifc(parent->type));
440
441
442
443
444
445
446
447
         validate_assert(state,
            instr->strct.index < glsl_get_length(parent->type));
         validate_assert(state, instr->type ==
            glsl_get_struct_field(parent->type, instr->strct.index));
         break;

      case nir_deref_type_array:
      case nir_deref_type_array_wildcard:
448
         if (instr->mode == nir_var_mem_ubo ||
449
             instr->mode == nir_var_mem_ssbo ||
450
451
             instr->mode == nir_var_mem_shared ||
             instr->mode == nir_var_mem_global) {
452
453
454
            /* Shared variables and UBO/SSBOs have a bit more relaxed rules
             * because we need to be able to handle array derefs on vectors.
             * Fortunately, nir_lower_io handles these just fine.
455
456
457
458
459
460
461
462
463
464
465
466
             */
            validate_assert(state, glsl_type_is_array(parent->type) ||
                                   glsl_type_is_matrix(parent->type) ||
                                   glsl_type_is_vector(parent->type));
         } else {
            /* Most of NIR cannot handle array derefs on vectors */
            validate_assert(state, glsl_type_is_array(parent->type) ||
                                   glsl_type_is_matrix(parent->type));
         }
         validate_assert(state,
            instr->type == glsl_get_array_element(parent->type));

467
468
469
470
         if (instr->deref_type == nir_deref_type_array) {
            validate_src(&instr->arr.index, state,
                         nir_dest_bit_size(instr->dest), 1);
         }
471
472
         break;

473
474
475
476
477
478
479
480
481
482
483
484
485
      case nir_deref_type_ptr_as_array:
         /* ptr_as_array derefs must have a parent that is either an array,
          * ptr_as_array, or cast.  If the parent is a cast, we get the stride
          * information (if any) from the cast deref.
          */
         validate_assert(state,
                         parent->deref_type == nir_deref_type_array ||
                         parent->deref_type == nir_deref_type_ptr_as_array ||
                         parent->deref_type == nir_deref_type_cast);
         validate_src(&instr->arr.index, state,
                      nir_dest_bit_size(instr->dest), 1);
         break;

486
487
488
489
490
491
492
493
494
495
      default:
         unreachable("Invalid deref instruction type");
      }
   }

   /* We intentionally don't validate the size of the destination because we
    * want to let other compiler components such as SPIR-V decide how big
    * pointers should be.
    */
   validate_dest(&instr->dest, state, 0, 0);
496
497
498
499
500
501

   /* Deref instructions as if conditions don't make sense because if
    * conditions expect well-formed Booleans.  If you want to compare with
    * NULL, an explicit comparison operation should be used.
    */
   validate_assert(state, list_empty(&instr->dest.ssa.if_uses));
502
503
504
505
506
507
508
509
510

   /* Only certain modes can be used as sources for phi instructions. */
   nir_foreach_use(use, &instr->dest.ssa) {
      if (use->parent_instr->type == nir_instr_type_phi) {
         validate_assert(state, instr->mode == nir_var_mem_ubo ||
                                instr->mode == nir_var_mem_ssbo ||
                                instr->mode == nir_var_mem_shared);
      }
   }
511
512
}

Connor Abbott's avatar
Connor Abbott committed
513
514
515
static void
validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
{
516
517
   unsigned dest_bit_size = 0;
   unsigned src_bit_sizes[NIR_INTRINSIC_MAX_INPUTS] = { 0, };
518
   switch (instr->intrinsic) {
519
520
521
522
523
524
525
526
527
   case nir_intrinsic_load_param: {
      unsigned param_idx = nir_intrinsic_param_idx(instr);
      validate_assert(state, param_idx < state->impl->function->num_params);
      nir_parameter *param = &state->impl->function->params[param_idx];
      validate_assert(state, instr->num_components == param->num_components);
      dest_bit_size = param->bit_size;
      break;
   }

528
529
530
531
532
533
534
535
   case nir_intrinsic_load_deref: {
      nir_deref_instr *src = nir_src_as_deref(instr->src[0]);
      validate_assert(state, glsl_type_is_vector_or_scalar(src->type) ||
                      (src->mode == nir_var_uniform &&
                       glsl_get_base_type(src->type) == GLSL_TYPE_SUBROUTINE));
      validate_assert(state, instr->num_components ==
                             glsl_get_vector_elements(src->type));
      dest_bit_size = glsl_get_bit_size(src->type);
536
537
538
      /* Also allow 32-bit boolean load operations */
      if (glsl_type_is_boolean(src->type))
         dest_bit_size |= 32;
539
540
541
542
543
544
545
546
547
      break;
   }

   case nir_intrinsic_store_deref: {
      nir_deref_instr *dst = nir_src_as_deref(instr->src[0]);
      validate_assert(state, glsl_type_is_vector_or_scalar(dst->type));
      validate_assert(state, instr->num_components ==
                             glsl_get_vector_elements(dst->type));
      src_bit_sizes[1] = glsl_get_bit_size(dst->type);
548
549
550
      /* Also allow 32-bit boolean store operations */
      if (glsl_type_is_boolean(dst->type))
         src_bit_sizes[1] |= 32;
551
      validate_assert(state, (dst->mode & (nir_var_shader_in |
552
                                           nir_var_uniform)) == 0);
553
554
555
556
557
558
559
      validate_assert(state, (nir_intrinsic_write_mask(instr) & ~((1 << instr->num_components) - 1)) == 0);
      break;
   }

   case nir_intrinsic_copy_deref: {
      nir_deref_instr *dst = nir_src_as_deref(instr->src[0]);
      nir_deref_instr *src = nir_src_as_deref(instr->src[1]);
560
561
      validate_assert(state, glsl_get_bare_type(dst->type) ==
                             glsl_get_bare_type(src->type));
562
      validate_assert(state, (dst->mode & (nir_var_shader_in |
563
                                           nir_var_uniform)) == 0);
564
565
566
      break;
   }

567
568
569
   default:
      break;
   }
570
571
572
573
574
575
576
577
578
579
580
581

   unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
   for (unsigned i = 0; i < num_srcs; i++) {
      unsigned components_read = nir_intrinsic_src_components(instr, i);

      validate_assert(state, components_read > 0);

      validate_src(&instr->src[i], state, src_bit_sizes[i], components_read);
   }

   if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
      unsigned components_written = nir_intrinsic_dest_components(instr);
582
      unsigned bit_sizes = nir_intrinsic_infos[instr->intrinsic].dest_bit_sizes;
583
584
585

      validate_assert(state, components_written > 0);

586
587
588
589
590
      if (dest_bit_size && bit_sizes)
         validate_assert(state, dest_bit_size & bit_sizes);
      else
         dest_bit_size = dest_bit_size ? dest_bit_size : bit_sizes;

591
592
      validate_dest(&instr->dest, state, dest_bit_size, components_written);
   }
Connor Abbott's avatar
Connor Abbott committed
593
594
595
596
597
}

static void
validate_tex_instr(nir_tex_instr *instr, validate_state *state)
{
598
599
   bool src_type_seen[nir_num_tex_src_types];
   for (unsigned i = 0; i < nir_num_tex_src_types; i++)
Connor Abbott's avatar
Connor Abbott committed
600
601
602
      src_type_seen[i] = false;

   for (unsigned i = 0; i < instr->num_srcs; i++) {
603
      validate_assert(state, !src_type_seen[instr->src[i].src_type]);
604
      src_type_seen[instr->src[i].src_type] = true;
605
606
      validate_src(&instr->src[i].src, state,
                   0, nir_tex_instr_src_size(instr, i));
607
608
609
610
611
612
613
614
615
616
617

      switch (instr->src[i].src_type) {
      case nir_tex_src_texture_deref:
      case nir_tex_src_sampler_deref:
         validate_assert(state, instr->src[i].src.is_ssa);
         validate_assert(state,
                         instr->src[i].src.ssa->parent_instr->type == nir_instr_type_deref);
         break;
      default:
         break;
      }
Connor Abbott's avatar
Connor Abbott committed
618
619
   }

620
621
622
623
624
   if (nir_tex_instr_has_explicit_tg4_offsets(instr)) {
      validate_assert(state, instr->op == nir_texop_tg4);
      validate_assert(state, !src_type_seen[nir_tex_src_offset]);
   }

625
   validate_dest(&instr->dest, state, 0, nir_tex_instr_dest_size(instr));
Connor Abbott's avatar
Connor Abbott committed
626
627
628
629
630
}

static void
validate_call_instr(nir_call_instr *instr, validate_state *state)
{
631
   validate_assert(state, instr->num_params == instr->callee->num_params);
Connor Abbott's avatar
Connor Abbott committed
632
633

   for (unsigned i = 0; i < instr->num_params; i++) {
634
635
636
      validate_src(&instr->params[i], state,
                   instr->callee->params[i].bit_size,
                   instr->callee->params[i].num_components);
Connor Abbott's avatar
Connor Abbott committed
637
638
639
   }
}

640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
static void
validate_const_value(nir_const_value *val, unsigned bit_size,
                     validate_state *state)
{
   /* In order for block copies to work properly for things like instruction
    * comparisons and [de]serialization, we require the unused bits of the
    * nir_const_value to be zero.
    */
   nir_const_value cmp_val;
   memset(&cmp_val, 0, sizeof(cmp_val));
   switch (bit_size) {
   case 1:
      cmp_val.b = val->b;
      break;
   case 8:
      cmp_val.u8 = val->u8;
      break;
   case 16:
      cmp_val.u16 = val->u16;
      break;
   case 32:
      cmp_val.u32 = val->u32;
      break;
   case 64:
      cmp_val.u64 = val->u64;
      break;
   default:
      validate_assert(state, !"Invalid load_const bit size");
   }
   validate_assert(state, memcmp(val, &cmp_val, sizeof(cmp_val)) == 0);
}

Connor Abbott's avatar
Connor Abbott committed
672
673
674
static void
validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
{
Jason Ekstrand's avatar
Jason Ekstrand committed
675
   validate_ssa_def(&instr->def, state);
676
677
678

   for (unsigned i = 0; i < instr->def.num_components; i++)
      validate_const_value(&instr->value[i], instr->def.bit_size, state);
Connor Abbott's avatar
Connor Abbott committed
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
}

static void
validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
{
   validate_ssa_def(&instr->def, state);
}

static void
validate_phi_instr(nir_phi_instr *instr, validate_state *state)
{
   /*
    * don't validate the sources until we get to them from their predecessor
    * basic blocks, to avoid validating an SSA use before its definition.
    */

695
   validate_dest(&instr->dest, state, 0, 0);
Connor Abbott's avatar
Connor Abbott committed
696

697
   exec_list_validate(&instr->srcs);
698
   validate_assert(state, exec_list_length(&instr->srcs) ==
Connor Abbott's avatar
Connor Abbott committed
699
700
701
702
703
704
          state->block->predecessors->entries);
}

static void
validate_instr(nir_instr *instr, validate_state *state)
{
705
   validate_assert(state, instr->block == state->block);
Connor Abbott's avatar
Connor Abbott committed
706
707
708
709
710
711
712
713

   state->instr = instr;

   switch (instr->type) {
   case nir_instr_type_alu:
      validate_alu_instr(nir_instr_as_alu(instr), state);
      break;

714
715
716
717
   case nir_instr_type_deref:
      validate_deref_instr(nir_instr_as_deref(instr), state);
      break;

Connor Abbott's avatar
Connor Abbott committed
718
719
720
721
722
723
724
725
   case nir_instr_type_call:
      validate_call_instr(nir_instr_as_call(instr), state);
      break;

   case nir_instr_type_intrinsic:
      validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
      break;

726
727
   case nir_instr_type_tex:
      validate_tex_instr(nir_instr_as_tex(instr), state);
Connor Abbott's avatar
Connor Abbott committed
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
      break;

   case nir_instr_type_load_const:
      validate_load_const_instr(nir_instr_as_load_const(instr), state);
      break;

   case nir_instr_type_phi:
      validate_phi_instr(nir_instr_as_phi(instr), state);
      break;

   case nir_instr_type_ssa_undef:
      validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
      break;

   case nir_instr_type_jump:
      break;

   default:
746
      validate_assert(state, !"Invalid ALU instruction type");
Connor Abbott's avatar
Connor Abbott committed
747
748
      break;
   }
749
750

   state->instr = NULL;
Connor Abbott's avatar
Connor Abbott committed
751
752
753
754
755
756
757
}

static void
validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
{
   state->instr = &instr->instr;

758
   validate_assert(state, instr->dest.is_ssa);
759

760
   exec_list_validate(&instr->srcs);
761
   nir_foreach_phi_src(src, instr) {
Connor Abbott's avatar
Connor Abbott committed
762
      if (src->pred == pred) {
763
         validate_assert(state, src->src.is_ssa);
764
765
         validate_src(&src->src, state, instr->dest.ssa.bit_size,
                      instr->dest.ssa.num_components);
766
         state->instr = NULL;
Connor Abbott's avatar
Connor Abbott committed
767
768
769
770
771
772
773
774
775
776
         return;
      }
   }

   abort();
}

static void
validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
{
777
   nir_foreach_instr(instr, succ) {
Connor Abbott's avatar
Connor Abbott committed
778
779
780
781
782
783
784
785
786
787
788
789
      if (instr->type != nir_instr_type_phi)
         break;

      validate_phi_src(nir_instr_as_phi(instr), block, state);
   }
}

static void validate_cf_node(nir_cf_node *node, validate_state *state);

static void
validate_block(nir_block *block, validate_state *state)
{
790
   validate_assert(state, block->cf_node.parent == state->parent_node);
Connor Abbott's avatar
Connor Abbott committed
791
792
793

   state->block = block;

794
   exec_list_validate(&block->instr_list);
795
   nir_foreach_instr(instr, block) {
Connor Abbott's avatar
Connor Abbott committed
796
      if (instr->type == nir_instr_type_phi) {
797
         validate_assert(state, instr == nir_block_first_instr(block) ||
Connor Abbott's avatar
Connor Abbott committed
798
799
800
801
                nir_instr_prev(instr)->type == nir_instr_type_phi);
      }

      if (instr->type == nir_instr_type_jump) {
802
         validate_assert(state, instr == nir_block_last_instr(block));
Connor Abbott's avatar
Connor Abbott committed
803
804
805
806
807
      }

      validate_instr(instr, state);
   }

808
809
   validate_assert(state, block->successors[0] != NULL);
   validate_assert(state, block->successors[0] != block->successors[1]);
Connor Abbott's avatar
Connor Abbott committed
810
811
812
813

   for (unsigned i = 0; i < 2; i++) {
      if (block->successors[i] != NULL) {
         struct set_entry *entry =
814
            _mesa_set_search(block->successors[i]->predecessors, block);
815
         validate_assert(state, entry);
Connor Abbott's avatar
Connor Abbott committed
816
817
818
819
820

         validate_phi_srcs(block, block->successors[i], state);
      }
   }

821
822
   set_foreach(block->predecessors, entry) {
      const nir_block *pred = entry->key;
823
      validate_assert(state, pred->successors[0] == block ||
824
825
826
             pred->successors[1] == block);
   }

Connor Abbott's avatar
Connor Abbott committed
827
   if (!exec_list_is_empty(&block->instr_list) &&
828
       nir_block_last_instr(block)->type == nir_instr_type_jump) {
829
      validate_assert(state, block->successors[1] == NULL);
830
831
832
833
834
      nir_jump_instr *jump = nir_instr_as_jump(nir_block_last_instr(block));
      switch (jump->type) {
      case nir_jump_break: {
         nir_block *after =
            nir_cf_node_as_block(nir_cf_node_next(&state->loop->cf_node));
835
         validate_assert(state, block->successors[0] == after);
836
837
838
839
         break;
      }

      case nir_jump_continue: {
840
         nir_block *first = nir_loop_first_block(state->loop);
841
         validate_assert(state, block->successors[0] == first);
842
843
844
845
         break;
      }

      case nir_jump_return:
846
         validate_assert(state, block->successors[0] == state->impl->end_block);
847
848
849
850
851
852
853
854
855
856
         break;

      default:
         unreachable("bad jump type");
      }
   } else {
      nir_cf_node *next = nir_cf_node_next(&block->cf_node);
      if (next == NULL) {
         switch (state->parent_node->type) {
         case nir_cf_node_loop: {
857
            nir_block *first = nir_loop_first_block(state->loop);
858
            validate_assert(state, block->successors[0] == first);
859
860
861
862
863
864
865
866
867
            /* due to the hack for infinite loops, block->successors[1] may
             * point to the block after the loop.
             */
            break;
         }

         case nir_cf_node_if: {
            nir_block *after =
               nir_cf_node_as_block(nir_cf_node_next(state->parent_node));
868
869
            validate_assert(state, block->successors[0] == after);
            validate_assert(state, block->successors[1] == NULL);
870
871
872
873
            break;
         }

         case nir_cf_node_function:
874
875
            validate_assert(state, block->successors[0] == state->impl->end_block);
            validate_assert(state, block->successors[1] == NULL);
876
877
878
879
880
881
882
883
            break;

         default:
            unreachable("unknown control flow node type");
         }
      } else {
         if (next->type == nir_cf_node_if) {
            nir_if *if_stmt = nir_cf_node_as_if(next);
884
885
886
887
            validate_assert(state, block->successors[0] ==
                   nir_if_first_then_block(if_stmt));
            validate_assert(state, block->successors[1] ==
                   nir_if_first_else_block(if_stmt));
888
         } else {
889
            validate_assert(state, next->type == nir_cf_node_loop);
890
            nir_loop *loop = nir_cf_node_as_loop(next);
891
892
            validate_assert(state, block->successors[0] ==
                   nir_loop_first_block(loop));
893
            validate_assert(state, block->successors[1] == NULL);
894
895
896
         }
      }
   }
Connor Abbott's avatar
Connor Abbott committed
897
898
899
900
901
}

static void
validate_if(nir_if *if_stmt, validate_state *state)
{
902
903
   state->if_stmt = if_stmt;

904
   validate_assert(state, !exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
Connor Abbott's avatar
Connor Abbott committed
905
   nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node);
906
   validate_assert(state, prev_node->type == nir_cf_node_block);
Connor Abbott's avatar
Connor Abbott committed
907

908
   validate_assert(state, !exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
Connor Abbott's avatar
Connor Abbott committed
909
   nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node);
910
   validate_assert(state, next_node->type == nir_cf_node_block);
Connor Abbott's avatar
Connor Abbott committed
911

912
   validate_src(&if_stmt->condition, state, 0, 1);
Connor Abbott's avatar
Connor Abbott committed
913

914
915
   validate_assert(state, !exec_list_is_empty(&if_stmt->then_list));
   validate_assert(state, !exec_list_is_empty(&if_stmt->else_list));
Connor Abbott's avatar
Connor Abbott committed
916
917
918
919

   nir_cf_node *old_parent = state->parent_node;
   state->parent_node = &if_stmt->cf_node;

920
   exec_list_validate(&if_stmt->then_list);
Connor Abbott's avatar
Connor Abbott committed
921
922
923
924
   foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) {
      validate_cf_node(cf_node, state);
   }

925
   exec_list_validate(&if_stmt->else_list);
Connor Abbott's avatar
Connor Abbott committed
926
927
928
929
930
   foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) {
      validate_cf_node(cf_node, state);
   }

   state->parent_node = old_parent;
931
   state->if_stmt = NULL;
Connor Abbott's avatar
Connor Abbott committed
932
933
934
935
936
}

static void
validate_loop(nir_loop *loop, validate_state *state)
{
937
   validate_assert(state, !exec_node_is_head_sentinel(loop->cf_node.node.prev));
Connor Abbott's avatar
Connor Abbott committed
938
   nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node);
939
   validate_assert(state, prev_node->type == nir_cf_node_block);
Connor Abbott's avatar
Connor Abbott committed
940

941
   validate_assert(state, !exec_node_is_tail_sentinel(loop->cf_node.node.next));
Connor Abbott's avatar
Connor Abbott committed
942
   nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node);
943
   validate_assert(state, next_node->type == nir_cf_node_block);
Connor Abbott's avatar
Connor Abbott committed
944

945
   validate_assert(state, !exec_list_is_empty(&loop->body));
Connor Abbott's avatar
Connor Abbott committed
946
947
948

   nir_cf_node *old_parent = state->parent_node;
   state->parent_node = &loop->cf_node;
949
950
   nir_loop *old_loop = state->loop;
   state->loop = loop;
Connor Abbott's avatar
Connor Abbott committed
951

952
   exec_list_validate(&loop->body);
Connor Abbott's avatar
Connor Abbott committed
953
954
955
956
957
   foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) {
      validate_cf_node(cf_node, state);
   }

   state->parent_node = old_parent;
958
   state->loop = old_loop;
Connor Abbott's avatar
Connor Abbott committed
959
960
961
962
963
}

static void
validate_cf_node(nir_cf_node *node, validate_state *state)
{
964
   validate_assert(state, node->parent == state->parent_node);
Connor Abbott's avatar
Connor Abbott committed
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979

   switch (node->type) {
   case nir_cf_node_block:
      validate_block(nir_cf_node_as_block(node), state);
      break;

   case nir_cf_node_if:
      validate_if(nir_cf_node_as_if(node), state);
      break;

   case nir_cf_node_loop:
      validate_loop(nir_cf_node_as_loop(node), state);
      break;

   default:
980
      unreachable("Invalid CF node type");
Connor Abbott's avatar
Connor Abbott committed
981
982
983
984
   }
}

static void
985
prevalidate_reg_decl(nir_register *reg, validate_state *state)
Connor Abbott's avatar
Connor Abbott committed
986
{
987
   validate_assert(state, reg->index < state->impl->reg_alloc);
988
   validate_assert(state, !BITSET_TEST(state->regs_found, reg->index));
989
990
   BITSET_SET(state->regs_found, reg->index);

991
992
993
994
   list_validate(&reg->uses);
   list_validate(&reg->defs);
   list_validate(&reg->if_uses);

Connor Abbott's avatar
Connor Abbott committed
995
   reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
996
997
998
   reg_state->uses = _mesa_pointer_set_create(reg_state);
   reg_state->if_uses = _mesa_pointer_set_create(reg_state);
   reg_state->defs = _mesa_pointer_set_create(reg_state);
Connor Abbott's avatar
Connor Abbott committed
999

1000
   reg_state->where_defined = state->impl;
Connor Abbott's avatar
Connor Abbott committed
1001
1002
1003
1004
1005
1006
1007
1008
1009

   _mesa_hash_table_insert(state->regs, reg, reg_state);
}

static void
postvalidate_reg_decl(nir_register *reg, validate_state *state)
{
   struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);

1010
   assume(entry);
Connor Abbott's avatar
Connor Abbott committed
1011
1012
   reg_validate_state *reg_state = (reg_validate_state *) entry->data;

1013
   nir_foreach_use(src, reg) {
1014
      struct set_entry *entry = _mesa_set_search(reg_state->uses, src);
1015
      validate_assert(state, entry);
1016
1017
1018
1019
      _mesa_set_remove(reg_state->uses, entry);
   }

   if (reg_state->uses->entries != 0) {
Connor Abbott's avatar
Connor Abbott committed
1020
      printf("extra entries in register uses:\n");
1021
1022
      set_foreach(reg_state->uses, entry)
         printf("%p\n", entry->key);
Connor Abbott's avatar
Connor Abbott committed
1023
1024
1025
1026

      abort();
   }

1027
   nir_foreach_if_use(src, reg) {
1028
      struct set_entry *entry = _mesa_set_search(reg_state->if_uses, src);
1029
      validate_assert(state, entry);
1030
1031
1032
1033
      _mesa_set_remove(reg_state->if_uses, entry);
   }

   if (reg_state->if_uses->entries != 0) {
1034
      printf("extra entries in register if_uses:\n");
1035
1036
      set_foreach(reg_state->if_uses, entry)
         printf("%p\n", entry->key);
1037
1038
1039
1040

      abort();
   }

1041
   nir_foreach_def(src, reg) {
1042
      struct set_entry *entry = _mesa_set_search(reg_state->defs, src);
1043
      validate_assert(state, entry);
1044
1045
1046
1047
      _mesa_set_remove(reg_state->defs, entry);
   }

   if (reg_state->defs->entries != 0) {
Connor Abbott's avatar
Connor Abbott committed
1048
      printf("extra entries in register defs:\n");
1049
1050
      set_foreach(reg_state->defs, entry)
         printf("%p\n", entry->key);
Connor Abbott's avatar
Connor Abbott committed
1051
1052
1053
1054
1055
1056
1057
1058

      abort();
   }
}

static void
validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
{
1059
1060
   state->var = var;

1061
   validate_assert(state, is_global == nir_variable_is_global(var));
Connor Abbott's avatar
Connor Abbott committed
1062

1063
   /* Must have exactly one mode set */
1064
   validate_assert(state, util_is_power_of_two_nonzero(var->data.mode));
1065

1066
1067
1068
1069
1070
   if (var->data.compact) {
      /* The "compact" flag is only valid on arrays of scalars. */
      assert(glsl_type_is_array(var->type));

      const struct glsl_type *type = glsl_get_array_element(var->type);
1071
      if (nir_is_per_vertex_io(var, state->shader->info.stage)) {
1072
1073
1074
1075
1076
1077
1078
         assert(glsl_type_is_array(type));
         assert(glsl_type_is_scalar(glsl_get_array_element(type)));
      } else {
         assert(glsl_type_is_scalar(type));
      }
   }

1079
1080
   if (var->num_members > 0) {
      const struct glsl_type *without_array = glsl_without_array(var->type);
1081
      validate_assert(state, glsl_type_is_struct_or_ifc(without_array));
1082
1083
1084
1085
      validate_assert(state, var->num_members == glsl_get_length(without_array));
      validate_assert(state, var->members != NULL);
   }

Connor Abbott's avatar
Connor Abbott committed
1086
1087
1088
1089
1090
   /*
    * TODO validate some things ir_validate.cpp does (requires more GLSL type
    * support)
    */

1091
1092
   _mesa_hash_table_insert(state->var_defs, var,
                           is_global ? NULL : state->impl);
1093
1094

   state->var = NULL;
Connor Abbott's avatar
Connor Abbott committed
1095
1096
1097
1098
1099
}

static void
validate_function_impl(nir_function_impl *impl, validate_state *state)
{
1100
1101
1102
1103
1104
1105
1106
1107
1108
   /* Resize the ssa_srcs set.  It's likely that the size of this set will
    * never actually hit the number of SSA defs because we remove sources from
    * the set as we visit them.  (It could actually be much larger because
    * each SSA def can be used more than once.)  However, growing it now costs
    * us very little (the extra memory is already dwarfed by the SSA defs
    * themselves) and makes collisions much less likely.
    */
   _mesa_set_resize(state->ssa_srcs, impl->ssa_alloc);

1109
1110
   validate_assert(state, impl->function->impl == impl);
   validate_assert(state, impl->cf_node.parent == NULL);
Connor Abbott's avatar
Connor Abbott committed
1111

1112
1113
1114
   validate_assert(state, exec_list_is_empty(&impl->end_block->instr_list));
   validate_assert(state, impl->end_block->successors[0] == NULL);
   validate_assert(state, impl->end_block->successors[1] == NULL);
Connor Abbott's avatar
Connor Abbott committed
1115
1116
1117
1118

   state->impl = impl;
   state->parent_node = &impl->cf_node;

1119
   exec_list_validate(&impl->locals);
1120
   nir_foreach_variable(var, &impl->locals) {
Connor Abbott's avatar
Connor Abbott committed
1121
1122
1123
      validate_var_decl(var, false, state);
   }