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