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