src/glsl/nir/nir_validate.c

   1 /*
   2  * Copyright © 2014 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Connor Abbott (cwabbott0@gmail.com)
  25  *
  26  */
  27
  28 #include "nir.h"
  29 #include <assert.h>
  30
  31 /*
  32  * This file checks for invalid IR indicating a bug somewhere in the compiler.
  33  */
  34
  35 /* Since this file is just a pile of asserts, don't bother compiling it if
  36  * we're not building a debug build.
  37  */
  38 #ifdef DEBUG
  39
  40 /*
  41  * Per-register validation state.
  42  */
  43
  44 typedef struct {
  45    /*
  46     * equivalent to the uses and defs in nir_register, but built up by the
  47     * validator. At the end, we verify that the sets have the same entries.
  48     */
  49    struct set *uses, *if_uses, *defs;
  50    nir_function_impl *where_defined; /* NULL for global registers */
  51 } reg_validate_state;
  52
  53 typedef struct {
  54    /*
  55     * equivalent to the uses in nir_ssa_def, but built up by the validator.
  56     * At the end, we verify that the sets have the same entries.
  57     */
  58    struct set *uses, *if_uses;
  59    nir_function_impl *where_defined;
  60 } ssa_def_validate_state;
  61
  62 typedef struct {
  63    /* map of register -> validation state (struct above) */
  64    struct hash_table *regs;
  65
  66    /* the current shader being validated */
  67    nir_shader *shader;
  68
  69    /* the current instruction being validated */
  70    nir_instr *instr;
  71
  72    /* the current basic block being validated */
  73    nir_block *block;
  74
  75    /* the current if statement being validated */
  76    nir_if *if_stmt;
  77
  78    /* the parent of the current cf node being visited */
  79    nir_cf_node *parent_node;
  80
  81    /* the current function implementation being validated */
  82    nir_function_impl *impl;
  83
  84    /* map of SSA value -> function implementation where it is defined */
  85    struct hash_table *ssa_defs;
  86
  87    /* bitset of ssa definitions we have found; used to check uniqueness */
  88    BITSET_WORD *ssa_defs_found;
  89
  90    /* bitset of registers we have currently found; used to check uniqueness */
  91    BITSET_WORD *regs_found;
  92
  93    /* map of local variable -> function implementation where it is defined */
  94    struct hash_table *var_defs;
  95 } validate_state;
  96
  97 static void validate_src(nir_src *src, validate_state *state);
  98
  99 static void
 100 validate_reg_src(nir_src *src, validate_state *state)
 101 {
 102    assert(src->reg.reg != NULL);
 103
 104    struct hash_entry *entry;
 105    entry = _mesa_hash_table_search(state->regs, src->reg.reg);
 106    assert(entry);
 107
 108    reg_validate_state *reg_state = (reg_validate_state *) entry->data;
 109
 110    if (state->instr) {
 111       _mesa_set_add(reg_state->uses, src);
 112    } else {
 113       assert(state->if_stmt);
 114       _mesa_set_add(reg_state->if_uses, src);
 115    }
 116
 117    if (!src->reg.reg->is_global) {
 118       assert(reg_state->where_defined == state->impl &&
 119              "using a register declared in a different function");
 120    }
 121
 122    assert((src->reg.reg->num_array_elems == 0 ||
 123           src->reg.base_offset < src->reg.reg->num_array_elems) &&
 124           "definitely out-of-bounds array access");
 125
 126    if (src->reg.indirect) {
 127       assert(src->reg.reg->num_array_elems != 0);
 128       assert((src->reg.indirect->is_ssa ||
 129               src->reg.indirect->reg.indirect == NULL) &&
 130              "only one level of indirection allowed");
 131       validate_src(src->reg.indirect, state);
 132    }
 133 }
 134
 135 static void
 136 validate_ssa_src(nir_src *src, validate_state *state)
 137 {
 138    assert(src->ssa != NULL);
 139
 140    struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, src->ssa);
 141
 142    assert(entry);
 143
 144    ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data;
 145
 146    assert(def_state->where_defined == state->impl &&
 147           "using an SSA value defined in a different function");
 148
 149    if (state->instr) {
 150       _mesa_set_add(def_state->uses, src);
 151    } else {
 152       assert(state->if_stmt);
 153       _mesa_set_add(def_state->if_uses, src);
 154    }
 155
 156    /* TODO validate that the use is dominated by the definition */
 157 }
 158
 159 static void
 160 validate_src(nir_src *src, validate_state *state)
 161 {
 162    if (state->instr)
 163       assert(src->parent_instr == state->instr);
 164    else
 165       assert(src->parent_if == state->if_stmt);
 166
 167    if (src->is_ssa)
 168       validate_ssa_src(src, state);
 169    else
 170       validate_reg_src(src, state);
 171 }
 172
 173 static void
 174 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
 175 {
 176    nir_alu_src *src = &instr->src[index];
 177
 178    unsigned num_components;
 179    if (src->src.is_ssa)
 180       num_components = src->src.ssa->num_components;
 181    else {
 182       if (src->src.reg.reg->is_packed)
 183          num_components = 4; /* can't check anything */
 184       else
 185          num_components = src->src.reg.reg->num_components;
 186    }
 187    for (unsigned i = 0; i < 4; i++) {
 188       assert(src->swizzle[i] < 4);
 189
 190       if (nir_alu_instr_channel_used(instr, index, i))
 191          assert(src->swizzle[i] < num_components);
 192    }
 193
 194    validate_src(&src->src, state);
 195 }
 196
 197 static void
 198 validate_reg_dest(nir_reg_dest *dest, validate_state *state)
 199 {
 200    assert(dest->reg != NULL);
 201
 202    assert(dest->parent_instr == state->instr);
 203
 204    struct hash_entry *entry2;
 205    entry2 = _mesa_hash_table_search(state->regs, dest->reg);
 206
 207    assert(entry2);
 208
 209    reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
 210    _mesa_set_add(reg_state->defs, dest);
 211
 212    if (!dest->reg->is_global) {
 213       assert(reg_state->where_defined == state->impl &&
 214              "writing to a register declared in a different function");
 215    }
 216
 217    assert((dest->reg->num_array_elems == 0 ||
 218           dest->base_offset < dest->reg->num_array_elems) &&
 219           "definitely out-of-bounds array access");
 220
 221    if (dest->indirect) {
 222       assert(dest->reg->num_array_elems != 0);
 223       assert((dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
 224              "only one level of indirection allowed");
 225       validate_src(dest->indirect, state);
 226    }
 227 }
 228
 229 static void
 230 validate_ssa_def(nir_ssa_def *def, validate_state *state)
 231 {
 232    assert(def->index < state->impl->ssa_alloc);
 233    assert(!BITSET_TEST(state->ssa_defs_found, def->index));
 234    BITSET_SET(state->ssa_defs_found, def->index);
 235
 236    assert(def->parent_instr == state->instr);
 237
 238    assert(def->num_components <= 4);
 239
 240    list_validate(&def->uses);
 241    list_validate(&def->if_uses);
 242
 243    ssa_def_validate_state *def_state = ralloc(state->ssa_defs,
 244                                               ssa_def_validate_state);
 245    def_state->where_defined = state->impl;
 246    def_state->uses = _mesa_set_create(def_state, _mesa_hash_pointer,
 247                                       _mesa_key_pointer_equal);
 248    def_state->if_uses = _mesa_set_create(def_state, _mesa_hash_pointer,
 249                                          _mesa_key_pointer_equal);
 250    _mesa_hash_table_insert(state->ssa_defs, def, def_state);
 251 }
 252
 253 static void
 254 validate_dest(nir_dest *dest, validate_state *state)
 255 {
 256    if (dest->is_ssa)
 257       validate_ssa_def(&dest->ssa, state);
 258    else
 259       validate_reg_dest(&dest->reg, state);
 260 }
 261
 262 static void
 263 validate_alu_dest(nir_alu_dest *dest, validate_state *state)
 264 {
 265    unsigned dest_size =
 266       dest->dest.is_ssa ? dest->dest.ssa.num_components
 267                         : dest->dest.reg.reg->num_components;
 268    bool is_packed = !dest->dest.is_ssa && dest->dest.reg.reg->is_packed;
 269    /*
 270     * validate that the instruction doesn't write to components not in the
 271     * register/SSA value
 272     */
 273    assert(is_packed || !(dest->write_mask & ~((1 << dest_size) - 1)));
 274
 275    /* validate that saturate is only ever used on instructions with
 276     * destinations of type float
 277     */
 278    nir_alu_instr *alu = nir_instr_as_alu(state->instr);
 279    assert(nir_op_infos[alu->op].output_type == nir_type_float ||
 280           !dest->saturate);
 281
 282    validate_dest(&dest->dest, state);
 283 }
 284
 285 static void
 286 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
 287 {
 288    assert(instr->op < nir_num_opcodes);
 289
 290    validate_alu_dest(&instr->dest, state);
 291
 292    for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
 293       validate_alu_src(instr, i, state);
 294    }
 295 }
 296
 297 static void
 298 validate_deref_chain(nir_deref *deref, validate_state *state)
 299 {
 300    assert(deref->child == NULL || ralloc_parent(deref->child) == deref);
 301
 302    nir_deref *parent = NULL;
 303    while (deref != NULL) {
 304       switch (deref->deref_type) {
 305       case nir_deref_type_array:
 306          assert(deref->type == glsl_get_array_element(parent->type));
 307          if (nir_deref_as_array(deref)->deref_array_type ==
 308              nir_deref_array_type_indirect)
 309             validate_src(&nir_deref_as_array(deref)->indirect, state);
 310          break;
 311
 312       case nir_deref_type_struct:
 313          assert(deref->type ==
 314                 glsl_get_struct_field(parent->type,
 315                                       nir_deref_as_struct(deref)->index));
 316          break;
 317
 318       case nir_deref_type_var:
 319          break;
 320
 321       default:
 322          assert(!"Invalid deref type");
 323          break;
 324       }
 325
 326       parent = deref;
 327       deref = deref->child;
 328    }
 329 }
 330
 331 static void
 332 validate_var_use(nir_variable *var, validate_state *state)
 333 {
 334    if (var->data.mode == nir_var_local) {
 335       struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
 336
 337       assert(entry);
 338       assert((nir_function_impl *) entry->data == state->impl);
 339    }
 340 }
 341
 342 static void
 343 validate_deref_var(void *parent_mem_ctx, nir_deref_var *deref, validate_state *state)
 344 {
 345    assert(deref != NULL);
 346    assert(ralloc_parent(deref) == parent_mem_ctx);
 347    assert(deref->deref.type == deref->var->type);
 348
 349    validate_var_use(deref->var, state);
 350
 351    validate_deref_chain(&deref->deref, state);
 352 }
 353
 354 static void
 355 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
 356 {
 357    unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
 358    for (unsigned i = 0; i < num_srcs; i++) {
 359       unsigned components_read =
 360          nir_intrinsic_infos[instr->intrinsic].src_components[i];
 361       if (components_read == 0)
 362          components_read = instr->num_components;
 363
 364       assert(components_read > 0);
 365
 366       if (instr->src[i].is_ssa) {
 367          assert(components_read <= instr->src[i].ssa->num_components);
 368       } else if (!instr->src[i].reg.reg->is_packed) {
 369          assert(components_read <= instr->src[i].reg.reg->num_components);
 370       }
 371
 372       validate_src(&instr->src[i], state);
 373    }
 374
 375    if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
 376       unsigned components_written =
 377          nir_intrinsic_infos[instr->intrinsic].dest_components;
 378       if (components_written == 0)
 379          components_written = instr->num_components;
 380
 381       assert(components_written > 0);
 382
 383       if (instr->dest.is_ssa) {
 384          assert(components_written <= instr->dest.ssa.num_components);
 385       } else if (!instr->dest.reg.reg->is_packed) {
 386          assert(components_written <= instr->dest.reg.reg->num_components);
 387       }
 388
 389       validate_dest(&instr->dest, state);
 390    }
 391
 392    unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
 393    for (unsigned i = 0; i < num_vars; i++) {
 394       validate_deref_var(instr, instr->variables[i], state);
 395    }
 396
 397    switch (instr->intrinsic) {
 398    case nir_intrinsic_load_var:
 399       assert(instr->variables[0]->var->data.mode != nir_var_shader_out);
 400       break;
 401    case nir_intrinsic_store_var:
 402       assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
 403              instr->variables[0]->var->data.mode != nir_var_uniform);
 404       break;
 405    case nir_intrinsic_copy_var:
 406       assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
 407              instr->variables[0]->var->data.mode != nir_var_uniform);
 408       assert(instr->variables[1]->var->data.mode != nir_var_shader_out);
 409       break;
 410    default:
 411       break;
 412    }
 413 }
 414
 415 static void
 416 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
 417 {
 418    validate_dest(&instr->dest, state);
 419
 420    bool src_type_seen[nir_num_tex_src_types];
 421    for (unsigned i = 0; i < nir_num_tex_src_types; i++)
 422       src_type_seen[i] = false;
 423
 424    for (unsigned i = 0; i < instr->num_srcs; i++) {
 425       assert(!src_type_seen[instr->src[i].src_type]);
 426       src_type_seen[instr->src[i].src_type] = true;
 427       validate_src(&instr->src[i].src, state);
 428    }
 429
 430    if (instr->sampler != NULL)
 431       validate_deref_var(instr, instr->sampler, state);
 432 }
 433
 434 static void
 435 validate_call_instr(nir_call_instr *instr, validate_state *state)
 436 {
 437    if (instr->return_deref == NULL)
 438       assert(glsl_type_is_void(instr->callee->return_type));
 439    else
 440       assert(instr->return_deref->deref.type == instr->callee->return_type);
 441
 442    assert(instr->num_params == instr->callee->num_params);
 443
 444    for (unsigned i = 0; i < instr->num_params; i++) {
 445       assert(instr->callee->params[i].type == instr->params[i]->deref.type);
 446       validate_deref_var(instr, instr->params[i], state);
 447    }
 448
 449    validate_deref_var(instr, instr->return_deref, state);
 450 }
 451
 452 static void
 453 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
 454 {
 455    validate_ssa_def(&instr->def, state);
 456 }
 457
 458 static void
 459 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
 460 {
 461    validate_ssa_def(&instr->def, state);
 462 }
 463
 464 static void
 465 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
 466 {
 467    /*
 468     * don't validate the sources until we get to them from their predecessor
 469     * basic blocks, to avoid validating an SSA use before its definition.
 470     */
 471
 472    validate_dest(&instr->dest, state);
 473
 474    exec_list_validate(&instr->srcs);
 475    assert(exec_list_length(&instr->srcs) ==
 476           state->block->predecessors->entries);
 477 }
 478
 479 static void
 480 validate_instr(nir_instr *instr, validate_state *state)
 481 {
 482    assert(instr->block == state->block);
 483
 484    state->instr = instr;
 485
 486    switch (instr->type) {
 487    case nir_instr_type_alu:
 488       validate_alu_instr(nir_instr_as_alu(instr), state);
 489       break;
 490
 491    case nir_instr_type_call:
 492       validate_call_instr(nir_instr_as_call(instr), state);
 493       break;
 494
 495    case nir_instr_type_intrinsic:
 496       validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
 497       break;
 498
 499    case nir_instr_type_tex:
 500       validate_tex_instr(nir_instr_as_tex(instr), state);
 501       break;
 502
 503    case nir_instr_type_load_const:
 504       validate_load_const_instr(nir_instr_as_load_const(instr), state);
 505       break;
 506
 507    case nir_instr_type_phi:
 508       validate_phi_instr(nir_instr_as_phi(instr), state);
 509       break;
 510
 511    case nir_instr_type_ssa_undef:
 512       validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
 513       break;
 514
 515    case nir_instr_type_jump:
 516       break;
 517
 518    default:
 519       assert(!"Invalid ALU instruction type");
 520       break;
 521    }
 522
 523    state->instr = NULL;
 524 }
 525
 526 static void
 527 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
 528 {
 529    state->instr = &instr->instr;
 530
 531    assert(instr->dest.is_ssa);
 532
 533    exec_list_validate(&instr->srcs);
 534    nir_foreach_phi_src(instr, src) {
 535       if (src->pred == pred) {
 536          assert(src->src.is_ssa);
 537          assert(src->src.ssa->num_components ==
 538                 instr->dest.ssa.num_components);
 539
 540          validate_src(&src->src, state);
 541          state->instr = NULL;
 542          return;
 543       }
 544    }
 545
 546    abort();
 547 }
 548
 549 static void
 550 validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
 551 {
 552    nir_foreach_instr(succ, instr) {
 553       if (instr->type != nir_instr_type_phi)
 554          break;
 555
 556       validate_phi_src(nir_instr_as_phi(instr), block, state);
 557    }
 558 }
 559
 560 static void validate_cf_node(nir_cf_node *node, validate_state *state);
 561
 562 static void
 563 validate_block(nir_block *block, validate_state *state)
 564 {
 565    assert(block->cf_node.parent == state->parent_node);
 566
 567    state->block = block;
 568
 569    exec_list_validate(&block->instr_list);
 570    nir_foreach_instr(block, instr) {
 571       if (instr->type == nir_instr_type_phi) {
 572          assert(instr == nir_block_first_instr(block) ||
 573                 nir_instr_prev(instr)->type == nir_instr_type_phi);
 574       }
 575
 576       if (instr->type == nir_instr_type_jump) {
 577          assert(instr == nir_block_last_instr(block));
 578       }
 579
 580       validate_instr(instr, state);
 581    }
 582
 583    assert(block->successors[0] != NULL);
 584
 585    for (unsigned i = 0; i < 2; i++) {
 586       if (block->successors[i] != NULL) {
 587          struct set_entry *entry =
 588             _mesa_set_search(block->successors[i]->predecessors, block);
 589          assert(entry);
 590
 591          validate_phi_srcs(block, block->successors[i], state);
 592       }
 593    }
 594
 595    if (!exec_list_is_empty(&block->instr_list) &&
 596        nir_block_last_instr(block)->type == nir_instr_type_jump)
 597       assert(block->successors[1] == NULL);
 598 }
 599
 600 static void
 601 validate_if(nir_if *if_stmt, validate_state *state)
 602 {
 603    state->if_stmt = if_stmt;
 604
 605    assert(!exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
 606    nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node);
 607    assert(prev_node->type == nir_cf_node_block);
 608
 609    nir_block *prev_block = nir_cf_node_as_block(prev_node);
 610    assert(&prev_block->successors[0]->cf_node ==
 611           nir_if_first_then_node(if_stmt));
 612    assert(&prev_block->successors[1]->cf_node ==
 613           nir_if_first_else_node(if_stmt));
 614
 615    assert(!exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
 616    nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node);
 617    assert(next_node->type == nir_cf_node_block);
 618
 619    validate_src(&if_stmt->condition, state);
 620
 621    assert(!exec_list_is_empty(&if_stmt->then_list));
 622    assert(!exec_list_is_empty(&if_stmt->else_list));
 623
 624    nir_cf_node *old_parent = state->parent_node;
 625    state->parent_node = &if_stmt->cf_node;
 626
 627    exec_list_validate(&if_stmt->then_list);
 628    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) {
 629       validate_cf_node(cf_node, state);
 630    }
 631
 632    exec_list_validate(&if_stmt->else_list);
 633    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) {
 634       validate_cf_node(cf_node, state);
 635    }
 636
 637    state->parent_node = old_parent;
 638    state->if_stmt = NULL;
 639 }
 640
 641 static void
 642 validate_loop(nir_loop *loop, validate_state *state)
 643 {
 644    assert(!exec_node_is_head_sentinel(loop->cf_node.node.prev));
 645    nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node);
 646    assert(prev_node->type == nir_cf_node_block);
 647
 648    nir_block *prev_block = nir_cf_node_as_block(prev_node);
 649    assert(&prev_block->successors[0]->cf_node == nir_loop_first_cf_node(loop));
 650    assert(prev_block->successors[1] == NULL);
 651
 652    assert(!exec_node_is_tail_sentinel(loop->cf_node.node.next));
 653    nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node);
 654    assert(next_node->type == nir_cf_node_block);
 655
 656    assert(!exec_list_is_empty(&loop->body));
 657
 658    nir_cf_node *old_parent = state->parent_node;
 659    state->parent_node = &loop->cf_node;
 660
 661    exec_list_validate(&loop->body);
 662    foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) {
 663       validate_cf_node(cf_node, state);
 664    }
 665
 666    state->parent_node = old_parent;
 667 }
 668
 669 static void
 670 validate_cf_node(nir_cf_node *node, validate_state *state)
 671 {
 672    assert(node->parent == state->parent_node);
 673
 674    switch (node->type) {
 675    case nir_cf_node_block:
 676       validate_block(nir_cf_node_as_block(node), state);
 677       break;
 678
 679    case nir_cf_node_if:
 680       validate_if(nir_cf_node_as_if(node), state);
 681       break;
 682
 683    case nir_cf_node_loop:
 684       validate_loop(nir_cf_node_as_loop(node), state);
 685       break;
 686
 687    default:
 688       unreachable("Invalid CF node type");
 689    }
 690 }
 691
 692 static void
 693 prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state)
 694 {
 695    assert(reg->is_global == is_global);
 696
 697    if (is_global)
 698       assert(reg->index < state->shader->reg_alloc);
 699    else
 700       assert(reg->index < state->impl->reg_alloc);
 701    assert(!BITSET_TEST(state->regs_found, reg->index));
 702    BITSET_SET(state->regs_found, reg->index);
 703
 704    list_validate(&reg->uses);
 705    list_validate(&reg->defs);
 706    list_validate(&reg->if_uses);
 707
 708    reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
 709    reg_state->uses = _mesa_set_create(reg_state, _mesa_hash_pointer,
 710                                       _mesa_key_pointer_equal);
 711    reg_state->if_uses = _mesa_set_create(reg_state, _mesa_hash_pointer,
 712                                          _mesa_key_pointer_equal);
 713    reg_state->defs = _mesa_set_create(reg_state, _mesa_hash_pointer,
 714                                       _mesa_key_pointer_equal);
 715
 716    reg_state->where_defined = is_global ? NULL : state->impl;
 717
 718    _mesa_hash_table_insert(state->regs, reg, reg_state);
 719 }
 720
 721 static void
 722 postvalidate_reg_decl(nir_register *reg, validate_state *state)
 723 {
 724    struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);
 725
 726    reg_validate_state *reg_state = (reg_validate_state *) entry->data;
 727
 728    nir_foreach_use(reg, src) {
 729       struct set_entry *entry = _mesa_set_search(reg_state->uses, src);
 730       assert(entry);
 731       _mesa_set_remove(reg_state->uses, entry);
 732    }
 733
 734    if (reg_state->uses->entries != 0) {
 735       printf("extra entries in register uses:\n");
 736       struct set_entry *entry;
 737       set_foreach(reg_state->uses, entry)
 738          printf("%p\n", entry->key);
 739
 740       abort();
 741    }
 742
 743    nir_foreach_if_use(reg, src) {
 744       struct set_entry *entry = _mesa_set_search(reg_state->if_uses, src);
 745       assert(entry);
 746       _mesa_set_remove(reg_state->if_uses, entry);
 747    }
 748
 749    if (reg_state->if_uses->entries != 0) {
 750       printf("extra entries in register if_uses:\n");
 751       struct set_entry *entry;
 752       set_foreach(reg_state->if_uses, entry)
 753          printf("%p\n", entry->key);
 754
 755       abort();
 756    }
 757
 758    nir_foreach_def(reg, src) {
 759       struct set_entry *entry = _mesa_set_search(reg_state->defs, src);
 760       assert(entry);
 761       _mesa_set_remove(reg_state->defs, entry);
 762    }
 763
 764    if (reg_state->defs->entries != 0) {
 765       printf("extra entries in register defs:\n");
 766       struct set_entry *entry;
 767       set_foreach(reg_state->defs, entry)
 768          printf("%p\n", entry->key);
 769
 770       abort();
 771    }
 772 }
 773
 774 static void
 775 validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
 776 {
 777    assert(is_global != (var->data.mode == nir_var_local));
 778
 779    /*
 780     * TODO validate some things ir_validate.cpp does (requires more GLSL type
 781     * support)
 782     */
 783
 784    if (!is_global) {
 785       _mesa_hash_table_insert(state->var_defs, var, state->impl);
 786    }
 787 }
 788
 789 static bool
 790 postvalidate_ssa_def(nir_ssa_def *def, void *void_state)
 791 {
 792    validate_state *state = void_state;
 793
 794    struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def);
 795    ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data;
 796
 797    nir_foreach_use(def, src) {
 798       struct set_entry *entry = _mesa_set_search(def_state->uses, src);
 799       assert(entry);
 800       _mesa_set_remove(def_state->uses, entry);
 801    }
 802
 803    if (def_state->uses->entries != 0) {
 804       printf("extra entries in register uses:\n");
 805       struct set_entry *entry;
 806       set_foreach(def_state->uses, entry)
 807          printf("%p\n", entry->key);
 808
 809       abort();
 810    }
 811
 812    nir_foreach_if_use(def, src) {
 813       struct set_entry *entry = _mesa_set_search(def_state->if_uses, src);
 814       assert(entry);
 815       _mesa_set_remove(def_state->if_uses, entry);
 816    }
 817
 818    if (def_state->if_uses->entries != 0) {
 819       printf("extra entries in register uses:\n");
 820       struct set_entry *entry;
 821       set_foreach(def_state->if_uses, entry)
 822          printf("%p\n", entry->key);
 823
 824       abort();
 825    }
 826
 827    return true;
 828 }
 829
 830 static bool
 831 postvalidate_ssa_defs_block(nir_block *block, void *state)
 832 {
 833    nir_foreach_instr(block, instr)
 834       nir_foreach_ssa_def(instr, postvalidate_ssa_def, state);
 835
 836    return true;
 837 }
 838
 839 static void
 840 validate_function_impl(nir_function_impl *impl, validate_state *state)
 841 {
 842    assert(impl->overload->impl == impl);
 843    assert(impl->cf_node.parent == NULL);
 844
 845    assert(impl->num_params == impl->overload->num_params);
 846    for (unsigned i = 0; i < impl->num_params; i++)
 847       assert(impl->params[i]->type == impl->overload->params[i].type);
 848
 849    if (glsl_type_is_void(impl->overload->return_type))
 850       assert(impl->return_var == NULL);
 851    else
 852       assert(impl->return_var->type == impl->overload->return_type);
 853
 854    assert(exec_list_is_empty(&impl->end_block->instr_list));
 855    assert(impl->end_block->successors[0] == NULL);
 856    assert(impl->end_block->successors[1] == NULL);
 857
 858    state->impl = impl;
 859    state->parent_node = &impl->cf_node;
 860
 861    exec_list_validate(&impl->locals);
 862    foreach_list_typed(nir_variable, var, node, &impl->locals) {
 863       validate_var_decl(var, false, state);
 864    }
 865
 866    state->regs_found = realloc(state->regs_found,
 867                                BITSET_WORDS(impl->reg_alloc) *
 868                                sizeof(BITSET_WORD));
 869    memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) *
 870                                 sizeof(BITSET_WORD));
 871    exec_list_validate(&impl->registers);
 872    foreach_list_typed(nir_register, reg, node, &impl->registers) {
 873       prevalidate_reg_decl(reg, false, state);
 874    }
 875
 876    state->ssa_defs_found = realloc(state->ssa_defs_found,
 877                                    BITSET_WORDS(impl->ssa_alloc) *
 878                                    sizeof(BITSET_WORD));
 879    memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) *
 880                                     sizeof(BITSET_WORD));
 881    exec_list_validate(&impl->body);
 882    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
 883       validate_cf_node(node, state);
 884    }
 885
 886    foreach_list_typed(nir_register, reg, node, &impl->registers) {
 887       postvalidate_reg_decl(reg, state);
 888    }
 889
 890    nir_foreach_block(impl, postvalidate_ssa_defs_block, state);
 891 }
 892
 893 static void
 894 validate_function_overload(nir_function_overload *overload,
 895                            validate_state *state)
 896 {
 897    if (overload->impl != NULL)
 898       validate_function_impl(overload->impl, state);
 899 }
 900
 901 static void
 902 validate_function(nir_function *func, validate_state *state)
 903 {
 904    exec_list_validate(&func->overload_list);
 905    foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
 906       assert(overload->function == func);
 907       validate_function_overload(overload, state);
 908    }
 909 }
 910
 911 static void
 912 init_validate_state(validate_state *state)
 913 {
 914    state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 915                                          _mesa_key_pointer_equal);
 916    state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 917                                              _mesa_key_pointer_equal);
 918    state->ssa_defs_found = NULL;
 919    state->regs_found = NULL;
 920    state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 921                                              _mesa_key_pointer_equal);
 922 }
 923
 924 static void
 925 destroy_validate_state(validate_state *state)
 926 {
 927    _mesa_hash_table_destroy(state->regs, NULL);
 928    _mesa_hash_table_destroy(state->ssa_defs, NULL);
 929    free(state->ssa_defs_found);
 930    free(state->regs_found);
 931    _mesa_hash_table_destroy(state->var_defs, NULL);
 932 }
 933
 934 void
 935 nir_validate_shader(nir_shader *shader)
 936 {
 937    validate_state state;
 938    init_validate_state(&state);
 939
 940    state.shader = shader;
 941
 942    exec_list_validate(&shader->uniforms);
 943    foreach_list_typed(nir_variable, var, node, &shader->uniforms) {
 944       validate_var_decl(var, true, &state);
 945    }
 946
 947    exec_list_validate(&shader->inputs);
 948    foreach_list_typed(nir_variable, var, node, &shader->inputs) {
 949      validate_var_decl(var, true, &state);
 950    }
 951
 952    exec_list_validate(&shader->outputs);
 953    foreach_list_typed(nir_variable, var, node, &shader->outputs) {
 954      validate_var_decl(var, true, &state);
 955    }
 956
 957    exec_list_validate(&shader->globals);
 958    foreach_list_typed(nir_variable, var, node, &shader->globals) {
 959      validate_var_decl(var, true, &state);
 960    }
 961
 962    exec_list_validate(&shader->system_values);
 963    foreach_list_typed(nir_variable, var, node, &shader->system_values) {
 964      validate_var_decl(var, true, &state);
 965    }
 966
 967    state.regs_found = realloc(state.regs_found,
 968                               BITSET_WORDS(shader->reg_alloc) *
 969                               sizeof(BITSET_WORD));
 970    memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) *
 971                                sizeof(BITSET_WORD));
 972    exec_list_validate(&shader->registers);
 973    foreach_list_typed(nir_register, reg, node, &shader->registers) {
 974       prevalidate_reg_decl(reg, true, &state);
 975    }
 976
 977    exec_list_validate(&shader->functions);
 978    foreach_list_typed(nir_function, func, node, &shader->functions) {
 979       validate_function(func, &state);
 980    }
 981
 982    foreach_list_typed(nir_register, reg, node, &shader->registers) {
 983       postvalidate_reg_decl(reg, &state);
 984    }
 985
 986    destroy_validate_state(&state);
 987 }
 988
 989 #endif /* NDEBUG */