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 #include <string.h> 24 #include "main/core.h" /* for MAX2 */ 25 #include "ir.h" 26 #include "ir_visitor.h" 27 #include "glsl_types.h" 28 29 ir_rvalue::ir_rvalue() 30 { 31 this->type = glsl_type::error_type; 32 } 33 34 bool ir_rvalue::is_zero() const 35 { 36 return false; 37 } 38 39 bool ir_rvalue::is_one() const 40 { 41 return false; 42 } 43 44 bool ir_rvalue::is_negative_one() const 45 { 46 return false; 47 } 48 49 bool ir_rvalue::is_basis() const 50 { 51 return false; 52 } 53 54 /** 55 * Modify the swizzle make to move one component to another 56 * 57 * \param m IR swizzle to be modified 58 * \param from Component in the RHS that is to be swizzled 59 * \param to Desired swizzle location of \c from 60 */ 61 static void 62 update_rhs_swizzle(ir_swizzle_mask &m, unsigned from, unsigned to) 63 { 64 switch (to) { 65 case 0: m.x = from; break; 66 case 1: m.y = from; break; 67 case 2: m.z = from; break; 68 case 3: m.w = from; break; 69 default: assert(!"Should not get here."); 70 } 71 72 m.num_components = MAX2(m.num_components, (to + 1)); 73 } 74 75 void 76 ir_assignment::set_lhs(ir_rvalue *lhs) 77 { 78 void *mem_ctx = this; 79 bool swizzled = false; 80 81 while (lhs != NULL) { 82 ir_swizzle *swiz = lhs->as_swizzle(); 83 84 if (swiz == NULL) 85 break; 86 87 unsigned write_mask = 0; 88 ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 }; 89 90 for (unsigned i = 0; i < swiz->mask.num_components; i++) { 91 unsigned c = 0; 92 93 switch (i) { 94 case 0: c = swiz->mask.x; break; 95 case 1: c = swiz->mask.y; break; 96 case 2: c = swiz->mask.z; break; 97 case 3: c = swiz->mask.w; break; 98 default: assert(!"Should not get here."); 99 } 100 101 write_mask |= (((this->write_mask >> i) & 1) << c); 102 update_rhs_swizzle(rhs_swiz, i, c); 103 } 104 105 this->write_mask = write_mask; 106 lhs = swiz->val; 107 108 this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz); 109 swizzled = true; 110 } 111 112 if (swizzled) { 113 /* Now, RHS channels line up with the LHS writemask. Collapse it 114 * to just the channels that will be written. 115 */ 116 ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 }; 117 int rhs_chan = 0; 118 for (int i = 0; i < 4; i++) { 119 if (write_mask & (1 << i)) 120 update_rhs_swizzle(rhs_swiz, i, rhs_chan++); 121 } 122 this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz); 123 } 124 125 assert((lhs == NULL) || lhs->as_dereference()); 126 127 this->lhs = (ir_dereference *) lhs; 128 } 129 130 ir_variable * 131 ir_assignment::whole_variable_written() 132 { 133 ir_variable *v = this->lhs->whole_variable_referenced(); 134 135 if (v == NULL) 136 return NULL; 137 138 if (v->type->is_scalar()) 139 return v; 140 141 if (v->type->is_vector()) { 142 const unsigned mask = (1U << v->type->vector_elements) - 1; 143 144 if (mask != this->write_mask) 145 return NULL; 146 } 147 148 /* Either all the vector components are assigned or the variable is some 149 * composite type (and the whole thing is assigned. 150 */ 151 return v; 152 } 153 154 ir_assignment::ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, 155 ir_rvalue *condition, unsigned write_mask) 156 { 157 this->ir_type = ir_type_assignment; 158 this->condition = condition; 159 this->rhs = rhs; 160 this->lhs = lhs; 161 this->write_mask = write_mask; 162 163 if (lhs->type->is_scalar() || lhs->type->is_vector()) { 164 int lhs_components = 0; 165 for (int i = 0; i < 4; i++) { 166 if (write_mask & (1 << i)) 167 lhs_components++; 168 } 169 170 assert(lhs_components == this->rhs->type->vector_elements); 171 } 172 } 173 174 ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, 175 ir_rvalue *condition) 176 { 177 this->ir_type = ir_type_assignment; 178 this->condition = condition; 179 this->rhs = rhs; 180 181 /* If the RHS is a vector type, assume that all components of the vector 182 * type are being written to the LHS. The write mask comes from the RHS 183 * because we can have a case where the LHS is a vec4 and the RHS is a 184 * vec3. In that case, the assignment is: 185 * 186 * (assign (...) (xyz) (var_ref lhs) (var_ref rhs)) 187 */ 188 if (rhs->type->is_vector()) 189 this->write_mask = (1U << rhs->type->vector_elements) - 1; 190 else if (rhs->type->is_scalar()) 191 this->write_mask = 1; 192 else 193 this->write_mask = 0; 194 195 this->set_lhs(lhs); 196 } 197 198 199 ir_expression::ir_expression(int op, const struct glsl_type *type, 200 ir_rvalue *op0) 201 { 202 assert(get_num_operands(ir_expression_operation(op)) == 1); 203 this->ir_type = ir_type_expression; 204 this->type = type; 205 this->operation = ir_expression_operation(op); 206 this->operands[0] = op0; 207 this->operands[1] = NULL; 208 this->operands[2] = NULL; 209 this->operands[3] = NULL; 210 } 211 212 ir_expression::ir_expression(int op, const struct glsl_type *type, 213 ir_rvalue *op0, ir_rvalue *op1) 214 { 215 assert(((op1 == NULL) && (get_num_operands(ir_expression_operation(op)) == 1)) 216 || (get_num_operands(ir_expression_operation(op)) == 2)); 217 this->ir_type = ir_type_expression; 218 this->type = type; 219 this->operation = ir_expression_operation(op); 220 this->operands[0] = op0; 221 this->operands[1] = op1; 222 this->operands[2] = NULL; 223 this->operands[3] = NULL; 224 } 225 226 ir_expression::ir_expression(int op, const struct glsl_type *type, 227 ir_rvalue *op0, ir_rvalue *op1, 228 ir_rvalue *op2, ir_rvalue *op3) 229 { 230 this->ir_type = ir_type_expression; 231 this->type = type; 232 this->operation = ir_expression_operation(op); 233 this->operands[0] = op0; 234 this->operands[1] = op1; 235 this->operands[2] = op2; 236 this->operands[3] = op3; 237 } 238 239 ir_expression::ir_expression(int op, ir_rvalue *op0) 240 { 241 this->ir_type = ir_type_expression; 242 243 this->operation = ir_expression_operation(op); 244 this->operands[0] = op0; 245 this->operands[1] = NULL; 246 this->operands[2] = NULL; 247 this->operands[3] = NULL; 248 249 assert(op <= ir_last_unop); 250 251 switch (this->operation) { 252 case ir_unop_bit_not: 253 case ir_unop_logic_not: 254 case ir_unop_neg: 255 case ir_unop_abs: 256 case ir_unop_sign: 257 case ir_unop_rcp: 258 case ir_unop_rsq: 259 case ir_unop_sqrt: 260 case ir_unop_exp: 261 case ir_unop_log: 262 case ir_unop_exp2: 263 case ir_unop_log2: 264 case ir_unop_trunc: 265 case ir_unop_ceil: 266 case ir_unop_floor: 267 case ir_unop_fract: 268 case ir_unop_round_even: 269 case ir_unop_sin: 270 case ir_unop_cos: 271 case ir_unop_sin_reduced: 272 case ir_unop_cos_reduced: 273 case ir_unop_dFdx: 274 case ir_unop_dFdy: 275 this->type = op0->type; 276 break; 277 278 case ir_unop_f2i: 279 case ir_unop_b2i: 280 case ir_unop_u2i: 281 case ir_unop_bitcast_f2i: 282 this->type = glsl_type::get_instance(GLSL_TYPE_INT, 283 op0->type->vector_elements, 1); 284 break; 285 286 case ir_unop_b2f: 287 case ir_unop_i2f: 288 case ir_unop_u2f: 289 case ir_unop_bitcast_i2f: 290 case ir_unop_bitcast_u2f: 291 this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT, 292 op0->type->vector_elements, 1); 293 break; 294 295 case ir_unop_f2b: 296 case ir_unop_i2b: 297 this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, 298 op0->type->vector_elements, 1); 299 break; 300 301 case ir_unop_i2u: 302 case ir_unop_f2u: 303 case ir_unop_bitcast_f2u: 304 this->type = glsl_type::get_instance(GLSL_TYPE_UINT, 305 op0->type->vector_elements, 1); 306 break; 307 308 case ir_unop_noise: 309 this->type = glsl_type::float_type; 310 break; 311 312 case ir_unop_any: 313 this->type = glsl_type::bool_type; 314 break; 315 316 default: 317 assert(!"not reached: missing automatic type setup for ir_expression"); 318 this->type = op0->type; 319 break; 320 } 321 } 322 323 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1) 324 { 325 this->ir_type = ir_type_expression; 326 327 this->operation = ir_expression_operation(op); 328 this->operands[0] = op0; 329 this->operands[1] = op1; 330 this->operands[2] = NULL; 331 this->operands[3] = NULL; 332 333 assert(op > ir_last_unop); 334 335 switch (this->operation) { 336 case ir_binop_all_equal: 337 case ir_binop_any_nequal: 338 this->type = glsl_type::bool_type; 339 break; 340 341 case ir_binop_add: 342 case ir_binop_sub: 343 case ir_binop_min: 344 case ir_binop_max: 345 case ir_binop_pow: 346 case ir_binop_mul: 347 case ir_binop_div: 348 case ir_binop_mod: 349 if (op0->type->is_scalar()) { 350 this->type = op1->type; 351 } else if (op1->type->is_scalar()) { 352 this->type = op0->type; 353 } else { 354 /* FINISHME: matrix types */ 355 assert(!op0->type->is_matrix() && !op1->type->is_matrix()); 356 assert(op0->type == op1->type); 357 this->type = op0->type; 358 } 359 break; 360 361 case ir_binop_logic_and: 362 case ir_binop_logic_xor: 363 case ir_binop_logic_or: 364 case ir_binop_bit_and: 365 case ir_binop_bit_xor: 366 case ir_binop_bit_or: 367 if (op0->type->is_scalar()) { 368 this->type = op1->type; 369 } else if (op1->type->is_scalar()) { 370 this->type = op0->type; 371 } 372 break; 373 374 case ir_binop_equal: 375 case ir_binop_nequal: 376 case ir_binop_lequal: 377 case ir_binop_gequal: 378 case ir_binop_less: 379 case ir_binop_greater: 380 assert(op0->type == op1->type); 381 this->type = glsl_type::get_instance(GLSL_TYPE_BOOL, 382 op0->type->vector_elements, 1); 383 break; 384 385 case ir_binop_dot: 386 this->type = glsl_type::float_type; 387 break; 388 389 case ir_binop_lshift: 390 case ir_binop_rshift: 391 this->type = op0->type; 392 break; 393 394 default: 395 assert(!"not reached: missing automatic type setup for ir_expression"); 396 this->type = glsl_type::float_type; 397 } 398 } 399 400 unsigned int 401 ir_expression::get_num_operands(ir_expression_operation op) 402 { 403 assert(op <= ir_last_opcode); 404 405 if (op <= ir_last_unop) 406 return 1; 407 408 if (op <= ir_last_binop) 409 return 2; 410 411 if (op == ir_quadop_vector) 412 return 4; 413 414 assert(false); 415 return 0; 416 } 417 418 static const char *const operator_strs[] = { 419 "~", 420 "!", 421 "neg", 422 "abs", 423 "sign", 424 "rcp", 425 "rsq", 426 "sqrt", 427 "exp", 428 "log", 429 "exp2", 430 "log2", 431 "f2i", 432 "f2u", 433 "i2f", 434 "f2b", 435 "b2f", 436 "i2b", 437 "b2i", 438 "u2f", 439 "i2u", 440 "u2i", 441 "bitcast_i2f", 442 "bitcast_f2i", 443 "bitcast_u2f", 444 "bitcast_f2u", 445 "any", 446 "trunc", 447 "ceil", 448 "floor", 449 "fract", 450 "round_even", 451 "sin", 452 "cos", 453 "sin_reduced", 454 "cos_reduced", 455 "dFdx", 456 "dFdy", 457 "noise", 458 "+", 459 "-", 460 "*", 461 "/", 462 "%", 463 "<", 464 ">", 465 "<=", 466 ">=", 467 "==", 468 "!=", 469 "all_equal", 470 "any_nequal", 471 "<<", 472 ">>", 473 "&", 474 "^", 475 "|", 476 "&&", 477 "^^", 478 "||", 479 "dot", 480 "min", 481 "max", 482 "pow", 483 "ubo_load", 484 "vector", 485 }; 486 487 const char *ir_expression::operator_string(ir_expression_operation op) 488 { 489 assert((unsigned int) op < Elements(operator_strs)); 490 assert(Elements(operator_strs) == (ir_quadop_vector + 1)); 491 return operator_strs[op]; 492 } 493 494 const char *ir_expression::operator_string() 495 { 496 return operator_string(this->operation); 497 } 498 499 const char* 500 depth_layout_string(ir_depth_layout layout) 501 { 502 switch(layout) { 503 case ir_depth_layout_none: return ""; 504 case ir_depth_layout_any: return "depth_any"; 505 case ir_depth_layout_greater: return "depth_greater"; 506 case ir_depth_layout_less: return "depth_less"; 507 case ir_depth_layout_unchanged: return "depth_unchanged"; 508 509 default: 510 assert(0); 511 return ""; 512 } 513 } 514 515 ir_expression_operation 516 ir_expression::get_operator(const char *str) 517 { 518 const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]); 519 for (int op = 0; op < operator_count; op++) { 520 if (strcmp(str, operator_strs[op]) == 0) 521 return (ir_expression_operation) op; 522 } 523 return (ir_expression_operation) -1; 524 } 525 526 ir_constant::ir_constant() 527 { 528 this->ir_type = ir_type_constant; 529 } 530 531 ir_constant::ir_constant(const struct glsl_type *type, 532 const ir_constant_data *data) 533 { 534 assert((type->base_type >= GLSL_TYPE_UINT) 535 && (type->base_type <= GLSL_TYPE_BOOL)); 536 537 this->ir_type = ir_type_constant; 538 this->type = type; 539 memcpy(& this->value, data, sizeof(this->value)); 540 } 541 542 ir_constant::ir_constant(float f) 543 { 544 this->ir_type = ir_type_constant; 545 this->type = glsl_type::float_type; 546 this->value.f[0] = f; 547 for (int i = 1; i < 16; i++) { 548 this->value.f[i] = 0; 549 } 550 } 551 552 ir_constant::ir_constant(unsigned int u) 553 { 554 this->ir_type = ir_type_constant; 555 this->type = glsl_type::uint_type; 556 this->value.u[0] = u; 557 for (int i = 1; i < 16; i++) { 558 this->value.u[i] = 0; 559 } 560 } 561 562 ir_constant::ir_constant(int i) 563 { 564 this->ir_type = ir_type_constant; 565 this->type = glsl_type::int_type; 566 this->value.i[0] = i; 567 for (int i = 1; i < 16; i++) { 568 this->value.i[i] = 0; 569 } 570 } 571 572 ir_constant::ir_constant(bool b) 573 { 574 this->ir_type = ir_type_constant; 575 this->type = glsl_type::bool_type; 576 this->value.b[0] = b; 577 for (int i = 1; i < 16; i++) { 578 this->value.b[i] = false; 579 } 580 } 581 582 ir_constant::ir_constant(const ir_constant *c, unsigned i) 583 { 584 this->ir_type = ir_type_constant; 585 this->type = c->type->get_base_type(); 586 587 switch (this->type->base_type) { 588 case GLSL_TYPE_UINT: this->value.u[0] = c->value.u[i]; break; 589 case GLSL_TYPE_INT: this->value.i[0] = c->value.i[i]; break; 590 case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break; 591 case GLSL_TYPE_BOOL: this->value.b[0] = c->value.b[i]; break; 592 default: assert(!"Should not get here."); break; 593 } 594 } 595 596 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list) 597 { 598 this->ir_type = ir_type_constant; 599 this->type = type; 600 601 assert(type->is_scalar() || type->is_vector() || type->is_matrix() 602 || type->is_record() || type->is_array()); 603 604 if (type->is_array()) { 605 this->array_elements = ralloc_array(this, ir_constant *, type->length); 606 unsigned i = 0; 607 foreach_list(node, value_list) { 608 ir_constant *value = (ir_constant *) node; 609 assert(value->as_constant() != NULL); 610 611 this->array_elements[i++] = value; 612 } 613 return; 614 } 615 616 /* If the constant is a record, the types of each of the entries in 617 * value_list must be a 1-for-1 match with the structure components. Each 618 * entry must also be a constant. Just move the nodes from the value_list 619 * to the list in the ir_constant. 620 */ 621 /* FINISHME: Should there be some type checking and / or assertions here? */ 622 /* FINISHME: Should the new constant take ownership of the nodes from 623 * FINISHME: value_list, or should it make copies? 624 */ 625 if (type->is_record()) { 626 value_list->move_nodes_to(& this->components); 627 return; 628 } 629 630 for (unsigned i = 0; i < 16; i++) { 631 this->value.u[i] = 0; 632 } 633 634 ir_constant *value = (ir_constant *) (value_list->head); 635 636 /* Constructors with exactly one scalar argument are special for vectors 637 * and matrices. For vectors, the scalar value is replicated to fill all 638 * the components. For matrices, the scalar fills the components of the 639 * diagonal while the rest is filled with 0. 640 */ 641 if (value->type->is_scalar() && value->next->is_tail_sentinel()) { 642 if (type->is_matrix()) { 643 /* Matrix - fill diagonal (rest is already set to 0) */ 644 assert(type->base_type == GLSL_TYPE_FLOAT); 645 for (unsigned i = 0; i < type->matrix_columns; i++) 646 this->value.f[i * type->vector_elements + i] = value->value.f[0]; 647 } else { 648 /* Vector or scalar - fill all components */ 649 switch (type->base_type) { 650 case GLSL_TYPE_UINT: 651 case GLSL_TYPE_INT: 652 for (unsigned i = 0; i < type->components(); i++) 653 this->value.u[i] = value->value.u[0]; 654 break; 655 case GLSL_TYPE_FLOAT: 656 for (unsigned i = 0; i < type->components(); i++) 657 this->value.f[i] = value->value.f[0]; 658 break; 659 case GLSL_TYPE_BOOL: 660 for (unsigned i = 0; i < type->components(); i++) 661 this->value.b[i] = value->value.b[0]; 662 break; 663 default: 664 assert(!"Should not get here."); 665 break; 666 } 667 } 668 return; 669 } 670 671 if (type->is_matrix() && value->type->is_matrix()) { 672 assert(value->next->is_tail_sentinel()); 673 674 /* From section 5.4.2 of the GLSL 1.20 spec: 675 * "If a matrix is constructed from a matrix, then each component 676 * (column i, row j) in the result that has a corresponding component 677 * (column i, row j) in the argument will be initialized from there." 678 */ 679 unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns); 680 unsigned rows = MIN2(type->vector_elements, value->type->vector_elements); 681 for (unsigned i = 0; i < cols; i++) { 682 for (unsigned j = 0; j < rows; j++) { 683 const unsigned src = i * value->type->vector_elements + j; 684 const unsigned dst = i * type->vector_elements + j; 685 this->value.f[dst] = value->value.f[src]; 686 } 687 } 688 689 /* "All other components will be initialized to the identity matrix." */ 690 for (unsigned i = cols; i < type->matrix_columns; i++) 691 this->value.f[i * type->vector_elements + i] = 1.0; 692 693 return; 694 } 695 696 /* Use each component from each entry in the value_list to initialize one 697 * component of the constant being constructed. 698 */ 699 for (unsigned i = 0; i < type->components(); /* empty */) { 700 assert(value->as_constant() != NULL); 701 assert(!value->is_tail_sentinel()); 702 703 for (unsigned j = 0; j < value->type->components(); j++) { 704 switch (type->base_type) { 705 case GLSL_TYPE_UINT: 706 this->value.u[i] = value->get_uint_component(j); 707 break; 708 case GLSL_TYPE_INT: 709 this->value.i[i] = value->get_int_component(j); 710 break; 711 case GLSL_TYPE_FLOAT: 712 this->value.f[i] = value->get_float_component(j); 713 break; 714 case GLSL_TYPE_BOOL: 715 this->value.b[i] = value->get_bool_component(j); 716 break; 717 default: 718 /* FINISHME: What to do? Exceptions are not the answer. 719 */ 720 break; 721 } 722 723 i++; 724 if (i >= type->components()) 725 break; 726 } 727 728 value = (ir_constant *) value->next; 729 } 730 } 731 732 ir_constant * 733 ir_constant::zero(void *mem_ctx, const glsl_type *type) 734 { 735 assert(type->is_scalar() || type->is_vector() || type->is_matrix() 736 || type->is_record() || type->is_array()); 737 738 ir_constant *c = new(mem_ctx) ir_constant; 739 c->type = type; 740 memset(&c->value, 0, sizeof(c->value)); 741 742 if (type->is_array()) { 743 c->array_elements = ralloc_array(c, ir_constant *, type->length); 744 745 for (unsigned i = 0; i < type->length; i++) 746 c->array_elements[i] = ir_constant::zero(c, type->element_type()); 747 } 748 749 if (type->is_record()) { 750 for (unsigned i = 0; i < type->length; i++) { 751 ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type); 752 c->components.push_tail(comp); 753 } 754 } 755 756 return c; 757 } 758 759 bool 760 ir_constant::get_bool_component(unsigned i) const 761 { 762 switch (this->type->base_type) { 763 case GLSL_TYPE_UINT: return this->value.u[i] != 0; 764 case GLSL_TYPE_INT: return this->value.i[i] != 0; 765 case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0; 766 case GLSL_TYPE_BOOL: return this->value.b[i]; 767 default: assert(!"Should not get here."); break; 768 } 769 770 /* Must return something to make the compiler happy. This is clearly an 771 * error case. 772 */ 773 return false; 774 } 775 776 float 777 ir_constant::get_float_component(unsigned i) const 778 { 779 switch (this->type->base_type) { 780 case GLSL_TYPE_UINT: return (float) this->value.u[i]; 781 case GLSL_TYPE_INT: return (float) this->value.i[i]; 782 case GLSL_TYPE_FLOAT: return this->value.f[i]; 783 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0; 784 default: assert(!"Should not get here."); break; 785 } 786 787 /* Must return something to make the compiler happy. This is clearly an 788 * error case. 789 */ 790 return 0.0; 791 } 792 793 int 794 ir_constant::get_int_component(unsigned i) const 795 { 796 switch (this->type->base_type) { 797 case GLSL_TYPE_UINT: return this->value.u[i]; 798 case GLSL_TYPE_INT: return this->value.i[i]; 799 case GLSL_TYPE_FLOAT: return (int) this->value.f[i]; 800 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0; 801 default: assert(!"Should not get here."); break; 802 } 803 804 /* Must return something to make the compiler happy. This is clearly an 805 * error case. 806 */ 807 return 0; 808 } 809 810 unsigned 811 ir_constant::get_uint_component(unsigned i) const 812 { 813 switch (this->type->base_type) { 814 case GLSL_TYPE_UINT: return this->value.u[i]; 815 case GLSL_TYPE_INT: return this->value.i[i]; 816 case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i]; 817 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0; 818 default: assert(!"Should not get here."); break; 819 } 820 821 /* Must return something to make the compiler happy. This is clearly an 822 * error case. 823 */ 824 return 0; 825 } 826 827 ir_constant * 828 ir_constant::get_array_element(unsigned i) const 829 { 830 assert(this->type->is_array()); 831 832 /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec: 833 * 834 * "Behavior is undefined if a shader subscripts an array with an index 835 * less than 0 or greater than or equal to the size the array was 836 * declared with." 837 * 838 * Most out-of-bounds accesses are removed before things could get this far. 839 * There are cases where non-constant array index values can get constant 840 * folded. 841 */ 842 if (int(i) < 0) 843 i = 0; 844 else if (i >= this->type->length) 845 i = this->type->length - 1; 846 847 return array_elements[i]; 848 } 849 850 ir_constant * 851 ir_constant::get_record_field(const char *name) 852 { 853 int idx = this->type->field_index(name); 854 855 if (idx < 0) 856 return NULL; 857 858 if (this->components.is_empty()) 859 return NULL; 860 861 exec_node *node = this->components.head; 862 for (int i = 0; i < idx; i++) { 863 node = node->next; 864 865 /* If the end of the list is encountered before the element matching the 866 * requested field is found, return NULL. 867 */ 868 if (node->is_tail_sentinel()) 869 return NULL; 870 } 871 872 return (ir_constant *) node; 873 } 874 875 void 876 ir_constant::copy_offset(ir_constant *src, int offset) 877 { 878 switch (this->type->base_type) { 879 case GLSL_TYPE_UINT: 880 case GLSL_TYPE_INT: 881 case GLSL_TYPE_FLOAT: 882 case GLSL_TYPE_BOOL: { 883 unsigned int size = src->type->components(); 884 assert (size <= this->type->components() - offset); 885 for (unsigned int i=0; i<size; i++) { 886 switch (this->type->base_type) { 887 case GLSL_TYPE_UINT: 888 value.u[i+offset] = src->get_uint_component(i); 889 break; 890 case GLSL_TYPE_INT: 891 value.i[i+offset] = src->get_int_component(i); 892 break; 893 case GLSL_TYPE_FLOAT: 894 value.f[i+offset] = src->get_float_component(i); 895 break; 896 case GLSL_TYPE_BOOL: 897 value.b[i+offset] = src->get_bool_component(i); 898 break; 899 default: // Shut up the compiler 900 break; 901 } 902 } 903 break; 904 } 905 906 case GLSL_TYPE_STRUCT: { 907 assert (src->type == this->type); 908 this->components.make_empty(); 909 foreach_list(node, &src->components) { 910 ir_constant *const orig = (ir_constant *) node; 911 912 this->components.push_tail(orig->clone(this, NULL)); 913 } 914 break; 915 } 916 917 case GLSL_TYPE_ARRAY: { 918 assert (src->type == this->type); 919 for (unsigned i = 0; i < this->type->length; i++) { 920 this->array_elements[i] = src->array_elements[i]->clone(this, NULL); 921 } 922 break; 923 } 924 925 default: 926 assert(!"Should not get here."); 927 break; 928 } 929 } 930 931 void 932 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask) 933 { 934 assert (!type->is_array() && !type->is_record()); 935 936 if (!type->is_vector() && !type->is_matrix()) { 937 offset = 0; 938 mask = 1; 939 } 940 941 int id = 0; 942 for (int i=0; i<4; i++) { 943 if (mask & (1 << i)) { 944 switch (this->type->base_type) { 945 case GLSL_TYPE_UINT: 946 value.u[i+offset] = src->get_uint_component(id++); 947 break; 948 case GLSL_TYPE_INT: 949 value.i[i+offset] = src->get_int_component(id++); 950 break; 951 case GLSL_TYPE_FLOAT: 952 value.f[i+offset] = src->get_float_component(id++); 953 break; 954 case GLSL_TYPE_BOOL: 955 value.b[i+offset] = src->get_bool_component(id++); 956 break; 957 default: 958 assert(!"Should not get here."); 959 return; 960 } 961 } 962 } 963 } 964 965 bool 966 ir_constant::has_value(const ir_constant *c) const 967 { 968 if (this->type != c->type) 969 return false; 970 971 if (this->type->is_array()) { 972 for (unsigned i = 0; i < this->type->length; i++) { 973 if (!this->array_elements[i]->has_value(c->array_elements[i])) 974 return false; 975 } 976 return true; 977 } 978 979 if (this->type->base_type == GLSL_TYPE_STRUCT) { 980 const exec_node *a_node = this->components.head; 981 const exec_node *b_node = c->components.head; 982 983 while (!a_node->is_tail_sentinel()) { 984 assert(!b_node->is_tail_sentinel()); 985 986 const ir_constant *const a_field = (ir_constant *) a_node; 987 const ir_constant *const b_field = (ir_constant *) b_node; 988 989 if (!a_field->has_value(b_field)) 990 return false; 991 992 a_node = a_node->next; 993 b_node = b_node->next; 994 } 995 996 return true; 997 } 998 999 for (unsigned i = 0; i < this->type->components(); i++) { 1000 switch (this->type->base_type) { 1001 case GLSL_TYPE_UINT: 1002 if (this->value.u[i] != c->value.u[i]) 1003 return false; 1004 break; 1005 case GLSL_TYPE_INT: 1006 if (this->value.i[i] != c->value.i[i]) 1007 return false; 1008 break; 1009 case GLSL_TYPE_FLOAT: 1010 if (this->value.f[i] != c->value.f[i]) 1011 return false; 1012 break; 1013 case GLSL_TYPE_BOOL: 1014 if (this->value.b[i] != c->value.b[i]) 1015 return false; 1016 break; 1017 default: 1018 assert(!"Should not get here."); 1019 return false; 1020 } 1021 } 1022 1023 return true; 1024 } 1025 1026 bool 1027 ir_constant::is_zero() const 1028 { 1029 if (!this->type->is_scalar() && !this->type->is_vector()) 1030 return false; 1031 1032 for (unsigned c = 0; c < this->type->vector_elements; c++) { 1033 switch (this->type->base_type) { 1034 case GLSL_TYPE_FLOAT: 1035 if (this->value.f[c] != 0.0) 1036 return false; 1037 break; 1038 case GLSL_TYPE_INT: 1039 if (this->value.i[c] != 0) 1040 return false; 1041 break; 1042 case GLSL_TYPE_UINT: 1043 if (this->value.u[c] != 0) 1044 return false; 1045 break; 1046 case GLSL_TYPE_BOOL: 1047 if (this->value.b[c] != false) 1048 return false; 1049 break; 1050 default: 1051 /* The only other base types are structures, arrays, and samplers. 1052 * Samplers cannot be constants, and the others should have been 1053 * filtered out above. 1054 */ 1055 assert(!"Should not get here."); 1056 return false; 1057 } 1058 } 1059 1060 return true; 1061 } 1062 1063 bool 1064 ir_constant::is_one() const 1065 { 1066 if (!this->type->is_scalar() && !this->type->is_vector()) 1067 return false; 1068 1069 for (unsigned c = 0; c < this->type->vector_elements; c++) { 1070 switch (this->type->base_type) { 1071 case GLSL_TYPE_FLOAT: 1072 if (this->value.f[c] != 1.0) 1073 return false; 1074 break; 1075 case GLSL_TYPE_INT: 1076 if (this->value.i[c] != 1) 1077 return false; 1078 break; 1079 case GLSL_TYPE_UINT: 1080 if (this->value.u[c] != 1) 1081 return false; 1082 break; 1083 case GLSL_TYPE_BOOL: 1084 if (this->value.b[c] != true) 1085 return false; 1086 break; 1087 default: 1088 /* The only other base types are structures, arrays, and samplers. 1089 * Samplers cannot be constants, and the others should have been 1090 * filtered out above. 1091 */ 1092 assert(!"Should not get here."); 1093 return false; 1094 } 1095 } 1096 1097 return true; 1098 } 1099 1100 bool 1101 ir_constant::is_negative_one() const 1102 { 1103 if (!this->type->is_scalar() && !this->type->is_vector()) 1104 return false; 1105 1106 if (this->type->is_boolean()) 1107 return false; 1108 1109 for (unsigned c = 0; c < this->type->vector_elements; c++) { 1110 switch (this->type->base_type) { 1111 case GLSL_TYPE_FLOAT: 1112 if (this->value.f[c] != -1.0) 1113 return false; 1114 break; 1115 case GLSL_TYPE_INT: 1116 if (this->value.i[c] != -1) 1117 return false; 1118 break; 1119 case GLSL_TYPE_UINT: 1120 if (int(this->value.u[c]) != -1) 1121 return false; 1122 break; 1123 default: 1124 /* The only other base types are structures, arrays, samplers, and 1125 * booleans. Samplers cannot be constants, and the others should 1126 * have been filtered out above. 1127 */ 1128 assert(!"Should not get here."); 1129 return false; 1130 } 1131 } 1132 1133 return true; 1134 } 1135 1136 bool 1137 ir_constant::is_basis() const 1138 { 1139 if (!this->type->is_scalar() && !this->type->is_vector()) 1140 return false; 1141 1142 if (this->type->is_boolean()) 1143 return false; 1144 1145 unsigned ones = 0; 1146 for (unsigned c = 0; c < this->type->vector_elements; c++) { 1147 switch (this->type->base_type) { 1148 case GLSL_TYPE_FLOAT: 1149 if (this->value.f[c] == 1.0) 1150 ones++; 1151 else if (this->value.f[c] != 0.0) 1152 return false; 1153 break; 1154 case GLSL_TYPE_INT: 1155 if (this->value.i[c] == 1) 1156 ones++; 1157 else if (this->value.i[c] != 0) 1158 return false; 1159 break; 1160 case GLSL_TYPE_UINT: 1161 if (int(this->value.u[c]) == 1) 1162 ones++; 1163 else if (int(this->value.u[c]) != 0) 1164 return false; 1165 break; 1166 default: 1167 /* The only other base types are structures, arrays, samplers, and 1168 * booleans. Samplers cannot be constants, and the others should 1169 * have been filtered out above. 1170 */ 1171 assert(!"Should not get here."); 1172 return false; 1173 } 1174 } 1175 1176 return ones == 1; 1177 } 1178 1179 ir_loop::ir_loop() 1180 { 1181 this->ir_type = ir_type_loop; 1182 this->cmp = ir_unop_neg; 1183 this->from = NULL; 1184 this->to = NULL; 1185 this->increment = NULL; 1186 this->counter = NULL; 1187 } 1188 1189 1190 ir_dereference_variable::ir_dereference_variable(ir_variable *var) 1191 { 1192 assert(var != NULL); 1193 1194 this->ir_type = ir_type_dereference_variable; 1195 this->var = var; 1196 this->type = var->type; 1197 } 1198 1199 1200 ir_dereference_array::ir_dereference_array(ir_rvalue *value, 1201 ir_rvalue *array_index) 1202 { 1203 this->ir_type = ir_type_dereference_array; 1204 this->array_index = array_index; 1205 this->set_array(value); 1206 } 1207 1208 1209 ir_dereference_array::ir_dereference_array(ir_variable *var, 1210 ir_rvalue *array_index) 1211 { 1212 void *ctx = ralloc_parent(var); 1213 1214 this->ir_type = ir_type_dereference_array; 1215 this->array_index = array_index; 1216 this->set_array(new(ctx) ir_dereference_variable(var)); 1217 } 1218 1219 1220 void 1221 ir_dereference_array::set_array(ir_rvalue *value) 1222 { 1223 assert(value != NULL); 1224 1225 this->array = value; 1226 1227 const glsl_type *const vt = this->array->type; 1228 1229 if (vt->is_array()) { 1230 type = vt->element_type(); 1231 } else if (vt->is_matrix()) { 1232 type = vt->column_type(); 1233 } else if (vt->is_vector()) { 1234 type = vt->get_base_type(); 1235 } 1236 } 1237 1238 1239 ir_dereference_record::ir_dereference_record(ir_rvalue *value, 1240 const char *field) 1241 { 1242 assert(value != NULL); 1243 1244 this->ir_type = ir_type_dereference_record; 1245 this->record = value; 1246 this->field = ralloc_strdup(this, field); 1247 this->type = this->record->type->field_type(field); 1248 } 1249 1250 1251 ir_dereference_record::ir_dereference_record(ir_variable *var, 1252 const char *field) 1253 { 1254 void *ctx = ralloc_parent(var); 1255 1256 this->ir_type = ir_type_dereference_record; 1257 this->record = new(ctx) ir_dereference_variable(var); 1258 this->field = ralloc_strdup(this, field); 1259 this->type = this->record->type->field_type(field); 1260 } 1261 1262 bool 1263 ir_dereference::is_lvalue() const 1264 { 1265 ir_variable *var = this->variable_referenced(); 1266 1267 /* Every l-value derference chain eventually ends in a variable. 1268 */ 1269 if ((var == NULL) || var->read_only) 1270 return false; 1271 1272 /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec: 1273 * 1274 * "Samplers cannot be treated as l-values; hence cannot be used 1275 * as out or inout function parameters, nor can they be 1276 * assigned into." 1277 */ 1278 if (this->type->contains_sampler()) 1279 return false; 1280 1281 return true; 1282 } 1283 1284 1285 const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txs" }; 1286 1287 const char *ir_texture::opcode_string() 1288 { 1289 assert((unsigned int) op <= 1290 sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0])); 1291 return tex_opcode_strs[op]; 1292 } 1293 1294 ir_texture_opcode 1295 ir_texture::get_opcode(const char *str) 1296 { 1297 const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]); 1298 for (int op = 0; op < count; op++) { 1299 if (strcmp(str, tex_opcode_strs[op]) == 0) 1300 return (ir_texture_opcode) op; 1301 } 1302 return (ir_texture_opcode) -1; 1303 } 1304 1305 1306 void 1307 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type) 1308 { 1309 assert(sampler != NULL); 1310 assert(type != NULL); 1311 this->sampler = sampler; 1312 this->type = type; 1313 1314 if (this->op == ir_txs) { 1315 assert(type->base_type == GLSL_TYPE_INT); 1316 } else { 1317 assert(sampler->type->sampler_type == (int) type->base_type); 1318 if (sampler->type->sampler_shadow) 1319 assert(type->vector_elements == 4 || type->vector_elements == 1); 1320 else 1321 assert(type->vector_elements == 4); 1322 } 1323 } 1324 1325 1326 void 1327 ir_swizzle::init_mask(const unsigned *comp, unsigned count) 1328 { 1329 assert((count >= 1) && (count <= 4)); 1330 1331 memset(&this->mask, 0, sizeof(this->mask)); 1332 this->mask.num_components = count; 1333 1334 unsigned dup_mask = 0; 1335 switch (count) { 1336 case 4: 1337 assert(comp[3] <= 3); 1338 dup_mask |= (1U << comp[3]) 1339 & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2])); 1340 this->mask.w = comp[3]; 1341 1342 case 3: 1343 assert(comp[2] <= 3); 1344 dup_mask |= (1U << comp[2]) 1345 & ((1U << comp[0]) | (1U << comp[1])); 1346 this->mask.z = comp[2]; 1347 1348 case 2: 1349 assert(comp[1] <= 3); 1350 dup_mask |= (1U << comp[1]) 1351 & ((1U << comp[0])); 1352 this->mask.y = comp[1]; 1353 1354 case 1: 1355 assert(comp[0] <= 3); 1356 this->mask.x = comp[0]; 1357 } 1358 1359 this->mask.has_duplicates = dup_mask != 0; 1360 1361 /* Based on the number of elements in the swizzle and the base type 1362 * (i.e., float, int, unsigned, or bool) of the vector being swizzled, 1363 * generate the type of the resulting value. 1364 */ 1365 type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1); 1366 } 1367 1368 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z, 1369 unsigned w, unsigned count) 1370 : val(val) 1371 { 1372 const unsigned components[4] = { x, y, z, w }; 1373 this->ir_type = ir_type_swizzle; 1374 this->init_mask(components, count); 1375 } 1376 1377 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp, 1378 unsigned count) 1379 : val(val) 1380 { 1381 this->ir_type = ir_type_swizzle; 1382 this->init_mask(comp, count); 1383 } 1384 1385 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask) 1386 { 1387 this->ir_type = ir_type_swizzle; 1388 this->val = val; 1389 this->mask = mask; 1390 this->type = glsl_type::get_instance(val->type->base_type, 1391 mask.num_components, 1); 1392 } 1393 1394 #define X 1 1395 #define R 5 1396 #define S 9 1397 #define I 13 1398 1399 ir_swizzle * 1400 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length) 1401 { 1402 void *ctx = ralloc_parent(val); 1403 1404 /* For each possible swizzle character, this table encodes the value in 1405 * \c idx_map that represents the 0th element of the vector. For invalid 1406 * swizzle characters (e.g., 'k'), a special value is used that will allow 1407 * detection of errors. 1408 */ 1409 static const unsigned char base_idx[26] = { 1410 /* a b c d e f g h i j k l m */ 1411 R, R, I, I, I, I, R, I, I, I, I, I, I, 1412 /* n o p q r s t u v w x y z */ 1413 I, I, S, S, R, S, S, I, I, X, X, X, X 1414 }; 1415 1416 /* Each valid swizzle character has an entry in the previous table. This 1417 * table encodes the base index encoded in the previous table plus the actual 1418 * index of the swizzle character. When processing swizzles, the first 1419 * character in the string is indexed in the previous table. Each character 1420 * in the string is indexed in this table, and the value found there has the 1421 * value form the first table subtracted. The result must be on the range 1422 * [0,3]. 1423 * 1424 * For example, the string "wzyx" will get X from the first table. Each of 1425 * the charcaters will get X+3, X+2, X+1, and X+0 from this table. After 1426 * subtraction, the swizzle values are { 3, 2, 1, 0 }. 1427 * 1428 * The string "wzrg" will get X from the first table. Each of the characters 1429 * will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the 1430 * swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range 1431 * [0,3], the error is detected. 1432 */ 1433 static const unsigned char idx_map[26] = { 1434 /* a b c d e f g h i j k l m */ 1435 R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0, 1436 /* n o p q r s t u v w x y z */ 1437 0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2 1438 }; 1439 1440 int swiz_idx[4] = { 0, 0, 0, 0 }; 1441 unsigned i; 1442 1443 1444 /* Validate the first character in the swizzle string and look up the base 1445 * index value as described above. 1446 */ 1447 if ((str[0] < 'a') || (str[0] > 'z')) 1448 return NULL; 1449 1450 const unsigned base = base_idx[str[0] - 'a']; 1451 1452 1453 for (i = 0; (i < 4) && (str[i] != '\0'); i++) { 1454 /* Validate the next character, and, as described above, convert it to a 1455 * swizzle index. 1456 */ 1457 if ((str[i] < 'a') || (str[i] > 'z')) 1458 return NULL; 1459 1460 swiz_idx[i] = idx_map[str[i] - 'a'] - base; 1461 if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length)) 1462 return NULL; 1463 } 1464 1465 if (str[i] != '\0') 1466 return NULL; 1467 1468 return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2], 1469 swiz_idx[3], i); 1470 } 1471 1472 #undef X 1473 #undef R 1474 #undef S 1475 #undef I 1476 1477 ir_variable * 1478 ir_swizzle::variable_referenced() const 1479 { 1480 return this->val->variable_referenced(); 1481 } 1482 1483 1484 ir_variable::ir_variable(const struct glsl_type *type, const char *name, 1485 ir_variable_mode mode) 1486 : max_array_access(0), read_only(false), centroid(false), invariant(false), 1487 mode(mode), interpolation(INTERP_QUALIFIER_NONE) 1488 { 1489 this->ir_type = ir_type_variable; 1490 this->type = type; 1491 this->name = ralloc_strdup(this, name); 1492 this->explicit_location = false; 1493 this->has_initializer = false; 1494 this->location = -1; 1495 this->uniform_block = -1; 1496 this->warn_extension = NULL; 1497 this->constant_value = NULL; 1498 this->constant_initializer = NULL; 1499 this->origin_upper_left = false; 1500 this->pixel_center_integer = false; 1501 this->depth_layout = ir_depth_layout_none; 1502 this->used = false; 1503 1504 if (type && type->base_type == GLSL_TYPE_SAMPLER) 1505 this->read_only = true; 1506 } 1507 1508 1509 const char * 1510 ir_variable::interpolation_string() const 1511 { 1512 switch (this->interpolation) { 1513 case INTERP_QUALIFIER_NONE: return "no"; 1514 case INTERP_QUALIFIER_SMOOTH: return "smooth"; 1515 case INTERP_QUALIFIER_FLAT: return "flat"; 1516 case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective"; 1517 } 1518 1519 assert(!"Should not get here."); 1520 return ""; 1521 } 1522 1523 1524 glsl_interp_qualifier 1525 ir_variable::determine_interpolation_mode(bool flat_shade) 1526 { 1527 if (this->interpolation != INTERP_QUALIFIER_NONE) 1528 return (glsl_interp_qualifier) this->interpolation; 1529 int location = this->location; 1530 bool is_gl_Color = 1531 location == FRAG_ATTRIB_COL0 || location == FRAG_ATTRIB_COL1; 1532 if (flat_shade && is_gl_Color) 1533 return INTERP_QUALIFIER_FLAT; 1534 else 1535 return INTERP_QUALIFIER_SMOOTH; 1536 } 1537 1538 1539 ir_function_signature::ir_function_signature(const glsl_type *return_type) 1540 : return_type(return_type), is_defined(false), _function(NULL) 1541 { 1542 this->ir_type = ir_type_function_signature; 1543 this->is_builtin = false; 1544 this->origin = NULL; 1545 } 1546 1547 1548 static bool 1549 modes_match(unsigned a, unsigned b) 1550 { 1551 if (a == b) 1552 return true; 1553 1554 /* Accept "in" vs. "const in" */ 1555 if ((a == ir_var_const_in && b == ir_var_in) || 1556 (b == ir_var_const_in && a == ir_var_in)) 1557 return true; 1558 1559 return false; 1560 } 1561 1562 1563 const char * 1564 ir_function_signature::qualifiers_match(exec_list *params) 1565 { 1566 exec_list_iterator iter_a = parameters.iterator(); 1567 exec_list_iterator iter_b = params->iterator(); 1568 1569 /* check that the qualifiers match. */ 1570 while (iter_a.has_next()) { 1571 ir_variable *a = (ir_variable *)iter_a.get(); 1572 ir_variable *b = (ir_variable *)iter_b.get(); 1573 1574 if (a->read_only != b->read_only || 1575 !modes_match(a->mode, b->mode) || 1576 a->interpolation != b->interpolation || 1577 a->centroid != b->centroid) { 1578 1579 /* parameter a's qualifiers don't match */ 1580 return a->name; 1581 } 1582 1583 iter_a.next(); 1584 iter_b.next(); 1585 } 1586 return NULL; 1587 } 1588 1589 1590 void 1591 ir_function_signature::replace_parameters(exec_list *new_params) 1592 { 1593 /* Destroy all of the previous parameter information. If the previous 1594 * parameter information comes from the function prototype, it may either 1595 * specify incorrect parameter names or not have names at all. 1596 */ 1597 foreach_iter(exec_list_iterator, iter, parameters) { 1598 assert(((ir_instruction *) iter.get())->as_variable() != NULL); 1599 1600 iter.remove(); 1601 } 1602 1603 new_params->move_nodes_to(¶meters); 1604 } 1605 1606 1607 ir_function::ir_function(const char *name) 1608 { 1609 this->ir_type = ir_type_function; 1610 this->name = ralloc_strdup(this, name); 1611 } 1612 1613 1614 bool 1615 ir_function::has_user_signature() 1616 { 1617 foreach_list(n, &this->signatures) { 1618 ir_function_signature *const sig = (ir_function_signature *) n; 1619 if (!sig->is_builtin) 1620 return true; 1621 } 1622 return false; 1623 } 1624 1625 1626 ir_rvalue * 1627 ir_rvalue::error_value(void *mem_ctx) 1628 { 1629 ir_rvalue *v = new(mem_ctx) ir_rvalue; 1630 1631 v->type = glsl_type::error_type; 1632 return v; 1633 } 1634 1635 1636 void 1637 visit_exec_list(exec_list *list, ir_visitor *visitor) 1638 { 1639 foreach_iter(exec_list_iterator, iter, *list) { 1640 ((ir_instruction *)iter.get())->accept(visitor); 1641 } 1642 } 1643 1644 1645 static void 1646 steal_memory(ir_instruction *ir, void *new_ctx) 1647 { 1648 ir_variable *var = ir->as_variable(); 1649 ir_constant *constant = ir->as_constant(); 1650 if (var != NULL && var->constant_value != NULL) 1651 steal_memory(var->constant_value, ir); 1652 1653 if (var != NULL && var->constant_initializer != NULL) 1654 steal_memory(var->constant_initializer, ir); 1655 1656 /* The components of aggregate constants are not visited by the normal 1657 * visitor, so steal their values by hand. 1658 */ 1659 if (constant != NULL) { 1660 if (constant->type->is_record()) { 1661 foreach_iter(exec_list_iterator, iter, constant->components) { 1662 ir_constant *field = (ir_constant *)iter.get(); 1663 steal_memory(field, ir); 1664 } 1665 } else if (constant->type->is_array()) { 1666 for (unsigned int i = 0; i < constant->type->length; i++) { 1667 steal_memory(constant->array_elements[i], ir); 1668 } 1669 } 1670 } 1671 1672 ralloc_steal(new_ctx, ir); 1673 } 1674 1675 1676 void 1677 reparent_ir(exec_list *list, void *mem_ctx) 1678 { 1679 foreach_list(node, list) { 1680 visit_tree((ir_instruction *) node, steal_memory, mem_ctx); 1681 } 1682 } 1683 1684 1685 static ir_rvalue * 1686 try_min_one(ir_rvalue *ir) 1687 { 1688 ir_expression *expr = ir->as_expression(); 1689 1690 if (!expr || expr->operation != ir_binop_min) 1691 return NULL; 1692 1693 if (expr->operands[0]->is_one()) 1694 return expr->operands[1]; 1695 1696 if (expr->operands[1]->is_one()) 1697 return expr->operands[0]; 1698 1699 return NULL; 1700 } 1701 1702 static ir_rvalue * 1703 try_max_zero(ir_rvalue *ir) 1704 { 1705 ir_expression *expr = ir->as_expression(); 1706 1707 if (!expr || expr->operation != ir_binop_max) 1708 return NULL; 1709 1710 if (expr->operands[0]->is_zero()) 1711 return expr->operands[1]; 1712 1713 if (expr->operands[1]->is_zero()) 1714 return expr->operands[0]; 1715 1716 return NULL; 1717 } 1718 1719 ir_rvalue * 1720 ir_rvalue::as_rvalue_to_saturate() 1721 { 1722 ir_expression *expr = this->as_expression(); 1723 1724 if (!expr) 1725 return NULL; 1726 1727 ir_rvalue *max_zero = try_max_zero(expr); 1728 if (max_zero) { 1729 return try_min_one(max_zero); 1730 } else { 1731 ir_rvalue *min_one = try_min_one(expr); 1732 if (min_one) { 1733 return try_max_zero(min_one); 1734 } 1735 } 1736 1737 return NULL; 1738 } 1739
