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