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