src/compiler/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 variable being validated */
  73    nir_variable *var;
  74
  75    /* the current basic block being validated */
  76    nir_block *block;
  77
  78    /* the current if statement being validated */
  79    nir_if *if_stmt;
  80
  81    /* the current loop being visited */
  82    nir_loop *loop;
  83
  84    /* the parent of the current cf node being visited */
  85    nir_cf_node *parent_node;
  86
  87    /* the current function implementation being validated */
  88    nir_function_impl *impl;
  89
  90    /* map of SSA value -> function implementation where it is defined */
  91    struct hash_table *ssa_defs;
  92
  93    /* bitset of ssa definitions we have found; used to check uniqueness */
  94    BITSET_WORD *ssa_defs_found;
  95
  96    /* bitset of registers we have currently found; used to check uniqueness */
  97    BITSET_WORD *regs_found;
  98
  99    /* map of local variable -> function implementation where it is defined */
 100    struct hash_table *var_defs;
 101
 102    /* map of instruction/var/etc to failed assert string */
 103    struct hash_table *errors;
 104 } validate_state;
 105
 106 static void
 107 log_error(validate_state *state, const char *cond, const char *file, int line)
 108 {
 109    const void *obj;
 110
 111    if (state->instr)
 112       obj = state->instr;
 113    else if (state->var)
 114       obj = state->var;
 115    else
 116       obj = cond;
 117
 118    char *msg = ralloc_asprintf(state->errors, "error: %s (%s:%d)",
 119                                cond, file, line);
 120
 121    _mesa_hash_table_insert(state->errors, obj, msg);
 122 }
 123
 124 #define validate_assert(state, cond) do {             \
 125       if (!(cond))                                    \
 126          log_error(state, #cond, __FILE__, __LINE__); \
 127    } while (0)
 128
 129 static void validate_src(nir_src *src, validate_state *state,
 130                          unsigned bit_size, unsigned num_components);
 131
 132 static void
 133 validate_reg_src(nir_src *src, validate_state *state,
 134                  unsigned bit_size, unsigned num_components)
 135 {
 136    validate_assert(state, src->reg.reg != NULL);
 137
 138    struct hash_entry *entry;
 139    entry = _mesa_hash_table_search(state->regs, src->reg.reg);
 140    validate_assert(state, entry);
 141
 142    reg_validate_state *reg_state = (reg_validate_state *) entry->data;
 143
 144    if (state->instr) {
 145       _mesa_set_add(reg_state->uses, src);
 146    } else {
 147       validate_assert(state, state->if_stmt);
 148       _mesa_set_add(reg_state->if_uses, src);
 149    }
 150
 151    if (!src->reg.reg->is_global) {
 152       validate_assert(state, reg_state->where_defined == state->impl &&
 153              "using a register declared in a different function");
 154    }
 155
 156    if (!src->reg.reg->is_packed) {
 157       if (bit_size)
 158          validate_assert(state, src->reg.reg->bit_size == bit_size);
 159       if (num_components)
 160          validate_assert(state, src->reg.reg->num_components == num_components);
 161    }
 162
 163    validate_assert(state, (src->reg.reg->num_array_elems == 0 ||
 164           src->reg.base_offset < src->reg.reg->num_array_elems) &&
 165           "definitely out-of-bounds array access");
 166
 167    if (src->reg.indirect) {
 168       validate_assert(state, src->reg.reg->num_array_elems != 0);
 169       validate_assert(state, (src->reg.indirect->is_ssa ||
 170               src->reg.indirect->reg.indirect == NULL) &&
 171              "only one level of indirection allowed");
 172       validate_src(src->reg.indirect, state, 32, 1);
 173    }
 174 }
 175
 176 static void
 177 validate_ssa_src(nir_src *src, validate_state *state,
 178                  unsigned bit_size, unsigned num_components)
 179 {
 180    validate_assert(state, src->ssa != NULL);
 181
 182    struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, src->ssa);
 183
 184    validate_assert(state, entry);
 185
 186    if (!entry)
 187       return;
 188
 189    ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data;
 190
 191    validate_assert(state, def_state->where_defined == state->impl &&
 192           "using an SSA value defined in a different function");
 193
 194    if (state->instr) {
 195       _mesa_set_add(def_state->uses, src);
 196    } else {
 197       validate_assert(state, state->if_stmt);
 198       _mesa_set_add(def_state->if_uses, src);
 199    }
 200
 201    if (bit_size)
 202       validate_assert(state, src->ssa->bit_size == bit_size);
 203    if (num_components)
 204       validate_assert(state, src->ssa->num_components == num_components);
 205
 206    /* TODO validate that the use is dominated by the definition */
 207 }
 208
 209 static void
 210 validate_src(nir_src *src, validate_state *state,
 211              unsigned bit_size, unsigned num_components)
 212 {
 213    if (state->instr)
 214       validate_assert(state, src->parent_instr == state->instr);
 215    else
 216       validate_assert(state, src->parent_if == state->if_stmt);
 217
 218    if (src->is_ssa)
 219       validate_ssa_src(src, state, bit_size, num_components);
 220    else
 221       validate_reg_src(src, state, bit_size, num_components);
 222 }
 223
 224 static void
 225 validate_alu_src(nir_alu_instr *instr, unsigned index, validate_state *state)
 226 {
 227    nir_alu_src *src = &instr->src[index];
 228
 229    unsigned num_components;
 230    unsigned src_bit_size;
 231    if (src->src.is_ssa) {
 232       src_bit_size = src->src.ssa->bit_size;
 233       num_components = src->src.ssa->num_components;
 234    } else {
 235       src_bit_size = src->src.reg.reg->bit_size;
 236       if (src->src.reg.reg->is_packed)
 237          num_components = 4; /* can't check anything */
 238       else
 239          num_components = src->src.reg.reg->num_components;
 240    }
 241    for (unsigned i = 0; i < 4; i++) {
 242       validate_assert(state, src->swizzle[i] < 4);
 243
 244       if (nir_alu_instr_channel_used(instr, index, i))
 245          validate_assert(state, src->swizzle[i] < num_components);
 246    }
 247
 248    nir_alu_type src_type = nir_op_infos[instr->op].input_types[index];
 249
 250    /* 8-bit float isn't a thing */
 251    if (nir_alu_type_get_base_type(src_type) == nir_type_float)
 252       validate_assert(state, src_bit_size == 16 || src_bit_size == 32 || src_bit_size == 64);
 253
 254    if (nir_alu_type_get_type_size(src_type)) {
 255       /* This source has an explicit bit size */
 256       validate_assert(state, nir_alu_type_get_type_size(src_type) == src_bit_size);
 257    } else {
 258       if (!nir_alu_type_get_type_size(nir_op_infos[instr->op].output_type)) {
 259          unsigned dest_bit_size =
 260             instr->dest.dest.is_ssa ? instr->dest.dest.ssa.bit_size
 261                                     : instr->dest.dest.reg.reg->bit_size;
 262          validate_assert(state, dest_bit_size == src_bit_size);
 263       }
 264    }
 265
 266    validate_src(&src->src, state, 0, 0);
 267 }
 268
 269 static void
 270 validate_reg_dest(nir_reg_dest *dest, validate_state *state,
 271                   unsigned bit_size, unsigned num_components)
 272 {
 273    validate_assert(state, dest->reg != NULL);
 274
 275    validate_assert(state, dest->parent_instr == state->instr);
 276
 277    struct hash_entry *entry2;
 278    entry2 = _mesa_hash_table_search(state->regs, dest->reg);
 279
 280    validate_assert(state, entry2);
 281
 282    reg_validate_state *reg_state = (reg_validate_state *) entry2->data;
 283    _mesa_set_add(reg_state->defs, dest);
 284
 285    if (!dest->reg->is_global) {
 286       validate_assert(state, reg_state->where_defined == state->impl &&
 287              "writing to a register declared in a different function");
 288    }
 289
 290    if (!dest->reg->is_packed) {
 291       if (bit_size)
 292          validate_assert(state, dest->reg->bit_size == bit_size);
 293       if (num_components)
 294          validate_assert(state, dest->reg->num_components == num_components);
 295    }
 296
 297    validate_assert(state, (dest->reg->num_array_elems == 0 ||
 298           dest->base_offset < dest->reg->num_array_elems) &&
 299           "definitely out-of-bounds array access");
 300
 301    if (dest->indirect) {
 302       validate_assert(state, dest->reg->num_array_elems != 0);
 303       validate_assert(state, (dest->indirect->is_ssa || dest->indirect->reg.indirect == NULL) &&
 304              "only one level of indirection allowed");
 305       validate_src(dest->indirect, state, 32, 1);
 306    }
 307 }
 308
 309 static void
 310 validate_ssa_def(nir_ssa_def *def, validate_state *state)
 311 {
 312    validate_assert(state, def->index < state->impl->ssa_alloc);
 313    validate_assert(state, !BITSET_TEST(state->ssa_defs_found, def->index));
 314    BITSET_SET(state->ssa_defs_found, def->index);
 315
 316    validate_assert(state, def->parent_instr == state->instr);
 317
 318    validate_assert(state, def->num_components <= 4);
 319
 320    list_validate(&def->uses);
 321    list_validate(&def->if_uses);
 322
 323    ssa_def_validate_state *def_state = ralloc(state->ssa_defs,
 324                                               ssa_def_validate_state);
 325    def_state->where_defined = state->impl;
 326    def_state->uses = _mesa_set_create(def_state, _mesa_hash_pointer,
 327                                       _mesa_key_pointer_equal);
 328    def_state->if_uses = _mesa_set_create(def_state, _mesa_hash_pointer,
 329                                          _mesa_key_pointer_equal);
 330    _mesa_hash_table_insert(state->ssa_defs, def, def_state);
 331 }
 332
 333 static void
 334 validate_dest(nir_dest *dest, validate_state *state,
 335               unsigned bit_size, unsigned num_components)
 336 {
 337    if (dest->is_ssa) {
 338       if (bit_size)
 339          validate_assert(state, dest->ssa.bit_size == bit_size);
 340       if (num_components)
 341          validate_assert(state, dest->ssa.num_components == num_components);
 342       validate_ssa_def(&dest->ssa, state);
 343    } else {
 344       validate_reg_dest(&dest->reg, state, bit_size, num_components);
 345    }
 346 }
 347
 348 static void
 349 validate_alu_dest(nir_alu_instr *instr, validate_state *state)
 350 {
 351    nir_alu_dest *dest = &instr->dest;
 352
 353    unsigned dest_size =
 354       dest->dest.is_ssa ? dest->dest.ssa.num_components
 355                         : dest->dest.reg.reg->num_components;
 356    bool is_packed = !dest->dest.is_ssa && dest->dest.reg.reg->is_packed;
 357    /*
 358     * validate that the instruction doesn't write to components not in the
 359     * register/SSA value
 360     */
 361    validate_assert(state, is_packed || !(dest->write_mask & ~((1 << dest_size) - 1)));
 362
 363    /* validate that saturate is only ever used on instructions with
 364     * destinations of type float
 365     */
 366    nir_alu_instr *alu = nir_instr_as_alu(state->instr);
 367    validate_assert(state,
 368           (nir_alu_type_get_base_type(nir_op_infos[alu->op].output_type) ==
 369            nir_type_float) ||
 370           !dest->saturate);
 371
 372    unsigned bit_size = dest->dest.is_ssa ? dest->dest.ssa.bit_size
 373                                          : dest->dest.reg.reg->bit_size;
 374    nir_alu_type type = nir_op_infos[instr->op].output_type;
 375
 376    /* 8-bit float isn't a thing */
 377    if (nir_alu_type_get_base_type(type) == nir_type_float)
 378       validate_assert(state, bit_size == 16 || bit_size == 32 || bit_size == 64);
 379
 380    validate_assert(state, nir_alu_type_get_type_size(type) == 0 ||
 381           nir_alu_type_get_type_size(type) == bit_size);
 382
 383    validate_dest(&dest->dest, state, 0, 0);
 384 }
 385
 386 static void
 387 validate_alu_instr(nir_alu_instr *instr, validate_state *state)
 388 {
 389    validate_assert(state, instr->op < nir_num_opcodes);
 390
 391    for (unsigned i = 0; i < nir_op_infos[instr->op].num_inputs; i++) {
 392       validate_alu_src(instr, i, state);
 393    }
 394
 395    validate_alu_dest(instr, state);
 396 }
 397
 398 static void
 399 validate_deref_chain(nir_deref *deref, validate_state *state)
 400 {
 401    validate_assert(state, deref->child == NULL || ralloc_parent(deref->child) == deref);
 402
 403    nir_deref *parent = NULL;
 404    while (deref != NULL) {
 405       switch (deref->deref_type) {
 406       case nir_deref_type_array:
 407          validate_assert(state, deref->type == glsl_get_array_element(parent->type));
 408          if (nir_deref_as_array(deref)->deref_array_type ==
 409              nir_deref_array_type_indirect)
 410             validate_src(&nir_deref_as_array(deref)->indirect, state, 32, 1);
 411          break;
 412
 413       case nir_deref_type_struct:
 414          assume(parent); /* cannot happen: deref change starts w/ nir_deref_var */
 415          validate_assert(state, deref->type ==
 416                 glsl_get_struct_field(parent->type,
 417                                       nir_deref_as_struct(deref)->index));
 418          break;
 419
 420       case nir_deref_type_var:
 421          break;
 422
 423       default:
 424          validate_assert(state, !"Invalid deref type");
 425          break;
 426       }
 427
 428       parent = deref;
 429       deref = deref->child;
 430    }
 431 }
 432
 433 static void
 434 validate_var_use(nir_variable *var, validate_state *state)
 435 {
 436    if (var->data.mode == nir_var_local) {
 437       struct hash_entry *entry = _mesa_hash_table_search(state->var_defs, var);
 438
 439       validate_assert(state, entry);
 440       validate_assert(state, (nir_function_impl *) entry->data == state->impl);
 441    }
 442 }
 443
 444 static void
 445 validate_deref_var(void *parent_mem_ctx, nir_deref_var *deref, validate_state *state)
 446 {
 447    validate_assert(state, deref != NULL);
 448    validate_assert(state, ralloc_parent(deref) == parent_mem_ctx);
 449    validate_assert(state, deref->deref.type == deref->var->type);
 450
 451    validate_var_use(deref->var, state);
 452
 453    validate_deref_chain(&deref->deref, state);
 454 }
 455
 456 static void
 457 validate_intrinsic_instr(nir_intrinsic_instr *instr, validate_state *state)
 458 {
 459    unsigned bit_size = 0;
 460    if (instr->intrinsic == nir_intrinsic_load_var ||
 461        instr->intrinsic == nir_intrinsic_store_var) {
 462       const struct glsl_type *type =
 463          nir_deref_tail(&instr->variables[0]->deref)->type;
 464       bit_size = glsl_get_bit_size(type);
 465    }
 466
 467    unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
 468    for (unsigned i = 0; i < num_srcs; i++) {
 469       unsigned components_read =
 470          nir_intrinsic_infos[instr->intrinsic].src_components[i];
 471       if (components_read == 0)
 472          components_read = instr->num_components;
 473
 474       validate_assert(state, components_read > 0);
 475
 476       validate_src(&instr->src[i], state, bit_size, components_read);
 477    }
 478
 479    unsigned num_vars = nir_intrinsic_infos[instr->intrinsic].num_variables;
 480    for (unsigned i = 0; i < num_vars; i++) {
 481       validate_deref_var(instr, instr->variables[i], state);
 482    }
 483
 484    if (nir_intrinsic_infos[instr->intrinsic].has_dest) {
 485       unsigned components_written =
 486          nir_intrinsic_infos[instr->intrinsic].dest_components;
 487       if (components_written == 0)
 488          components_written = instr->num_components;
 489
 490       validate_assert(state, components_written > 0);
 491
 492       validate_dest(&instr->dest, state, bit_size, components_written);
 493    }
 494
 495    switch (instr->intrinsic) {
 496    case nir_intrinsic_load_var: {
 497       const struct glsl_type *type =
 498          nir_deref_tail(&instr->variables[0]->deref)->type;
 499       validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
 500              (instr->variables[0]->var->data.mode == nir_var_uniform &&
 501               glsl_get_base_type(type) == GLSL_TYPE_SUBROUTINE));
 502       validate_assert(state, instr->num_components == glsl_get_vector_elements(type));
 503       break;
 504    }
 505    case nir_intrinsic_store_var: {
 506       const struct glsl_type *type =
 507          nir_deref_tail(&instr->variables[0]->deref)->type;
 508       validate_assert(state, glsl_type_is_vector_or_scalar(type) ||
 509              (instr->variables[0]->var->data.mode == nir_var_uniform &&
 510               glsl_get_base_type(type) == GLSL_TYPE_SUBROUTINE));
 511       validate_assert(state, instr->num_components == glsl_get_vector_elements(type));
 512       validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
 513              instr->variables[0]->var->data.mode != nir_var_uniform &&
 514              instr->variables[0]->var->data.mode != nir_var_shader_storage);
 515       validate_assert(state, (nir_intrinsic_write_mask(instr) & ~((1 << instr->num_components) - 1)) == 0);
 516       break;
 517    }
 518    case nir_intrinsic_copy_var:
 519       validate_assert(state, nir_deref_tail(&instr->variables[0]->deref)->type ==
 520              nir_deref_tail(&instr->variables[1]->deref)->type);
 521       validate_assert(state, instr->variables[0]->var->data.mode != nir_var_shader_in &&
 522              instr->variables[0]->var->data.mode != nir_var_uniform &&
 523              instr->variables[0]->var->data.mode != nir_var_shader_storage);
 524       break;
 525    default:
 526       break;
 527    }
 528 }
 529
 530 static void
 531 validate_tex_instr(nir_tex_instr *instr, validate_state *state)
 532 {
 533    bool src_type_seen[nir_num_tex_src_types];
 534    for (unsigned i = 0; i < nir_num_tex_src_types; i++)
 535       src_type_seen[i] = false;
 536
 537    for (unsigned i = 0; i < instr->num_srcs; i++) {
 538       validate_assert(state, !src_type_seen[instr->src[i].src_type]);
 539       src_type_seen[instr->src[i].src_type] = true;
 540       validate_src(&instr->src[i].src, state,
 541                    0, nir_tex_instr_src_size(instr, i));
 542    }
 543
 544    if (instr->texture != NULL)
 545       validate_deref_var(instr, instr->texture, state);
 546
 547    if (instr->sampler != NULL)
 548       validate_deref_var(instr, instr->sampler, state);
 549
 550    validate_dest(&instr->dest, state, 0, nir_tex_instr_dest_size(instr));
 551 }
 552
 553 static void
 554 validate_call_instr(nir_call_instr *instr, validate_state *state)
 555 {
 556    if (instr->return_deref == NULL) {
 557       validate_assert(state, glsl_type_is_void(instr->callee->return_type));
 558    } else {
 559       validate_assert(state, instr->return_deref->deref.type == instr->callee->return_type);
 560       validate_deref_var(instr, instr->return_deref, state);
 561    }
 562
 563    validate_assert(state, instr->num_params == instr->callee->num_params);
 564
 565    for (unsigned i = 0; i < instr->num_params; i++) {
 566       validate_assert(state, instr->callee->params[i].type == instr->params[i]->deref.type);
 567       validate_deref_var(instr, instr->params[i], state);
 568    }
 569 }
 570
 571 static void
 572 validate_load_const_instr(nir_load_const_instr *instr, validate_state *state)
 573 {
 574    validate_ssa_def(&instr->def, state);
 575 }
 576
 577 static void
 578 validate_ssa_undef_instr(nir_ssa_undef_instr *instr, validate_state *state)
 579 {
 580    validate_ssa_def(&instr->def, state);
 581 }
 582
 583 static void
 584 validate_phi_instr(nir_phi_instr *instr, validate_state *state)
 585 {
 586    /*
 587     * don't validate the sources until we get to them from their predecessor
 588     * basic blocks, to avoid validating an SSA use before its definition.
 589     */
 590
 591    validate_dest(&instr->dest, state, 0, 0);
 592
 593    exec_list_validate(&instr->srcs);
 594    validate_assert(state, exec_list_length(&instr->srcs) ==
 595           state->block->predecessors->entries);
 596 }
 597
 598 static void
 599 validate_instr(nir_instr *instr, validate_state *state)
 600 {
 601    validate_assert(state, instr->block == state->block);
 602
 603    state->instr = instr;
 604
 605    switch (instr->type) {
 606    case nir_instr_type_alu:
 607       validate_alu_instr(nir_instr_as_alu(instr), state);
 608       break;
 609
 610    case nir_instr_type_call:
 611       validate_call_instr(nir_instr_as_call(instr), state);
 612       break;
 613
 614    case nir_instr_type_intrinsic:
 615       validate_intrinsic_instr(nir_instr_as_intrinsic(instr), state);
 616       break;
 617
 618    case nir_instr_type_tex:
 619       validate_tex_instr(nir_instr_as_tex(instr), state);
 620       break;
 621
 622    case nir_instr_type_load_const:
 623       validate_load_const_instr(nir_instr_as_load_const(instr), state);
 624       break;
 625
 626    case nir_instr_type_phi:
 627       validate_phi_instr(nir_instr_as_phi(instr), state);
 628       break;
 629
 630    case nir_instr_type_ssa_undef:
 631       validate_ssa_undef_instr(nir_instr_as_ssa_undef(instr), state);
 632       break;
 633
 634    case nir_instr_type_jump:
 635       break;
 636
 637    default:
 638       validate_assert(state, !"Invalid ALU instruction type");
 639       break;
 640    }
 641
 642    state->instr = NULL;
 643 }
 644
 645 static void
 646 validate_phi_src(nir_phi_instr *instr, nir_block *pred, validate_state *state)
 647 {
 648    state->instr = &instr->instr;
 649
 650    validate_assert(state, instr->dest.is_ssa);
 651
 652    exec_list_validate(&instr->srcs);
 653    nir_foreach_phi_src(src, instr) {
 654       if (src->pred == pred) {
 655          validate_assert(state, src->src.is_ssa);
 656          validate_src(&src->src, state, instr->dest.ssa.bit_size,
 657                       instr->dest.ssa.num_components);
 658          state->instr = NULL;
 659          return;
 660       }
 661    }
 662
 663    abort();
 664 }
 665
 666 static void
 667 validate_phi_srcs(nir_block *block, nir_block *succ, validate_state *state)
 668 {
 669    nir_foreach_instr(instr, succ) {
 670       if (instr->type != nir_instr_type_phi)
 671          break;
 672
 673       validate_phi_src(nir_instr_as_phi(instr), block, state);
 674    }
 675 }
 676
 677 static void validate_cf_node(nir_cf_node *node, validate_state *state);
 678
 679 static void
 680 validate_block(nir_block *block, validate_state *state)
 681 {
 682    validate_assert(state, block->cf_node.parent == state->parent_node);
 683
 684    state->block = block;
 685
 686    exec_list_validate(&block->instr_list);
 687    nir_foreach_instr(instr, block) {
 688       if (instr->type == nir_instr_type_phi) {
 689          validate_assert(state, instr == nir_block_first_instr(block) ||
 690                 nir_instr_prev(instr)->type == nir_instr_type_phi);
 691       }
 692
 693       if (instr->type == nir_instr_type_jump) {
 694          validate_assert(state, instr == nir_block_last_instr(block));
 695       }
 696
 697       validate_instr(instr, state);
 698    }
 699
 700    validate_assert(state, block->successors[0] != NULL);
 701    validate_assert(state, block->successors[0] != block->successors[1]);
 702
 703    for (unsigned i = 0; i < 2; i++) {
 704       if (block->successors[i] != NULL) {
 705          struct set_entry *entry =
 706             _mesa_set_search(block->successors[i]->predecessors, block);
 707          validate_assert(state, entry);
 708
 709          validate_phi_srcs(block, block->successors[i], state);
 710       }
 711    }
 712
 713    struct set_entry *entry;
 714    set_foreach(block->predecessors, entry) {
 715       const nir_block *pred = entry->key;
 716       validate_assert(state, pred->successors[0] == block ||
 717              pred->successors[1] == block);
 718    }
 719
 720    if (!exec_list_is_empty(&block->instr_list) &&
 721        nir_block_last_instr(block)->type == nir_instr_type_jump) {
 722       validate_assert(state, block->successors[1] == NULL);
 723       nir_jump_instr *jump = nir_instr_as_jump(nir_block_last_instr(block));
 724       switch (jump->type) {
 725       case nir_jump_break: {
 726          nir_block *after =
 727             nir_cf_node_as_block(nir_cf_node_next(&state->loop->cf_node));
 728          validate_assert(state, block->successors[0] == after);
 729          break;
 730       }
 731
 732       case nir_jump_continue: {
 733          nir_block *first = nir_loop_first_block(state->loop);
 734          validate_assert(state, block->successors[0] == first);
 735          break;
 736       }
 737
 738       case nir_jump_return:
 739          validate_assert(state, block->successors[0] == state->impl->end_block);
 740          break;
 741
 742       default:
 743          unreachable("bad jump type");
 744       }
 745    } else {
 746       nir_cf_node *next = nir_cf_node_next(&block->cf_node);
 747       if (next == NULL) {
 748          switch (state->parent_node->type) {
 749          case nir_cf_node_loop: {
 750             nir_block *first = nir_loop_first_block(state->loop);
 751             validate_assert(state, block->successors[0] == first);
 752             /* due to the hack for infinite loops, block->successors[1] may
 753              * point to the block after the loop.
 754              */
 755             break;
 756          }
 757
 758          case nir_cf_node_if: {
 759             nir_block *after =
 760                nir_cf_node_as_block(nir_cf_node_next(state->parent_node));
 761             validate_assert(state, block->successors[0] == after);
 762             validate_assert(state, block->successors[1] == NULL);
 763             break;
 764          }
 765
 766          case nir_cf_node_function:
 767             validate_assert(state, block->successors[0] == state->impl->end_block);
 768             validate_assert(state, block->successors[1] == NULL);
 769             break;
 770
 771          default:
 772             unreachable("unknown control flow node type");
 773          }
 774       } else {
 775          if (next->type == nir_cf_node_if) {
 776             nir_if *if_stmt = nir_cf_node_as_if(next);
 777             validate_assert(state, block->successors[0] ==
 778                    nir_if_first_then_block(if_stmt));
 779             validate_assert(state, block->successors[1] ==
 780                    nir_if_first_else_block(if_stmt));
 781          } else {
 782             validate_assert(state, next->type == nir_cf_node_loop);
 783             nir_loop *loop = nir_cf_node_as_loop(next);
 784             validate_assert(state, block->successors[0] ==
 785                    nir_loop_first_block(loop));
 786             validate_assert(state, block->successors[1] == NULL);
 787          }
 788       }
 789    }
 790 }
 791
 792 static void
 793 validate_if(nir_if *if_stmt, validate_state *state)
 794 {
 795    state->if_stmt = if_stmt;
 796
 797    validate_assert(state, !exec_node_is_head_sentinel(if_stmt->cf_node.node.prev));
 798    nir_cf_node *prev_node = nir_cf_node_prev(&if_stmt->cf_node);
 799    validate_assert(state, prev_node->type == nir_cf_node_block);
 800
 801    validate_assert(state, !exec_node_is_tail_sentinel(if_stmt->cf_node.node.next));
 802    nir_cf_node *next_node = nir_cf_node_next(&if_stmt->cf_node);
 803    validate_assert(state, next_node->type == nir_cf_node_block);
 804
 805    validate_src(&if_stmt->condition, state, 32, 1);
 806
 807    validate_assert(state, !exec_list_is_empty(&if_stmt->then_list));
 808    validate_assert(state, !exec_list_is_empty(&if_stmt->else_list));
 809
 810    nir_cf_node *old_parent = state->parent_node;
 811    state->parent_node = &if_stmt->cf_node;
 812
 813    exec_list_validate(&if_stmt->then_list);
 814    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->then_list) {
 815       validate_cf_node(cf_node, state);
 816    }
 817
 818    exec_list_validate(&if_stmt->else_list);
 819    foreach_list_typed(nir_cf_node, cf_node, node, &if_stmt->else_list) {
 820       validate_cf_node(cf_node, state);
 821    }
 822
 823    state->parent_node = old_parent;
 824    state->if_stmt = NULL;
 825 }
 826
 827 static void
 828 validate_loop(nir_loop *loop, validate_state *state)
 829 {
 830    validate_assert(state, !exec_node_is_head_sentinel(loop->cf_node.node.prev));
 831    nir_cf_node *prev_node = nir_cf_node_prev(&loop->cf_node);
 832    validate_assert(state, prev_node->type == nir_cf_node_block);
 833
 834    validate_assert(state, !exec_node_is_tail_sentinel(loop->cf_node.node.next));
 835    nir_cf_node *next_node = nir_cf_node_next(&loop->cf_node);
 836    validate_assert(state, next_node->type == nir_cf_node_block);
 837
 838    validate_assert(state, !exec_list_is_empty(&loop->body));
 839
 840    nir_cf_node *old_parent = state->parent_node;
 841    state->parent_node = &loop->cf_node;
 842    nir_loop *old_loop = state->loop;
 843    state->loop = loop;
 844
 845    exec_list_validate(&loop->body);
 846    foreach_list_typed(nir_cf_node, cf_node, node, &loop->body) {
 847       validate_cf_node(cf_node, state);
 848    }
 849
 850    state->parent_node = old_parent;
 851    state->loop = old_loop;
 852 }
 853
 854 static void
 855 validate_cf_node(nir_cf_node *node, validate_state *state)
 856 {
 857    validate_assert(state, node->parent == state->parent_node);
 858
 859    switch (node->type) {
 860    case nir_cf_node_block:
 861       validate_block(nir_cf_node_as_block(node), state);
 862       break;
 863
 864    case nir_cf_node_if:
 865       validate_if(nir_cf_node_as_if(node), state);
 866       break;
 867
 868    case nir_cf_node_loop:
 869       validate_loop(nir_cf_node_as_loop(node), state);
 870       break;
 871
 872    default:
 873       unreachable("Invalid CF node type");
 874    }
 875 }
 876
 877 static void
 878 prevalidate_reg_decl(nir_register *reg, bool is_global, validate_state *state)
 879 {
 880    validate_assert(state, reg->is_global == is_global);
 881
 882    if (is_global)
 883       validate_assert(state, reg->index < state->shader->reg_alloc);
 884    else
 885       validate_assert(state, reg->index < state->impl->reg_alloc);
 886    validate_assert(state, !BITSET_TEST(state->regs_found, reg->index));
 887    BITSET_SET(state->regs_found, reg->index);
 888
 889    list_validate(&reg->uses);
 890    list_validate(&reg->defs);
 891    list_validate(&reg->if_uses);
 892
 893    reg_validate_state *reg_state = ralloc(state->regs, reg_validate_state);
 894    reg_state->uses = _mesa_set_create(reg_state, _mesa_hash_pointer,
 895                                       _mesa_key_pointer_equal);
 896    reg_state->if_uses = _mesa_set_create(reg_state, _mesa_hash_pointer,
 897                                          _mesa_key_pointer_equal);
 898    reg_state->defs = _mesa_set_create(reg_state, _mesa_hash_pointer,
 899                                       _mesa_key_pointer_equal);
 900
 901    reg_state->where_defined = is_global ? NULL : state->impl;
 902
 903    _mesa_hash_table_insert(state->regs, reg, reg_state);
 904 }
 905
 906 static void
 907 postvalidate_reg_decl(nir_register *reg, validate_state *state)
 908 {
 909    struct hash_entry *entry = _mesa_hash_table_search(state->regs, reg);
 910
 911    assume(entry);
 912    reg_validate_state *reg_state = (reg_validate_state *) entry->data;
 913
 914    nir_foreach_use(src, reg) {
 915       struct set_entry *entry = _mesa_set_search(reg_state->uses, src);
 916       validate_assert(state, entry);
 917       _mesa_set_remove(reg_state->uses, entry);
 918    }
 919
 920    if (reg_state->uses->entries != 0) {
 921       printf("extra entries in register uses:\n");
 922       struct set_entry *entry;
 923       set_foreach(reg_state->uses, entry)
 924          printf("%p\n", entry->key);
 925
 926       abort();
 927    }
 928
 929    nir_foreach_if_use(src, reg) {
 930       struct set_entry *entry = _mesa_set_search(reg_state->if_uses, src);
 931       validate_assert(state, entry);
 932       _mesa_set_remove(reg_state->if_uses, entry);
 933    }
 934
 935    if (reg_state->if_uses->entries != 0) {
 936       printf("extra entries in register if_uses:\n");
 937       struct set_entry *entry;
 938       set_foreach(reg_state->if_uses, entry)
 939          printf("%p\n", entry->key);
 940
 941       abort();
 942    }
 943
 944    nir_foreach_def(src, reg) {
 945       struct set_entry *entry = _mesa_set_search(reg_state->defs, src);
 946       validate_assert(state, entry);
 947       _mesa_set_remove(reg_state->defs, entry);
 948    }
 949
 950    if (reg_state->defs->entries != 0) {
 951       printf("extra entries in register defs:\n");
 952       struct set_entry *entry;
 953       set_foreach(reg_state->defs, entry)
 954          printf("%p\n", entry->key);
 955
 956       abort();
 957    }
 958 }
 959
 960 static void
 961 validate_var_decl(nir_variable *var, bool is_global, validate_state *state)
 962 {
 963    state->var = var;
 964
 965    validate_assert(state, is_global == nir_variable_is_global(var));
 966
 967    /* Must have exactly one mode set */
 968    validate_assert(state, util_bitcount(var->data.mode) == 1);
 969
 970    if (var->data.compact) {
 971       /* The "compact" flag is only valid on arrays of scalars. */
 972       assert(glsl_type_is_array(var->type));
 973
 974       const struct glsl_type *type = glsl_get_array_element(var->type);
 975       if (nir_is_per_vertex_io(var, state->shader->stage)) {
 976          assert(glsl_type_is_array(type));
 977          assert(glsl_type_is_scalar(glsl_get_array_element(type)));
 978       } else {
 979          assert(glsl_type_is_scalar(type));
 980       }
 981    }
 982
 983    /*
 984     * TODO validate some things ir_validate.cpp does (requires more GLSL type
 985     * support)
 986     */
 987
 988    if (!is_global) {
 989       _mesa_hash_table_insert(state->var_defs, var, state->impl);
 990    }
 991
 992    state->var = NULL;
 993 }
 994
 995 static bool
 996 postvalidate_ssa_def(nir_ssa_def *def, void *void_state)
 997 {
 998    validate_state *state = void_state;
 999
1000    struct hash_entry *entry = _mesa_hash_table_search(state->ssa_defs, def);
1001
1002    assume(entry);
1003    ssa_def_validate_state *def_state = (ssa_def_validate_state *)entry->data;
1004
1005    nir_foreach_use(src, def) {
1006       struct set_entry *entry = _mesa_set_search(def_state->uses, src);
1007       validate_assert(state, entry);
1008       _mesa_set_remove(def_state->uses, entry);
1009    }
1010
1011    if (def_state->uses->entries != 0) {
1012       printf("extra entries in SSA def uses:\n");
1013       struct set_entry *entry;
1014       set_foreach(def_state->uses, entry)
1015          printf("%p\n", entry->key);
1016
1017       abort();
1018    }
1019
1020    nir_foreach_if_use(src, def) {
1021       struct set_entry *entry = _mesa_set_search(def_state->if_uses, src);
1022       validate_assert(state, entry);
1023       _mesa_set_remove(def_state->if_uses, entry);
1024    }
1025
1026    if (def_state->if_uses->entries != 0) {
1027       printf("extra entries in SSA def uses:\n");
1028       struct set_entry *entry;
1029       set_foreach(def_state->if_uses, entry)
1030          printf("%p\n", entry->key);
1031
1032       abort();
1033    }
1034
1035    return true;
1036 }
1037
1038 static void
1039 validate_function_impl(nir_function_impl *impl, validate_state *state)
1040 {
1041    validate_assert(state, impl->function->impl == impl);
1042    validate_assert(state, impl->cf_node.parent == NULL);
1043
1044    validate_assert(state, impl->num_params == impl->function->num_params);
1045    for (unsigned i = 0; i < impl->num_params; i++) {
1046       validate_assert(state, impl->params[i]->type == impl->function->params[i].type);
1047       validate_assert(state, impl->params[i]->data.mode == nir_var_param);
1048       validate_assert(state, impl->params[i]->data.location == i);
1049       validate_var_decl(impl->params[i], false, state);
1050    }
1051
1052    if (glsl_type_is_void(impl->function->return_type)) {
1053       validate_assert(state, impl->return_var == NULL);
1054    } else {
1055       validate_assert(state, impl->return_var->type == impl->function->return_type);
1056       validate_assert(state, impl->return_var->data.mode == nir_var_param);
1057       validate_assert(state, impl->return_var->data.location == -1);
1058       validate_var_decl(impl->return_var, false, state);
1059    }
1060
1061    validate_assert(state, exec_list_is_empty(&impl->end_block->instr_list));
1062    validate_assert(state, impl->end_block->successors[0] == NULL);
1063    validate_assert(state, impl->end_block->successors[1] == NULL);
1064
1065    state->impl = impl;
1066    state->parent_node = &impl->cf_node;
1067
1068    exec_list_validate(&impl->locals);
1069    nir_foreach_variable(var, &impl->locals) {
1070       validate_var_decl(var, false, state);
1071    }
1072
1073    state->regs_found = realloc(state->regs_found,
1074                                BITSET_WORDS(impl->reg_alloc) *
1075                                sizeof(BITSET_WORD));
1076    memset(state->regs_found, 0, BITSET_WORDS(impl->reg_alloc) *
1077                                 sizeof(BITSET_WORD));
1078    exec_list_validate(&impl->registers);
1079    foreach_list_typed(nir_register, reg, node, &impl->registers) {
1080       prevalidate_reg_decl(reg, false, state);
1081    }
1082
1083    state->ssa_defs_found = realloc(state->ssa_defs_found,
1084                                    BITSET_WORDS(impl->ssa_alloc) *
1085                                    sizeof(BITSET_WORD));
1086    memset(state->ssa_defs_found, 0, BITSET_WORDS(impl->ssa_alloc) *
1087                                     sizeof(BITSET_WORD));
1088    exec_list_validate(&impl->body);
1089    foreach_list_typed(nir_cf_node, node, node, &impl->body) {
1090       validate_cf_node(node, state);
1091    }
1092
1093    foreach_list_typed(nir_register, reg, node, &impl->registers) {
1094       postvalidate_reg_decl(reg, state);
1095    }
1096
1097    nir_foreach_block(block, impl) {
1098       nir_foreach_instr(instr, block)
1099          nir_foreach_ssa_def(instr, postvalidate_ssa_def, state);
1100    }
1101 }
1102
1103 static void
1104 validate_function(nir_function *func, validate_state *state)
1105 {
1106    if (func->impl != NULL) {
1107       validate_assert(state, func->impl->function == func);
1108       validate_function_impl(func->impl, state);
1109    }
1110 }
1111
1112 static void
1113 init_validate_state(validate_state *state)
1114 {
1115    state->regs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1116                                          _mesa_key_pointer_equal);
1117    state->ssa_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1118                                              _mesa_key_pointer_equal);
1119    state->ssa_defs_found = NULL;
1120    state->regs_found = NULL;
1121    state->var_defs = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1122                                              _mesa_key_pointer_equal);
1123    state->errors = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
1124                                            _mesa_key_pointer_equal);
1125
1126    state->loop = NULL;
1127    state->instr = NULL;
1128    state->var = NULL;
1129 }
1130
1131 static void
1132 destroy_validate_state(validate_state *state)
1133 {
1134    _mesa_hash_table_destroy(state->regs, NULL);
1135    _mesa_hash_table_destroy(state->ssa_defs, NULL);
1136    free(state->ssa_defs_found);
1137    free(state->regs_found);
1138    _mesa_hash_table_destroy(state->var_defs, NULL);
1139    _mesa_hash_table_destroy(state->errors, NULL);
1140 }
1141
1142 static void
1143 dump_errors(validate_state *state)
1144 {
1145    struct hash_table *errors = state->errors;
1146
1147    fprintf(stderr, "%d errors:\n", _mesa_hash_table_num_entries(errors));
1148
1149    nir_print_shader_annotated(state->shader, stderr, errors);
1150
1151    if (_mesa_hash_table_num_entries(errors) > 0) {
1152       fprintf(stderr, "%d additional errors:\n",
1153               _mesa_hash_table_num_entries(errors));
1154       struct hash_entry *entry;
1155       hash_table_foreach(errors, entry) {
1156          fprintf(stderr, "%s\n", (char *)entry->data);
1157       }
1158    }
1159
1160    abort();
1161 }
1162
1163 void
1164 nir_validate_shader(nir_shader *shader)
1165 {
1166    static int should_validate = -1;
1167    if (should_validate < 0)
1168       should_validate = env_var_as_boolean("NIR_VALIDATE", true);
1169    if (!should_validate)
1170       return;
1171
1172    validate_state state;
1173    init_validate_state(&state);
1174
1175    state.shader = shader;
1176
1177    exec_list_validate(&shader->uniforms);
1178    nir_foreach_variable(var, &shader->uniforms) {
1179       validate_var_decl(var, true, &state);
1180    }
1181
1182    exec_list_validate(&shader->inputs);
1183    nir_foreach_variable(var, &shader->inputs) {
1184      validate_var_decl(var, true, &state);
1185    }
1186
1187    exec_list_validate(&shader->outputs);
1188    nir_foreach_variable(var, &shader->outputs) {
1189      validate_var_decl(var, true, &state);
1190    }
1191
1192    exec_list_validate(&shader->shared);
1193    nir_foreach_variable(var, &shader->shared) {
1194       validate_var_decl(var, true, &state);
1195    }
1196
1197    exec_list_validate(&shader->globals);
1198    nir_foreach_variable(var, &shader->globals) {
1199      validate_var_decl(var, true, &state);
1200    }
1201
1202    exec_list_validate(&shader->system_values);
1203    nir_foreach_variable(var, &shader->system_values) {
1204      validate_var_decl(var, true, &state);
1205    }
1206
1207    state.regs_found = realloc(state.regs_found,
1208                               BITSET_WORDS(shader->reg_alloc) *
1209                               sizeof(BITSET_WORD));
1210    memset(state.regs_found, 0, BITSET_WORDS(shader->reg_alloc) *
1211                                sizeof(BITSET_WORD));
1212    exec_list_validate(&shader->registers);
1213    foreach_list_typed(nir_register, reg, node, &shader->registers) {
1214       prevalidate_reg_decl(reg, true, &state);
1215    }
1216
1217    exec_list_validate(&shader->functions);
1218    foreach_list_typed(nir_function, func, node, &shader->functions) {
1219       validate_function(func, &state);
1220    }
1221
1222    foreach_list_typed(nir_register, reg, node, &shader->registers) {
1223       postvalidate_reg_decl(reg, &state);
1224    }
1225
1226    if (_mesa_hash_table_num_entries(state.errors) > 0)
1227       dump_errors(&state);
1228
1229    destroy_validate_state(&state);
1230 }
1231
1232 #endif /* NDEBUG */