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, *defs;
  50    nir_function_impl *where_defined; /* NULL for global registers */
  51 } reg_validate_state;
  52
  53 typedef struct {
  54    /* map of register -> validation state (struct above) */
  55    struct hash_table *regs;
  56
  57    /* the current shader being validated */
  58    nir_shader *shader;
  59
  60    /* the current instruction being validated */
  61    nir_instr *instr;
  62
  63    /* the current basic block being validated */
  64    nir_block *block;
  65
  66    /* the current if statement being validated */
  67    nir_if *if_stmt;
  68
  69    /* the parent of the current cf node being visited */
  70    nir_cf_node *parent_node;
  71
  72    /* the current function implementation being validated */
  73    nir_function_impl *impl;
  74
  75    /* map of SSA value -> function implementation where it is defined */
  76    struct hash_table *ssa_defs;
  77
  78    /* bitset of ssa definitions we have found; used to check uniqueness */
  79    BITSET_WORD *ssa_defs_found;
  80
  81    /* bitset of registers we have currently found; used to check uniqueness */
  82    BITSET_WORD *regs_found;
  83
  84    /* map of local variable -> function implementation where it is defined */
  85    struct hash_table *var_defs;
  86 } validate_state;
  87
  88 static void validate_src(nir_src *src, validate_state *state);
  89
  90 static void
  91 validate_reg_src(nir_reg_src *src, validate_state *state)
  92 {
  93    assert(src->reg != NULL);
  94
  95    struct set_entry *entry =
  96       _mesa_set_search(src->reg->uses, _mesa_hash_pointer(state->instr),
  97                        state->instr);
  98    assert(entry && "use not in nir_register.uses");
  99
 100    struct hash_entry *entry2;
 101    entry2 = _mesa_hash_table_search(state->regs, src->reg);
 102
 103    assert(entry2);
 104
 105    reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
 106    _mesa_set_add(reg_state->uses, _mesa_hash_pointer(state->instr),
 107                  state->instr);
 108
 109    if (!src->reg->is_global) {
 110       assert(reg_state->where_defined == state->impl &&
 111              "using a register declared in a different function");
 112    }
 113
 114    assert((src->reg->num_array_elems == 0 ||
 115           src->base_offset < src->reg->num_array_elems) &&
 116           "definitely out-of-bounds array access");
 117
 118    if (src->indirect) {
 119       assert(src->reg->num_array_elems != 0);
 120       assert((src->indirect->is_ssa || src->indirect->reg.indirect == NULL) &&
 121              "only one level of indirection allowed");
 122       validate_src(src->indirect, state);
 123    }
 124 }
 125
 126 static void
 127 validate_ssa_src(nir_ssa_def *def, validate_state *state)
 128 {
 129    assert(def != NULL);
 130
 131    struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def);
 132
 133    assert(entry);
 134
 135    assert((nir_function_impl *) entry->data == state->impl &&
 136           "using an SSA value defined in a different function");
 137
 138    struct set_entry *entry2;
 139
 140    entry2 = _mesa_set_search(def->uses, _mesa_hash_pointer(state->instr),
 141                               state->instr);
 142
 143    assert(entry2 && "SSA use missing");
 144
 145    /* TODO validate that the use is dominated by the definition */
 146 }
 147
 148 static void
 149 validate_src(nir_src *src, validate_state *state)
 150 {
 151    if (src->is_ssa)
 152       validate_ssa_src(src->ssa, state);
 153    else
 154       validate_reg_src(&src->reg, state);
 155 }
 156
 157 static void
 158 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
 159 {
 160    nir_alu_src *src = &instr->src[index];
 161
 162    unsigned num_components;
 163    if (src->src.is_ssa)
 164       num_components = src->src.ssa->num_components;
 165    else {
 166       if (src->src.reg.reg->is_packed)
 167          num_components = 4; /* can't check anything */
 168       else
 169          num_components = src->src.reg.reg->num_components;
 170    }
 171    for (unsigned i = 0; i < 4; i++) {
 172       assert(src->swizzle[i] < 4);
 173
 174       if (nir_alu_instr_channel_used(instr, index, i))
 175          assert(src->swizzle[i] < num_components);
 176    }
 177
 178    validate_src(&src->src, state);
 179 }
 180
 181 static void
 182 validate_reg_dest(nir_reg_dest *dest, validate_state *state)
 183 {
 184    assert(dest->reg != NULL);
 185
 186    struct set_entry *entry =
 187       _mesa_set_search(dest->reg->defs, _mesa_hash_pointer(state->instr),
 188                        state->instr);
 189    assert(entry && "definition not in nir_register.defs");
 190
 191    struct hash_entry *entry2;
 192    entry2 = _mesa_hash_table_search(state->regs, dest->reg);
 193
 194    assert(entry2);
 195
 196    reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
 197    _mesa_set_add(reg_state->defs, _mesa_hash_pointer(state->instr),
 198                  state->instr);
 199
 200    if (!dest->reg->is_global) {
 201       assert(reg_state->where_defined == state->impl &&
 202              "writing to a register declared in a different function");
 203    }
 204
 205    assert((dest->reg->num_array_elems == 0 ||
 206           dest->base_offset < dest->reg->num_array_elems) &&
 207           "definitely out-of-bounds array access");
 208
 209    if (dest->indirect) {
 210       assert(dest->reg->num_array_elems != 0);
 211       assert((dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
 212              "only one level of indirection allowed");
 213       validate_src(dest->indirect, state);
 214    }
 215 }
 216
 217 static void
 218 validate_ssa_def(nir_ssa_def *def, validate_state *state)
 219 {
 220    assert(def->index < state->impl->ssa_alloc);
 221    assert(!BITSET_TEST(state->ssa_defs_found, def->index));
 222    BITSET_SET(state->ssa_defs_found, def->index);
 223
 224    assert(def->num_components <= 4);
 225    _mesa_hash_table_insert(state->ssa_defs, def, state->impl);
 226 }
 227
 228 static void
 229 validate_dest(nir_dest *dest, validate_state *state)
 230 {
 231    if (dest->is_ssa)
 232       validate_ssa_def(&dest->ssa, state);
 233    else
 234       validate_reg_dest(&dest->reg, state);
 235 }
 236
 237 static void
 238 validate_alu_dest(nir_alu_dest *dest, validate_state *state)
 239 {
 240    unsigned dest_size =
 241       dest->dest.is_ssa ? dest->dest.ssa.num_components
 242                         : dest->dest.reg.reg->num_components;
 243    bool is_packed = !dest->dest.is_ssa && dest->dest.reg.reg->is_packed;
 244    /*
 245     * validate that the instruction doesn't write to components not in the
 246     * register/SSA value
 247     */
 248    assert(is_packed || !(dest->write_mask & ~((1 << dest_size) - 1)));
 249    validate_dest(&dest->dest, state);
 250 }
 251
 252 static void
 253 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
 254 {
 255    assert(instr->op < nir_num_opcodes);
 256
 257    validate_alu_dest(&instr->dest, state);
 258
 259    for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
 260       validate_alu_src(instr, i, state);
 261    }
 262 }
 263
 264 static void
 265 validate_deref_chain(nir_deref *deref, validate_state *state)
 266 {
 267    nir_deref *parent = NULL;
 268    while (deref != NULL) {
 269       switch (deref->deref_type) {
 270       case nir_deref_type_array:
 271          assert(deref->type == glsl_get_array_element(parent->type));
 272          if (nir_deref_as_array(deref)->deref_array_type ==
 273              nir_deref_array_type_indirect)
 274             validate_src(&nir_deref_as_array(deref)->indirect, state);
 275          break;
 276
 277       case nir_deref_type_struct:
 278          assert(deref->type ==
 279                 glsl_get_struct_field(parent->type,
 280                                       nir_deref_as_struct(deref)->index));
 281          break;
 282
 283       case nir_deref_type_var:
 284          break;
 285
 286       default:
 287          assert(!"Invalid deref type");
 288          break;
 289       }
 290
 291       parent = deref;
 292       deref = deref->child;
 293    }
 294 }
 295
 296 static void
 297 validate_var_use(nir_variable *var, validate_state *state)
 298 {
 299    if (var->data.mode == nir_var_local) {
 300       struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
 301
 302       assert(entry);
 303       assert((nir_function_impl *) entry->data == state->impl);
 304    }
 305 }
 306
 307 static void
 308 validate_deref_var(nir_deref_var *deref, validate_state *state)
 309 {
 310    assert(deref != NULL);
 311    assert(deref->deref.type == deref->var->type);
 312
 313    validate_var_use(deref->var, state);
 314
 315    validate_deref_chain(&deref->deref, state);
 316 }
 317
 318 static void
 319 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
 320 {
 321    unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
 322    for (unsigned i = 0; i < num_srcs; i++) {
 323       unsigned components_read =
 324          nir_intrinsic_infos[instr->intrinsic].src_components[i];
 325       if (components_read == 0)
 326          components_read = instr->num_components;
 327
 328       assert(components_read > 0);
 329
 330       if (instr->src[i].is_ssa) {
 331          assert(components_read <= instr->src[i].ssa->num_components);
 332       } else if (!instr->src[i].reg.reg->is_packed) {
 333          assert(components_read <= instr->src[i].reg.reg->num_components);
 334       }
 335
 336       validate_src(&instr->src[i], state);
 337    }
 338
 339    if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
 340       unsigned components_written =
 341          nir_intrinsic_infos[instr->intrinsic].dest_components;
 342       if (components_written == 0)
 343          components_written = instr->num_components;
 344
 345       assert(components_written > 0);
 346
 347       if (instr->dest.is_ssa) {
 348          assert(components_written <= instr->dest.ssa.num_components);
 349       } else if (!instr->dest.reg.reg->is_packed) {
 350          assert(components_written <= instr->dest.reg.reg->num_components);
 351       }
 352
 353       validate_dest(&instr->dest, state);
 354    }
 355
 356    unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
 357    for (unsigned i = 0; i < num_vars; i++) {
 358       validate_deref_var(instr->variables[i], state);
 359    }
 360
 361    switch (instr->intrinsic) {
 362    case nir_intrinsic_load_var:
 363       assert(instr->variables[0]->var->data.mode != nir_var_shader_out);
 364       break;
 365    case nir_intrinsic_store_var:
 366       assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
 367              instr->variables[0]->var->data.mode != nir_var_uniform);
 368       break;
 369    case nir_intrinsic_copy_var:
 370       assert(instr->variables[0]->var->data.mode != nir_var_shader_in &&
 371              instr->variables[0]->var->data.mode != nir_var_uniform);
 372       assert(instr->variables[1]->var->data.mode != nir_var_shader_out);
 373       break;
 374    default:
 375       break;
 376    }
 377 }
 378
 379 static void
 380 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
 381 {
 382    validate_dest(&instr->dest, state);
 383
 384    bool src_type_seen[nir_num_texinput_types];
 385    for (unsigned i = 0; i < nir_num_texinput_types; i++)
 386       src_type_seen[i] = false;
 387
 388    for (unsigned i = 0; i < instr->num_srcs; i++) {
 389       assert(!src_type_seen[instr->src_type[i]]);
 390       src_type_seen[instr->src_type[i]] = true;
 391       validate_src(&instr->src[i], state);
 392    }
 393
 394    if (instr->sampler != NULL)
 395       validate_deref_var(instr->sampler, state);
 396 }
 397
 398 static void
 399 validate_call_instr(nir_call_instr *instr, validate_state *state)
 400 {
 401    if (instr->return_deref == NULL)
 402       assert(glsl_type_is_void(instr->callee->return_type));
 403    else
 404       assert(instr->return_deref->deref.type == instr->callee->return_type);
 405
 406    assert(instr->num_params == instr->callee->num_params);
 407
 408    for (unsigned i = 0; i < instr->num_params; i++) {
 409       assert(instr->callee->params[i].type == instr->params[i]->deref.type);
 410       validate_deref_var(instr->params[i], state);
 411    }
 412
 413    validate_deref_var(instr->return_deref, state);
 414 }
 415
 416 static void
 417 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
 418 {
 419    validate_ssa_def(&instr->def, state);
 420 }
 421
 422 static void
 423 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
 424 {
 425    validate_ssa_def(&instr->def, state);
 426 }
 427
 428 static void
 429 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
 430 {
 431    /*
 432     * don't validate the sources until we get to them from their predecessor
 433     * basic blocks, to avoid validating an SSA use before its definition.
 434     */
 435
 436    validate_dest(&instr->dest, state);
 437
 438    exec_list_validate(&instr->srcs);
 439    assert(exec_list_length(&instr->srcs) ==
 440           state->block->predecessors->entries);
 441 }
 442
 443 static void
 444 validate_instr(nir_instr *instr, validate_state *state)
 445 {
 446    assert(instr->block == state->block);
 447
 448    state->instr = instr;
 449
 450    switch (instr->type) {
 451    case nir_instr_type_alu:
 452       validate_alu_instr(nir_instr_as_alu(instr), state);
 453       break;
 454
 455    case nir_instr_type_call:
 456       validate_call_instr(nir_instr_as_call(instr), state);
 457       break;
 458
 459    case nir_instr_type_intrinsic:
 460       validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
 461       break;
 462
 463    case nir_instr_type_tex:
 464       validate_tex_instr(nir_instr_as_tex(instr), state);
 465       break;
 466
 467    case nir_instr_type_load_const:
 468       validate_load_const_instr(nir_instr_as_load_const(instr), state);
 469       break;
 470
 471    case nir_instr_type_phi:
 472       validate_phi_instr(nir_instr_as_phi(instr), state);
 473       break;
 474
 475    case nir_instr_type_ssa_undef:
 476       validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
 477       break;
 478
 479    case nir_instr_type_jump:
 480       break;
 481
 482    default:
 483       assert(!"Invalid ALU instruction type");
 484       break;
 485    }
 486 }
 487
 488 static void
 489 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
 490 {
 491    state->instr = &instr->instr;
 492
 493    assert(instr->dest.is_ssa);
 494
 495    exec_list_validate(&instr->srcs);
 496    foreach_list_typed(nir_phi_src, src, node, &instr->srcs) {
 497       if (src->pred == pred) {
 498          unsigned num_components;
 499          if (src->src.is_ssa)
 500             num_components = src->src.ssa->num_components;
 501          else {
 502             if (src->src.reg.reg->is_packed)
 503                num_components = 4; /* can't check anything */
 504             else
 505                num_components = src->src.reg.reg->num_components;
 506          }
 507          assert(num_components == instr->dest.ssa.num_components);
 508
 509          validate_src(&src->src, state);
 510          return;
 511       }
 512    }
 513
 514    abort();
 515 }
 516
 517 static void
 518 validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
 519 {
 520    nir_foreach_instr(succ, instr) {
 521       if (instr->type != nir_instr_type_phi)
 522          break;
 523
 524       validate_phi_src(nir_instr_as_phi(instr), block, state);
 525    }
 526 }
 527
 528 static void validate_cf_node(nir_cf_node *node, validate_state *state);
 529
 530 static void
 531 validate_block(nir_block *block, validate_state *state)
 532 {
 533    assert(block->cf_node.parent == state->parent_node);
 534
 535    state->block = block;
 536
 537    exec_list_validate(&block->instr_list);
 538    nir_foreach_instr(block, instr) {
 539       if (instr->type == nir_instr_type_phi) {
 540          assert(instr == nir_block_first_instr(block) ||
 541                 nir_instr_prev(instr)->type == nir_instr_type_phi);
 542       }
 543
 544       if (instr->type == nir_instr_type_jump) {
 545          assert(instr == nir_block_last_instr(block));
 546       }
 547
 548       validate_instr(instr, state);
 549    }
 550
 551    assert(block->successors[0] != NULL);
 552
 553    for (unsigned i = 0; i < 2; i++) {
 554       if (block->successors[i] != NULL) {
 555          struct set_entry *entry =
 556             _mesa_set_search(block->successors[i]->predecessors,
 557                              _mesa_hash_pointer(block), block);
 558          assert(entry);
 559
 560          validate_phi_srcs(block, block->successors[i], state);
 561       }
 562    }
 563
 564    if (!exec_list_is_empty(&block->instr_list) &&
 565        nir_block_last_instr(block)->type == nir_instr_type_jump)
 566       assert(block->successors[1] == NULL);
 567 }
 568
 569 static void
 570 validate_if(nir_if *if_stmt, validate_state *state)
 571 {
 572    assert(!exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
 573    nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node);
 574    assert(prev_node->type == nir_cf_node_block);
 575
 576    nir_block *prev_block = nir_cf_node_as_block(prev_node);
 577    assert(&prev_block->successors[0]->cf_node ==
 578           nir_if_first_then_node(if_stmt));
 579    assert(&prev_block->successors[1]->cf_node ==
 580           nir_if_first_else_node(if_stmt));
 581
 582    assert(!exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
 583    nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node);
 584    assert(next_node->type == nir_cf_node_block);
 585
 586    if (!if_stmt->condition.is_ssa) {
 587       nir_register *reg = if_stmt->condition.reg.reg;
 588       struct set_entry *entry =
 589          _mesa_set_search(reg->if_uses, _mesa_hash_pointer(if_stmt), if_stmt);
 590       assert(entry);
 591    } else {
 592       nir_ssa_def *def = if_stmt->condition.ssa;
 593       struct set_entry *entry =
 594          _mesa_set_search(def->if_uses, _mesa_hash_pointer(if_stmt), if_stmt);
 595       assert(entry);
 596    }
 597
 598    assert(!exec_list_is_empty(&if_stmt->then_list));
 599    assert(!exec_list_is_empty(&if_stmt->else_list));
 600
 601    nir_cf_node *old_parent = state->parent_node;
 602    state->parent_node = &if_stmt->cf_node;
 603
 604    exec_list_validate(&if_stmt->then_list);
 605    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) {
 606       validate_cf_node(cf_node, state);
 607    }
 608
 609    exec_list_validate(&if_stmt->else_list);
 610    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) {
 611       validate_cf_node(cf_node, state);
 612    }
 613
 614    state->parent_node = old_parent;
 615 }
 616
 617 static void
 618 validate_loop(nir_loop *loop, validate_state *state)
 619 {
 620    assert(!exec_node_is_head_sentinel(loop->cf_node.node.prev));
 621    nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node);
 622    assert(prev_node->type == nir_cf_node_block);
 623
 624    nir_block *prev_block = nir_cf_node_as_block(prev_node);
 625    assert(&prev_block->successors[0]->cf_node == nir_loop_first_cf_node(loop));
 626    assert(prev_block->successors[1] == NULL);
 627
 628    assert(!exec_node_is_tail_sentinel(loop->cf_node.node.next));
 629    nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node);
 630    assert(next_node->type == nir_cf_node_block);
 631
 632    assert(!exec_list_is_empty(&loop->body));
 633
 634    nir_cf_node *old_parent = state->parent_node;
 635    state->parent_node = &loop->cf_node;
 636
 637    exec_list_validate(&loop->body);
 638    foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) {
 639       validate_cf_node(cf_node, state);
 640    }
 641
 642    state->parent_node = old_parent;
 643 }
 644
 645 static void
 646 validate_cf_node(nir_cf_node *node, validate_state *state)
 647 {
 648    assert(node->parent == state->parent_node);
 649
 650    switch (node->type) {
 651    case nir_cf_node_block:
 652       validate_block(nir_cf_node_as_block(node), state);
 653       break;
 654
 655    case nir_cf_node_if:
 656       validate_if(nir_cf_node_as_if(node), state);
 657       break;
 658
 659    case nir_cf_node_loop:
 660       validate_loop(nir_cf_node_as_loop(node), state);
 661       break;
 662
 663    default:
 664       assert(!"Invalid ALU instruction type");
 665       break;
 666    }
 667 }
 668
 669 static void
 670 prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state)
 671 {
 672    assert(reg->is_global == is_global);
 673
 674    if (is_global)
 675       assert(reg->index < state->shader->reg_alloc);
 676    else
 677       assert(reg->index < state->impl->reg_alloc);
 678    assert(!BITSET_TEST(state->regs_found, reg->index));
 679    BITSET_SET(state->regs_found, reg->index);
 680
 681    reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
 682    reg_state->uses = _mesa_set_create(reg_state, _mesa_key_pointer_equal);
 683    reg_state->defs = _mesa_set_create(reg_state, _mesa_key_pointer_equal);
 684
 685    reg_state->where_defined = is_global ? NULL : state->impl;
 686
 687    _mesa_hash_table_insert(state->regs, reg, reg_state);
 688 }
 689
 690 static void
 691 postvalidate_reg_decl(nir_register *reg, validate_state *state)
 692 {
 693    struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);
 694
 695    reg_validate_state *reg_state = (reg_validate_state *) entry->data;
 696
 697    if (reg_state->uses->entries != reg->uses->entries) {
 698       printf("extra entries in register uses:\n");
 699       struct set_entry *entry;
 700       set_foreach(reg->uses, entry) {
 701          struct set_entry *entry2 =
 702             _mesa_set_search(reg_state->uses, _mesa_hash_pointer(entry->key),
 703                              entry->key);
 704
 705          if (entry2 == NULL) {
 706             printf("%p\n", entry->key);
 707          }
 708       }
 709
 710       abort();
 711    }
 712
 713    if (reg_state->defs->entries != reg->defs->entries) {
 714       printf("extra entries in register defs:\n");
 715       struct set_entry *entry;
 716       set_foreach(reg->defs, entry) {
 717          struct set_entry *entry2 =
 718             _mesa_set_search(reg_state->defs, _mesa_hash_pointer(entry->key),
 719                              entry->key);
 720
 721          if (entry2 == NULL) {
 722             printf("%p\n", entry->key);
 723          }
 724       }
 725
 726       abort();
 727    }
 728 }
 729
 730 static void
 731 validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
 732 {
 733    assert(is_global != (var->data.mode == nir_var_local));
 734
 735    /*
 736     * TODO validate some things ir_validate.cpp does (requires more GLSL type
 737     * support)
 738     */
 739
 740    if (!is_global) {
 741       _mesa_hash_table_insert(state->var_defs, var, state->impl);
 742    }
 743 }
 744
 745 static void
 746 validate_function_impl(nir_function_impl *impl, validate_state *state)
 747 {
 748    assert(impl->overload->impl == impl);
 749    assert(impl->cf_node.parent == NULL);
 750
 751    assert(impl->num_params == impl->overload->num_params);
 752    for (unsigned i = 0; i < impl->num_params; i++)
 753       assert(impl->params[i]->type == impl->overload->params[i].type);
 754
 755    if (glsl_type_is_void(impl->overload->return_type))
 756       assert(impl->return_var == NULL);
 757    else
 758       assert(impl->return_var->type == impl->overload->return_type);
 759
 760    assert(exec_list_is_empty(&impl->end_block->instr_list));
 761    assert(impl->end_block->successors[0] == NULL);
 762    assert(impl->end_block->successors[1] == NULL);
 763
 764    state->impl = impl;
 765    state->parent_node = &impl->cf_node;
 766
 767    exec_list_validate(&impl->locals);
 768    foreach_list_typed(nir_variable, var, node, &impl->locals) {
 769       validate_var_decl(var, false, state);
 770    }
 771
 772    state->regs_found = realloc(state->regs_found,
 773                                BITSET_WORDS(impl->reg_alloc) *
 774                                sizeof(BITSET_WORD));
 775    memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) *
 776                                 sizeof(BITSET_WORD));
 777    exec_list_validate(&impl->registers);
 778    foreach_list_typed(nir_register, reg, node, &impl->registers) {
 779       prevalidate_reg_decl(reg, false, state);
 780    }
 781
 782    state->ssa_defs_found = realloc(state->ssa_defs_found,
 783                                    BITSET_WORDS(impl->ssa_alloc) *
 784                                    sizeof(BITSET_WORD));
 785    memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) *
 786                                     sizeof(BITSET_WORD));
 787    exec_list_validate(&impl->body);
 788    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
 789       validate_cf_node(node, state);
 790    }
 791
 792    foreach_list_typed(nir_register, reg, node, &impl->registers) {
 793       postvalidate_reg_decl(reg, state);
 794    }
 795 }
 796
 797 static void
 798 validate_function_overload(nir_function_overload *overload,
 799                            validate_state *state)
 800 {
 801    if (overload->impl != NULL)
 802       validate_function_impl(overload->impl, state);
 803 }
 804
 805 static void
 806 validate_function(nir_function *func, validate_state *state)
 807 {
 808    exec_list_validate(&func->overload_list);
 809    foreach_list_typed(nir_function_overload, overload, node, &func->overload_list) {
 810       assert(overload->function == func);
 811       validate_function_overload(overload, state);
 812    }
 813 }
 814
 815 static void
 816 init_validate_state(validate_state *state)
 817 {
 818    state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 819                                          _mesa_key_pointer_equal);
 820    state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 821                                              _mesa_key_pointer_equal);
 822    state->ssa_defs_found = NULL;
 823    state->regs_found = NULL;
 824    state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
 825                                              _mesa_key_pointer_equal);
 826 }
 827
 828 static void
 829 destroy_validate_state(validate_state *state)
 830 {
 831    _mesa_hash_table_destroy(state->regs, NULL);
 832    _mesa_hash_table_destroy(state->ssa_defs, NULL);
 833    free(state->ssa_defs_found);
 834    free(state->regs_found);
 835    _mesa_hash_table_destroy(state->var_defs, NULL);
 836 }
 837
 838 void
 839 nir_validate_shader(nir_shader *shader)
 840 {
 841    validate_state state;
 842    init_validate_state(&state);
 843
 844    state.shader = shader;
 845
 846    struct hash_entry *entry;
 847    hash_table_foreach(shader->uniforms, entry) {
 848       validate_var_decl((nir_variable *) entry->data, true, &state);
 849    }
 850
 851    hash_table_foreach(shader->inputs, entry) {
 852      validate_var_decl((nir_variable *) entry->data, true, &state);
 853    }
 854
 855    hash_table_foreach(shader->outputs, entry) {
 856       validate_var_decl((nir_variable *) entry->data, true, &state);
 857    }
 858
 859    exec_list_validate(&shader->globals);
 860    foreach_list_typed(nir_variable, var, node, &shader->globals) {
 861      validate_var_decl(var, true, &state);
 862    }
 863
 864    exec_list_validate(&shader->system_values);
 865    foreach_list_typed(nir_variable, var, node, &shader->system_values) {
 866      validate_var_decl(var, true, &state);
 867    }
 868
 869    state.regs_found = realloc(state.regs_found,
 870                               BITSET_WORDS(shader->reg_alloc) *
 871                               sizeof(BITSET_WORD));
 872    memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) *
 873                                sizeof(BITSET_WORD));
 874    exec_list_validate(&shader->registers);
 875    foreach_list_typed(nir_register, reg, node, &shader->registers) {
 876       prevalidate_reg_decl(reg, true, &state);
 877    }
 878
 879    exec_list_validate(&shader->functions);
 880    foreach_list_typed(nir_function, func, node, &shader->functions) {
 881       validate_function(func, &state);
 882    }
 883
 884    foreach_list_typed(nir_register, reg, node, &shader->registers) {
 885       postvalidate_reg_decl(reg, &state);
 886    }
 887
 888    destroy_validate_state(&state);
 889 }
 890
 891 #endif /* NDEBUG */