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