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