1/* 2 * Copyright © 2010 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 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24/** 25 * \file ir_validate.cpp 26 * 27 * Attempts to verify that various invariants of the IR tree are true. 28 * 29 * In particular, at the moment it makes sure that no single 30 * ir_instruction node except for ir_variable appears multiple times 31 * in the ir tree. ir_variable does appear multiple times: Once as a 32 * declaration in an exec_list, and multiple times as the endpoint of 33 * a dereference chain. 34 */ 35 36#include "ir.h" 37#include "ir_hierarchical_visitor.h" 38#include "util/hash_table.h" 39#include "util/macros.h" 40#include "util/set.h" 41#include "compiler/glsl_types.h" 42 43namespace { 44 45class ir_validate : public ir_hierarchical_visitor { 46public: 47 ir_validate() 48 { 49 this->ir_set = _mesa_pointer_set_create(NULL); 50 51 this->current_function = NULL; 52 53 this->callback_enter = ir_validate::validate_ir; 54 this->data_enter = ir_set; 55 } 56 57 ~ir_validate() 58 { 59 _mesa_set_destroy(this->ir_set, NULL); 60 } 61 62 virtual ir_visitor_status visit(ir_variable *v); 63 virtual ir_visitor_status visit(ir_dereference_variable *ir); 64 65 virtual ir_visitor_status visit_enter(ir_discard *ir); 66 virtual ir_visitor_status visit_enter(ir_if *ir); 67 68 virtual ir_visitor_status visit_enter(ir_function *ir); 69 virtual ir_visitor_status visit_leave(ir_function *ir); 70 virtual ir_visitor_status visit_enter(ir_function_signature *ir); 71 72 virtual ir_visitor_status visit_leave(ir_expression *ir); 73 virtual ir_visitor_status visit_leave(ir_swizzle *ir); 74 75 virtual ir_visitor_status visit_enter(class ir_dereference_array *); 76 77 virtual ir_visitor_status visit_enter(ir_assignment *ir); 78 virtual ir_visitor_status visit_enter(ir_call *ir); 79 80 static void validate_ir(ir_instruction *ir, void *data); 81 82 ir_function *current_function; 83 84 struct set *ir_set; 85}; 86 87} /* anonymous namespace */ 88 89ir_visitor_status 90ir_validate::visit(ir_dereference_variable *ir) 91{ 92 if ((ir->var == NULL) || (ir->var->as_variable() == NULL)) { 93 printf("ir_dereference_variable @ %p does not specify a variable %p\n", 94 (void *) ir, (void *) ir->var); 95 abort(); 96 } 97 98 if (_mesa_set_search(ir_set, ir->var) == NULL) { 99 printf("ir_dereference_variable @ %p specifies undeclared variable " 100 "`%s' @ %p\n", 101 (void *) ir, ir->var->name, (void *) ir->var); 102 abort(); 103 } 104 105 this->validate_ir(ir, this->data_enter); 106 107 return visit_continue; 108} 109 110ir_visitor_status 111ir_validate::visit_enter(class ir_dereference_array *ir) 112{ 113 if (!ir->array->type->is_array() && !ir->array->type->is_matrix() && 114 !ir->array->type->is_vector()) { 115 printf("ir_dereference_array @ %p does not specify an array, a vector " 116 "or a matrix\n", 117 (void *) ir); 118 ir->print(); 119 printf("\n"); 120 abort(); 121 } 122 123 if (!ir->array_index->type->is_scalar()) { 124 printf("ir_dereference_array @ %p does not have scalar index: %s\n", 125 (void *) ir, ir->array_index->type->name); 126 abort(); 127 } 128 129 if (!ir->array_index->type->is_integer()) { 130 printf("ir_dereference_array @ %p does not have integer index: %s\n", 131 (void *) ir, ir->array_index->type->name); 132 abort(); 133 } 134 135 return visit_continue; 136} 137 138ir_visitor_status 139ir_validate::visit_enter(ir_discard *ir) 140{ 141 if (ir->condition && ir->condition->type != glsl_type::bool_type) { 142 printf("ir_discard condition %s type instead of bool.\n", 143 ir->condition->type->name); 144 ir->print(); 145 printf("\n"); 146 abort(); 147 } 148 149 return visit_continue; 150} 151 152ir_visitor_status 153ir_validate::visit_enter(ir_if *ir) 154{ 155 if (ir->condition->type != glsl_type::bool_type) { 156 printf("ir_if condition %s type instead of bool.\n", 157 ir->condition->type->name); 158 ir->print(); 159 printf("\n"); 160 abort(); 161 } 162 163 return visit_continue; 164} 165 166 167ir_visitor_status 168ir_validate::visit_enter(ir_function *ir) 169{ 170 /* Function definitions cannot be nested. 171 */ 172 if (this->current_function != NULL) { 173 printf("Function definition nested inside another function " 174 "definition:\n"); 175 printf("%s %p inside %s %p\n", 176 ir->name, (void *) ir, 177 this->current_function->name, (void *) this->current_function); 178 abort(); 179 } 180 181 /* Store the current function hierarchy being traversed. This is used 182 * by the function signature visitor to ensure that the signatures are 183 * linked with the correct functions. 184 */ 185 this->current_function = ir; 186 187 this->validate_ir(ir, this->data_enter); 188 189 /* Verify that all of the things stored in the list of signatures are, 190 * in fact, function signatures. 191 */ 192 foreach_in_list(ir_instruction, sig, &ir->signatures) { 193 if (sig->ir_type != ir_type_function_signature) { 194 printf("Non-signature in signature list of function `%s'\n", 195 ir->name); 196 abort(); 197 } 198 } 199 200 return visit_continue; 201} 202 203ir_visitor_status 204ir_validate::visit_leave(ir_function *ir) 205{ 206 assert(ralloc_parent(ir->name) == ir); 207 208 this->current_function = NULL; 209 return visit_continue; 210} 211 212ir_visitor_status 213ir_validate::visit_enter(ir_function_signature *ir) 214{ 215 if (this->current_function != ir->function()) { 216 printf("Function signature nested inside wrong function " 217 "definition:\n"); 218 printf("%p inside %s %p instead of %s %p\n", 219 (void *) ir, 220 this->current_function->name, (void *) this->current_function, 221 ir->function_name(), (void *) ir->function()); 222 abort(); 223 } 224 225 if (ir->return_type == NULL) { 226 printf("Function signature %p for function %s has NULL return type.\n", 227 (void *) ir, ir->function_name()); 228 abort(); 229 } 230 231 this->validate_ir(ir, this->data_enter); 232 233 return visit_continue; 234} 235 236ir_visitor_status 237ir_validate::visit_leave(ir_expression *ir) 238{ 239 for (unsigned i = ir->num_operands; i < 4; i++) { 240 assert(ir->operands[i] == NULL); 241 } 242 243 for (unsigned i = 0; i < ir->num_operands; i++) { 244 assert(ir->operands[i] != NULL); 245 } 246 247 switch (ir->operation) { 248 case ir_unop_bit_not: 249 assert(ir->operands[0]->type == ir->type); 250 break; 251 case ir_unop_logic_not: 252 assert(ir->type->is_boolean()); 253 assert(ir->operands[0]->type->is_boolean()); 254 break; 255 256 case ir_unop_neg: 257 assert(ir->type == ir->operands[0]->type); 258 break; 259 260 case ir_unop_abs: 261 case ir_unop_sign: 262 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT || 263 ir->operands[0]->type->is_float() || 264 ir->operands[0]->type->is_double() || 265 ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 266 assert(ir->type == ir->operands[0]->type); 267 break; 268 269 case ir_unop_rcp: 270 case ir_unop_rsq: 271 case ir_unop_sqrt: 272 assert(ir->type->is_float() || 273 ir->type->is_double()); 274 assert(ir->type == ir->operands[0]->type); 275 break; 276 277 case ir_unop_exp: 278 case ir_unop_log: 279 case ir_unop_exp2: 280 case ir_unop_log2: 281 case ir_unop_saturate: 282 assert(ir->operands[0]->type->is_float()); 283 assert(ir->type == ir->operands[0]->type); 284 break; 285 286 case ir_unop_f2i: 287 assert(ir->operands[0]->type->is_float()); 288 assert(ir->type->base_type == GLSL_TYPE_INT); 289 break; 290 case ir_unop_f2u: 291 assert(ir->operands[0]->type->is_float()); 292 assert(ir->type->base_type == GLSL_TYPE_UINT); 293 break; 294 case ir_unop_i2f: 295 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 296 assert(ir->type->is_float()); 297 break; 298 case ir_unop_f2b: 299 assert(ir->operands[0]->type->is_float()); 300 assert(ir->type->is_boolean()); 301 break; 302 case ir_unop_b2f: 303 assert(ir->operands[0]->type->is_boolean()); 304 assert(ir->type->is_float()); 305 break; 306 case ir_unop_i2b: 307 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 308 assert(ir->type->is_boolean()); 309 break; 310 case ir_unop_b2i: 311 assert(ir->operands[0]->type->is_boolean()); 312 assert(ir->type->base_type == GLSL_TYPE_INT); 313 break; 314 case ir_unop_u2f: 315 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 316 assert(ir->type->is_float()); 317 break; 318 case ir_unop_i2u: 319 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 320 assert(ir->type->base_type == GLSL_TYPE_UINT); 321 break; 322 case ir_unop_u2i: 323 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 324 assert(ir->type->base_type == GLSL_TYPE_INT); 325 break; 326 case ir_unop_bitcast_i2f: 327 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 328 assert(ir->type->is_float()); 329 break; 330 case ir_unop_bitcast_f2i: 331 assert(ir->operands[0]->type->is_float()); 332 assert(ir->type->base_type == GLSL_TYPE_INT); 333 break; 334 case ir_unop_bitcast_u2f: 335 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 336 assert(ir->type->is_float()); 337 break; 338 case ir_unop_bitcast_f2u: 339 assert(ir->operands[0]->type->is_float()); 340 assert(ir->type->base_type == GLSL_TYPE_UINT); 341 break; 342 343 case ir_unop_bitcast_u642d: 344 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 345 assert(ir->type->is_double()); 346 break; 347 case ir_unop_bitcast_i642d: 348 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 349 assert(ir->type->is_double()); 350 break; 351 case ir_unop_bitcast_d2u64: 352 assert(ir->operands[0]->type->is_double()); 353 assert(ir->type->base_type == GLSL_TYPE_UINT64); 354 break; 355 case ir_unop_bitcast_d2i64: 356 assert(ir->operands[0]->type->is_double()); 357 assert(ir->type->base_type == GLSL_TYPE_INT64); 358 break; 359 case ir_unop_i642i: 360 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 361 assert(ir->type->base_type == GLSL_TYPE_INT); 362 break; 363 case ir_unop_u642i: 364 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 365 assert(ir->type->base_type == GLSL_TYPE_INT); 366 break; 367 case ir_unop_i642u: 368 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 369 assert(ir->type->base_type == GLSL_TYPE_UINT); 370 break; 371 case ir_unop_u642u: 372 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 373 assert(ir->type->base_type == GLSL_TYPE_UINT); 374 break; 375 case ir_unop_i642b: 376 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 377 assert(ir->type->is_boolean()); 378 break; 379 case ir_unop_i642f: 380 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 381 assert(ir->type->is_float()); 382 break; 383 case ir_unop_u642f: 384 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 385 assert(ir->type->is_float()); 386 break; 387 case ir_unop_i642d: 388 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 389 assert(ir->type->is_double()); 390 break; 391 case ir_unop_u642d: 392 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 393 assert(ir->type->is_double()); 394 break; 395 case ir_unop_i2i64: 396 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 397 assert(ir->type->base_type == GLSL_TYPE_INT64); 398 break; 399 case ir_unop_u2i64: 400 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 401 assert(ir->type->base_type == GLSL_TYPE_INT64); 402 break; 403 case ir_unop_b2i64: 404 assert(ir->operands[0]->type->is_boolean()); 405 assert(ir->type->base_type == GLSL_TYPE_INT64); 406 break; 407 case ir_unop_f2i64: 408 assert(ir->operands[0]->type->is_float()); 409 assert(ir->type->base_type == GLSL_TYPE_INT64); 410 break; 411 case ir_unop_d2i64: 412 assert(ir->operands[0]->type->is_double()); 413 assert(ir->type->base_type == GLSL_TYPE_INT64); 414 break; 415 case ir_unop_i2u64: 416 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 417 assert(ir->type->base_type == GLSL_TYPE_UINT64); 418 break; 419 case ir_unop_u2u64: 420 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 421 assert(ir->type->base_type == GLSL_TYPE_UINT64); 422 break; 423 case ir_unop_f2u64: 424 assert(ir->operands[0]->type->is_float()); 425 assert(ir->type->base_type == GLSL_TYPE_UINT64); 426 break; 427 case ir_unop_d2u64: 428 assert(ir->operands[0]->type->is_double()); 429 assert(ir->type->base_type == GLSL_TYPE_UINT64); 430 break; 431 case ir_unop_u642i64: 432 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT64); 433 assert(ir->type->base_type == GLSL_TYPE_INT64); 434 break; 435 case ir_unop_i642u64: 436 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT64); 437 assert(ir->type->base_type == GLSL_TYPE_UINT64); 438 break; 439 case ir_unop_trunc: 440 case ir_unop_round_even: 441 case ir_unop_ceil: 442 case ir_unop_floor: 443 case ir_unop_fract: 444 assert(ir->operands[0]->type->is_float() || 445 ir->operands[0]->type->is_double()); 446 assert(ir->operands[0]->type == ir->type); 447 break; 448 case ir_unop_sin: 449 case ir_unop_cos: 450 case ir_unop_dFdx: 451 case ir_unop_dFdx_coarse: 452 case ir_unop_dFdx_fine: 453 case ir_unop_dFdy: 454 case ir_unop_dFdy_coarse: 455 case ir_unop_dFdy_fine: 456 assert(ir->operands[0]->type->is_float()); 457 assert(ir->operands[0]->type == ir->type); 458 break; 459 460 case ir_unop_pack_snorm_2x16: 461 case ir_unop_pack_unorm_2x16: 462 case ir_unop_pack_half_2x16: 463 assert(ir->type == glsl_type::uint_type); 464 assert(ir->operands[0]->type == glsl_type::vec2_type); 465 break; 466 467 case ir_unop_pack_snorm_4x8: 468 case ir_unop_pack_unorm_4x8: 469 assert(ir->type == glsl_type::uint_type); 470 assert(ir->operands[0]->type == glsl_type::vec4_type); 471 break; 472 473 case ir_unop_pack_double_2x32: 474 assert(ir->type == glsl_type::double_type); 475 assert(ir->operands[0]->type == glsl_type::uvec2_type); 476 break; 477 478 case ir_unop_pack_int_2x32: 479 assert(ir->type == glsl_type::int64_t_type); 480 assert(ir->operands[0]->type == glsl_type::ivec2_type); 481 break; 482 483 case ir_unop_pack_uint_2x32: 484 assert(ir->type == glsl_type::uint64_t_type); 485 assert(ir->operands[0]->type == glsl_type::uvec2_type); 486 break; 487 488 case ir_unop_pack_sampler_2x32: 489 assert(ir->type->is_sampler()); 490 assert(ir->operands[0]->type == glsl_type::uvec2_type); 491 break; 492 493 case ir_unop_pack_image_2x32: 494 assert(ir->type->is_image()); 495 assert(ir->operands[0]->type == glsl_type::uvec2_type); 496 break; 497 498 case ir_unop_unpack_snorm_2x16: 499 case ir_unop_unpack_unorm_2x16: 500 case ir_unop_unpack_half_2x16: 501 assert(ir->type == glsl_type::vec2_type); 502 assert(ir->operands[0]->type == glsl_type::uint_type); 503 break; 504 505 case ir_unop_unpack_snorm_4x8: 506 case ir_unop_unpack_unorm_4x8: 507 assert(ir->type == glsl_type::vec4_type); 508 assert(ir->operands[0]->type == glsl_type::uint_type); 509 break; 510 511 case ir_unop_unpack_double_2x32: 512 assert(ir->type == glsl_type::uvec2_type); 513 assert(ir->operands[0]->type == glsl_type::double_type); 514 break; 515 516 case ir_unop_unpack_int_2x32: 517 assert(ir->type == glsl_type::ivec2_type); 518 assert(ir->operands[0]->type == glsl_type::int64_t_type); 519 break; 520 521 case ir_unop_unpack_uint_2x32: 522 assert(ir->type == glsl_type::uvec2_type); 523 assert(ir->operands[0]->type == glsl_type::uint64_t_type); 524 break; 525 526 case ir_unop_unpack_sampler_2x32: 527 assert(ir->type == glsl_type::uvec2_type); 528 assert(ir->operands[0]->type->is_sampler()); 529 break; 530 531 case ir_unop_unpack_image_2x32: 532 assert(ir->type == glsl_type::uvec2_type); 533 assert(ir->operands[0]->type->is_image()); 534 break; 535 536 case ir_unop_bitfield_reverse: 537 assert(ir->operands[0]->type == ir->type); 538 assert(ir->type->is_integer()); 539 break; 540 541 case ir_unop_bit_count: 542 case ir_unop_find_msb: 543 case ir_unop_find_lsb: 544 assert(ir->operands[0]->type->vector_elements == ir->type->vector_elements); 545 assert(ir->operands[0]->type->is_integer()); 546 assert(ir->type->base_type == GLSL_TYPE_INT); 547 break; 548 549 case ir_unop_noise: 550 /* XXX what can we assert here? */ 551 break; 552 553 case ir_unop_interpolate_at_centroid: 554 assert(ir->operands[0]->type == ir->type); 555 assert(ir->operands[0]->type->is_float()); 556 break; 557 558 case ir_unop_get_buffer_size: 559 assert(ir->type == glsl_type::int_type); 560 assert(ir->operands[0]->type == glsl_type::uint_type); 561 break; 562 563 case ir_unop_ssbo_unsized_array_length: 564 assert(ir->type == glsl_type::int_type); 565 assert(ir->operands[0]->type->is_array()); 566 assert(ir->operands[0]->type->is_unsized_array()); 567 break; 568 569 case ir_unop_d2f: 570 assert(ir->operands[0]->type->is_double()); 571 assert(ir->type->is_float()); 572 break; 573 case ir_unop_f2d: 574 assert(ir->operands[0]->type->is_float()); 575 assert(ir->type->is_double()); 576 break; 577 case ir_unop_d2i: 578 assert(ir->operands[0]->type->is_double()); 579 assert(ir->type->base_type == GLSL_TYPE_INT); 580 break; 581 case ir_unop_i2d: 582 assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT); 583 assert(ir->type->is_double()); 584 break; 585 case ir_unop_d2u: 586 assert(ir->operands[0]->type->is_double()); 587 assert(ir->type->base_type == GLSL_TYPE_UINT); 588 break; 589 case ir_unop_u2d: 590 assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT); 591 assert(ir->type->is_double()); 592 break; 593 case ir_unop_d2b: 594 assert(ir->operands[0]->type->is_double()); 595 assert(ir->type->is_boolean()); 596 break; 597 598 case ir_unop_frexp_sig: 599 assert(ir->operands[0]->type->is_float() || 600 ir->operands[0]->type->is_double()); 601 assert(ir->type->is_double()); 602 break; 603 case ir_unop_frexp_exp: 604 assert(ir->operands[0]->type->is_float() || 605 ir->operands[0]->type->is_double()); 606 assert(ir->type->base_type == GLSL_TYPE_INT); 607 break; 608 case ir_unop_subroutine_to_int: 609 assert(ir->operands[0]->type->base_type == GLSL_TYPE_SUBROUTINE); 610 assert(ir->type->base_type == GLSL_TYPE_INT); 611 break; 612 613 case ir_binop_add: 614 case ir_binop_sub: 615 case ir_binop_mul: 616 case ir_binop_div: 617 case ir_binop_mod: 618 case ir_binop_min: 619 case ir_binop_max: 620 case ir_binop_pow: 621 assert(ir->operands[0]->type->base_type == 622 ir->operands[1]->type->base_type); 623 624 if (ir->operation == ir_binop_mul && 625 (ir->type->base_type == GLSL_TYPE_UINT64 || 626 ir->type->base_type == GLSL_TYPE_INT64) && 627 (ir->operands[0]->type->base_type == GLSL_TYPE_INT || 628 ir->operands[1]->type->base_type == GLSL_TYPE_INT || 629 ir->operands[0]->type->base_type == GLSL_TYPE_UINT || 630 ir->operands[1]->type->base_type == GLSL_TYPE_UINT)) { 631 assert(ir->operands[0]->type == ir->operands[1]->type); 632 break; 633 } 634 635 if (ir->operands[0]->type->is_scalar()) 636 assert(ir->operands[1]->type == ir->type); 637 else if (ir->operands[1]->type->is_scalar()) 638 assert(ir->operands[0]->type == ir->type); 639 else if (ir->operands[0]->type->is_vector() && 640 ir->operands[1]->type->is_vector()) { 641 assert(ir->operands[0]->type == ir->operands[1]->type); 642 assert(ir->operands[0]->type == ir->type); 643 } 644 break; 645 646 case ir_binop_imul_high: 647 assert(ir->type == ir->operands[0]->type); 648 assert(ir->type == ir->operands[1]->type); 649 assert(ir->type->is_integer()); 650 break; 651 652 case ir_binop_carry: 653 case ir_binop_borrow: 654 assert(ir->type == ir->operands[0]->type); 655 assert(ir->type == ir->operands[1]->type); 656 assert(ir->type->base_type == GLSL_TYPE_UINT); 657 break; 658 659 case ir_binop_less: 660 case ir_binop_gequal: 661 case ir_binop_equal: 662 case ir_binop_nequal: 663 /* The semantics of the IR operators differ from the GLSL <, >, <=, >=, 664 * ==, and != operators. The IR operators perform a component-wise 665 * comparison on scalar or vector types and return a boolean scalar or 666 * vector type of the same size. 667 */ 668 assert(ir->type->is_boolean()); 669 assert(ir->operands[0]->type == ir->operands[1]->type); 670 assert(ir->operands[0]->type->is_vector() 671 || ir->operands[0]->type->is_scalar()); 672 assert(ir->operands[0]->type->vector_elements 673 == ir->type->vector_elements); 674 break; 675 676 case ir_binop_all_equal: 677 case ir_binop_any_nequal: 678 /* GLSL == and != operate on scalars, vectors, matrices and arrays, and 679 * return a scalar boolean. The IR matches that. 680 */ 681 assert(ir->type == glsl_type::bool_type); 682 assert(ir->operands[0]->type == ir->operands[1]->type); 683 break; 684 685 case ir_binop_lshift: 686 case ir_binop_rshift: 687 assert(ir->operands[0]->type->is_integer_32_64() && 688 ir->operands[1]->type->is_integer()); 689 if (ir->operands[0]->type->is_scalar()) { 690 assert(ir->operands[1]->type->is_scalar()); 691 } 692 if (ir->operands[0]->type->is_vector() && 693 ir->operands[1]->type->is_vector()) { 694 assert(ir->operands[0]->type->components() == 695 ir->operands[1]->type->components()); 696 } 697 assert(ir->type == ir->operands[0]->type); 698 break; 699 700 case ir_binop_bit_and: 701 case ir_binop_bit_xor: 702 case ir_binop_bit_or: 703 assert(ir->operands[0]->type->base_type == 704 ir->operands[1]->type->base_type); 705 assert(ir->type->is_integer_32_64()); 706 if (ir->operands[0]->type->is_vector() && 707 ir->operands[1]->type->is_vector()) { 708 assert(ir->operands[0]->type->vector_elements == 709 ir->operands[1]->type->vector_elements); 710 } 711 break; 712 713 case ir_binop_logic_and: 714 case ir_binop_logic_xor: 715 case ir_binop_logic_or: 716 assert(ir->type->is_boolean()); 717 assert(ir->operands[0]->type->is_boolean()); 718 assert(ir->operands[1]->type->is_boolean()); 719 break; 720 721 case ir_binop_dot: 722 assert(ir->type == glsl_type::float_type || 723 ir->type == glsl_type::double_type); 724 assert(ir->operands[0]->type->is_float() || 725 ir->operands[0]->type->is_double()); 726 assert(ir->operands[0]->type->is_vector()); 727 assert(ir->operands[0]->type == ir->operands[1]->type); 728 break; 729 730 case ir_binop_ubo_load: 731 assert(ir->operands[0]->type == glsl_type::uint_type); 732 733 assert(ir->operands[1]->type == glsl_type::uint_type); 734 break; 735 736 case ir_binop_ldexp: 737 assert(ir->operands[0]->type == ir->type); 738 assert(ir->operands[0]->type->is_float() || 739 ir->operands[0]->type->is_double()); 740 assert(ir->operands[1]->type->base_type == GLSL_TYPE_INT); 741 assert(ir->operands[0]->type->components() == 742 ir->operands[1]->type->components()); 743 break; 744 745 case ir_binop_vector_extract: 746 assert(ir->operands[0]->type->is_vector()); 747 assert(ir->operands[1]->type->is_scalar() 748 && ir->operands[1]->type->is_integer()); 749 break; 750 751 case ir_binop_interpolate_at_offset: 752 assert(ir->operands[0]->type == ir->type); 753 assert(ir->operands[0]->type->is_float()); 754 assert(ir->operands[1]->type->components() == 2); 755 assert(ir->operands[1]->type->is_float()); 756 break; 757 758 case ir_binop_interpolate_at_sample: 759 assert(ir->operands[0]->type == ir->type); 760 assert(ir->operands[0]->type->is_float()); 761 assert(ir->operands[1]->type == glsl_type::int_type); 762 break; 763 764 case ir_triop_fma: 765 assert(ir->type->is_float() || 766 ir->type->is_double()); 767 assert(ir->type == ir->operands[0]->type); 768 assert(ir->type == ir->operands[1]->type); 769 assert(ir->type == ir->operands[2]->type); 770 break; 771 772 case ir_triop_lrp: 773 assert(ir->operands[0]->type->is_float() || 774 ir->operands[0]->type->is_double()); 775 assert(ir->operands[0]->type == ir->operands[1]->type); 776 assert(ir->operands[2]->type == ir->operands[0]->type || 777 ir->operands[2]->type == glsl_type::float_type || 778 ir->operands[2]->type == glsl_type::double_type); 779 break; 780 781 case ir_triop_csel: 782 assert(ir->operands[0]->type->is_boolean()); 783 assert(ir->type->vector_elements == ir->operands[0]->type->vector_elements); 784 assert(ir->type == ir->operands[1]->type); 785 assert(ir->type == ir->operands[2]->type); 786 break; 787 788 case ir_triop_bitfield_extract: 789 assert(ir->type->is_integer()); 790 assert(ir->operands[0]->type == ir->type); 791 assert(ir->operands[1]->type == ir->type); 792 assert(ir->operands[2]->type == ir->type); 793 break; 794 795 case ir_triop_vector_insert: 796 assert(ir->operands[0]->type->is_vector()); 797 assert(ir->operands[1]->type->is_scalar()); 798 assert(ir->operands[0]->type->base_type == ir->operands[1]->type->base_type); 799 assert(ir->operands[2]->type->is_scalar() 800 && ir->operands[2]->type->is_integer()); 801 assert(ir->type == ir->operands[0]->type); 802 break; 803 804 case ir_quadop_bitfield_insert: 805 assert(ir->type->is_integer()); 806 assert(ir->operands[0]->type == ir->type); 807 assert(ir->operands[1]->type == ir->type); 808 assert(ir->operands[2]->type == ir->type); 809 assert(ir->operands[3]->type == ir->type); 810 break; 811 812 case ir_quadop_vector: 813 /* The vector operator collects some number of scalars and generates a 814 * vector from them. 815 * 816 * - All of the operands must be scalar. 817 * - Number of operands must matche the size of the resulting vector. 818 * - Base type of the operands must match the base type of the result. 819 */ 820 assert(ir->type->is_vector()); 821 switch (ir->type->vector_elements) { 822 case 2: 823 assert(ir->operands[0]->type->is_scalar()); 824 assert(ir->operands[0]->type->base_type == ir->type->base_type); 825 assert(ir->operands[1]->type->is_scalar()); 826 assert(ir->operands[1]->type->base_type == ir->type->base_type); 827 assert(ir->operands[2] == NULL); 828 assert(ir->operands[3] == NULL); 829 break; 830 case 3: 831 assert(ir->operands[0]->type->is_scalar()); 832 assert(ir->operands[0]->type->base_type == ir->type->base_type); 833 assert(ir->operands[1]->type->is_scalar()); 834 assert(ir->operands[1]->type->base_type == ir->type->base_type); 835 assert(ir->operands[2]->type->is_scalar()); 836 assert(ir->operands[2]->type->base_type == ir->type->base_type); 837 assert(ir->operands[3] == NULL); 838 break; 839 case 4: 840 assert(ir->operands[0]->type->is_scalar()); 841 assert(ir->operands[0]->type->base_type == ir->type->base_type); 842 assert(ir->operands[1]->type->is_scalar()); 843 assert(ir->operands[1]->type->base_type == ir->type->base_type); 844 assert(ir->operands[2]->type->is_scalar()); 845 assert(ir->operands[2]->type->base_type == ir->type->base_type); 846 assert(ir->operands[3]->type->is_scalar()); 847 assert(ir->operands[3]->type->base_type == ir->type->base_type); 848 break; 849 default: 850 /* The is_vector assertion above should prevent execution from ever 851 * getting here. 852 */ 853 assert(!"Should not get here."); 854 break; 855 } 856 } 857 858 return visit_continue; 859} 860 861ir_visitor_status 862ir_validate::visit_leave(ir_swizzle *ir) 863{ 864 unsigned int chans[4] = {ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w}; 865 866 for (unsigned int i = 0; i < ir->type->vector_elements; i++) { 867 if (chans[i] >= ir->val->type->vector_elements) { 868 printf("ir_swizzle @ %p specifies a channel not present " 869 "in the value.\n", (void *) ir); 870 ir->print(); 871 abort(); 872 } 873 } 874 875 return visit_continue; 876} 877 878ir_visitor_status 879ir_validate::visit(ir_variable *ir) 880{ 881 /* An ir_variable is the one thing that can (and will) appear multiple times 882 * in an IR tree. It is added to the hashtable so that it can be used 883 * in the ir_dereference_variable handler to ensure that a variable is 884 * declared before it is dereferenced. 885 */ 886 if (ir->name && ir->is_name_ralloced()) 887 assert(ralloc_parent(ir->name) == ir); 888 889 _mesa_set_add(ir_set, ir); 890 891 /* If a variable is an array, verify that the maximum array index is in 892 * bounds. There was once an error in AST-to-HIR conversion that set this 893 * to be out of bounds. 894 */ 895 if (ir->type->array_size() > 0) { 896 if (ir->data.max_array_access >= (int)ir->type->length) { 897 printf("ir_variable has maximum access out of bounds (%d vs %d)\n", 898 ir->data.max_array_access, ir->type->length - 1); 899 ir->print(); 900 abort(); 901 } 902 } 903 904 /* If a variable is an interface block (or an array of interface blocks), 905 * verify that the maximum array index for each interface member is in 906 * bounds. 907 */ 908 if (ir->is_interface_instance()) { 909 const glsl_struct_field *fields = 910 ir->get_interface_type()->fields.structure; 911 for (unsigned i = 0; i < ir->get_interface_type()->length; i++) { 912 if (fields[i].type->array_size() > 0 && 913 !fields[i].implicit_sized_array) { 914 const int *const max_ifc_array_access = 915 ir->get_max_ifc_array_access(); 916 917 assert(max_ifc_array_access != NULL); 918 919 if (max_ifc_array_access[i] >= (int)fields[i].type->length) { 920 printf("ir_variable has maximum access out of bounds for " 921 "field %s (%d vs %d)\n", fields[i].name, 922 max_ifc_array_access[i], fields[i].type->length); 923 ir->print(); 924 abort(); 925 } 926 } 927 } 928 } 929 930 if (ir->constant_initializer != NULL && !ir->data.has_initializer) { 931 printf("ir_variable didn't have an initializer, but has a constant " 932 "initializer value.\n"); 933 ir->print(); 934 abort(); 935 } 936 937 if (ir->data.mode == ir_var_uniform 938 && is_gl_identifier(ir->name) 939 && ir->get_state_slots() == NULL) { 940 printf("built-in uniform has no state\n"); 941 ir->print(); 942 abort(); 943 } 944 945 return visit_continue; 946} 947 948ir_visitor_status 949ir_validate::visit_enter(ir_assignment *ir) 950{ 951 const ir_dereference *const lhs = ir->lhs; 952 if (lhs->type->is_scalar() || lhs->type->is_vector()) { 953 if (ir->write_mask == 0) { 954 printf("Assignment LHS is %s, but write mask is 0:\n", 955 lhs->type->is_scalar() ? "scalar" : "vector"); 956 ir->print(); 957 abort(); 958 } 959 960 int lhs_components = 0; 961 for (int i = 0; i < 4; i++) { 962 if (ir->write_mask & (1 << i)) 963 lhs_components++; 964 } 965 966 if (lhs_components != ir->rhs->type->vector_elements) { 967 printf("Assignment count of LHS write mask channels enabled not\n" 968 "matching RHS vector size (%d LHS, %d RHS).\n", 969 lhs_components, ir->rhs->type->vector_elements); 970 ir->print(); 971 abort(); 972 } 973 } 974 975 this->validate_ir(ir, this->data_enter); 976 977 return visit_continue; 978} 979 980ir_visitor_status 981ir_validate::visit_enter(ir_call *ir) 982{ 983 ir_function_signature *const callee = ir->callee; 984 985 if (callee->ir_type != ir_type_function_signature) { 986 printf("IR called by ir_call is not ir_function_signature!\n"); 987 abort(); 988 } 989 990 if (ir->return_deref) { 991 if (ir->return_deref->type != callee->return_type) { 992 printf("callee type %s does not match return storage type %s\n", 993 callee->return_type->name, ir->return_deref->type->name); 994 abort(); 995 } 996 } else if (callee->return_type != glsl_type::void_type) { 997 printf("ir_call has non-void callee but no return storage\n"); 998 abort(); 999 } 1000 1001 const exec_node *formal_param_node = callee->parameters.get_head_raw(); 1002 const exec_node *actual_param_node = ir->actual_parameters.get_head_raw(); 1003 while (true) { 1004 if (formal_param_node->is_tail_sentinel() 1005 != actual_param_node->is_tail_sentinel()) { 1006 printf("ir_call has the wrong number of parameters:\n"); 1007 goto dump_ir; 1008 } 1009 if (formal_param_node->is_tail_sentinel()) { 1010 break; 1011 } 1012 const ir_variable *formal_param 1013 = (const ir_variable *) formal_param_node; 1014 const ir_rvalue *actual_param 1015 = (const ir_rvalue *) actual_param_node; 1016 if (formal_param->type != actual_param->type) { 1017 printf("ir_call parameter type mismatch:\n"); 1018 goto dump_ir; 1019 } 1020 if (formal_param->data.mode == ir_var_function_out 1021 || formal_param->data.mode == ir_var_function_inout) { 1022 if (!actual_param->is_lvalue()) { 1023 printf("ir_call out/inout parameters must be lvalues:\n"); 1024 goto dump_ir; 1025 } 1026 } 1027 formal_param_node = formal_param_node->next; 1028 actual_param_node = actual_param_node->next; 1029 } 1030 1031 return visit_continue; 1032 1033dump_ir: 1034 ir->print(); 1035 printf("callee:\n"); 1036 callee->print(); 1037 abort(); 1038 return visit_stop; 1039} 1040 1041void 1042ir_validate::validate_ir(ir_instruction *ir, void *data) 1043{ 1044 struct set *ir_set = (struct set *) data; 1045 1046 if (_mesa_set_search(ir_set, ir)) { 1047 printf("Instruction node present twice in ir tree:\n"); 1048 ir->print(); 1049 printf("\n"); 1050 abort(); 1051 } 1052 _mesa_set_add(ir_set, ir); 1053} 1054 1055MAYBE_UNUSED static void 1056check_node_type(ir_instruction *ir, void *data) 1057{ 1058 (void) data; 1059 1060 if (ir->ir_type >= ir_type_max) { 1061 printf("Instruction node with unset type\n"); 1062 ir->print(); printf("\n"); 1063 } 1064 ir_rvalue *value = ir->as_rvalue(); 1065 if (value != NULL) 1066 assert(value->type != glsl_type::error_type); 1067} 1068 1069void 1070validate_ir_tree(exec_list *instructions) 1071{ 1072 /* We shouldn't have any reason to validate IR in a release build, 1073 * and it's half composed of assert()s anyway which wouldn't do 1074 * anything. 1075 */ 1076#ifdef DEBUG 1077 ir_validate v; 1078 1079 v.run(instructions); 1080 1081 foreach_in_list(ir_instruction, ir, instructions) { 1082 visit_tree(ir, check_node_type, NULL); 1083 } 1084#endif 1085} 1086