src/compiler/glsl/ir.cpp

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