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