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->base_type == GLSL_TYPE_FLOAT ||
 787                 type->is_double());
 788          for (unsigned i = 0; i < type->matrix_columns; i++) {
 789             if (type->base_type == GLSL_TYPE_FLOAT)
 790                this->value.f[i * type->vector_elements + i] =
 791                   value->value.f[0];
 792             else
 793                this->value.d[i * type->vector_elements + i] =
 794                   value->value.d[0];
 795          }
 796       } else {
 797          /* Vector or scalar - fill all components */
 798          switch (type->base_type) {
 799          case GLSL_TYPE_UINT:
 800          case GLSL_TYPE_INT:
 801             for (unsigned i = 0; i < type->components(); i++)
 802                this->value.u[i] = value->value.u[0];
 803             break;
 804          case GLSL_TYPE_FLOAT:
 805             for (unsigned i = 0; i < type->components(); i++)
 806                this->value.f[i] = value->value.f[0];
 807             break;
 808          case GLSL_TYPE_DOUBLE:
 809             for (unsigned i = 0; i < type->components(); i++)
 810                this->value.d[i] = value->value.d[0];
 811             break;
 812          case GLSL_TYPE_UINT64:
 813          case GLSL_TYPE_INT64:
 814             for (unsigned i = 0; i < type->components(); i++)
 815                this->value.u64[i] = value->value.u64[0];
 816             break;
 817          case GLSL_TYPE_BOOL:
 818             for (unsigned i = 0; i < type->components(); i++)
 819                this->value.b[i] = value->value.b[0];
 820             break;
 821          default:
 822             assert(!"Should not get here.");
 823             break;
 824          }
 825       }
 826       return;
 827    }
 828
 829    if (type->is_matrix() && value->type->is_matrix()) {
 830       assert(value->next->is_tail_sentinel());
 831
 832       /* From section 5.4.2 of the GLSL 1.20 spec:
 833        * "If a matrix is constructed from a matrix, then each component
 834        *  (column i, row j) in the result that has a corresponding component
 835        *  (column i, row j) in the argument will be initialized from there."
 836        */
 837       unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
 838       unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
 839       for (unsigned i = 0; i < cols; i++) {
 840          for (unsigned j = 0; j < rows; j++) {
 841             const unsigned src = i * value->type->vector_elements + j;
 842             const unsigned dst = i * type->vector_elements + j;
 843             this->value.f[dst] = value->value.f[src];
 844          }
 845       }
 846
 847       /* "All other components will be initialized to the identity matrix." */
 848       for (unsigned i = cols; i < type->matrix_columns; i++)
 849          this->value.f[i * type->vector_elements + i] = 1.0;
 850
 851       return;
 852    }
 853
 854    /* Use each component from each entry in the value_list to initialize one
 855     * component of the constant being constructed.
 856     */
 857    unsigned i = 0;
 858    for (;;) {
 859       assert(value->as_constant() != NULL);
 860       assert(!value->is_tail_sentinel());
 861
 862       for (unsigned j = 0; j < value->type->components(); j++) {
 863          switch (type->base_type) {
 864          case GLSL_TYPE_UINT:
 865             this->value.u[i] = value->get_uint_component(j);
 866             break;
 867          case GLSL_TYPE_INT:
 868             this->value.i[i] = value->get_int_component(j);
 869             break;
 870          case GLSL_TYPE_FLOAT:
 871             this->value.f[i] = value->get_float_component(j);
 872             break;
 873          case GLSL_TYPE_BOOL:
 874             this->value.b[i] = value->get_bool_component(j);
 875             break;
 876          case GLSL_TYPE_DOUBLE:
 877             this->value.d[i] = value->get_double_component(j);
 878             break;
 879          case GLSL_TYPE_UINT64:
 880             this->value.u64[i] = value->get_uint64_component(j);
 881             break;
 882          case GLSL_TYPE_INT64:
 883             this->value.i64[i] = value->get_int64_component(j);
 884             break;
 885          default:
 886             /* FINISHME: What to do?  Exceptions are not the answer.
 887              */
 888             break;
 889          }
 890
 891          i++;
 892          if (i >= type->components())
 893             break;
 894       }
 895
 896       if (i >= type->components())
 897          break; /* avoid downcasting a list sentinel */
 898       value = (ir_constant *) value->next;
 899    }
 900 }
 901
 902 ir_constant *
 903 ir_constant::zero(void *mem_ctx, const glsl_type *type)
 904 {
 905    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 906           || type->is_record() || type->is_array());
 907
 908    ir_constant *c = new(mem_ctx) ir_constant;
 909    c->type = type;
 910    memset(&c->value, 0, sizeof(c->value));
 911
 912    if (type->is_array()) {
 913       c->array_elements = ralloc_array(c, ir_constant *, type->length);
 914
 915       for (unsigned i = 0; i < type->length; i++)
 916          c->array_elements[i] = ir_constant::zero(c, type->fields.array);
 917    }
 918
 919    if (type->is_record()) {
 920       for (unsigned i = 0; i < type->length; i++) {
 921          ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
 922          c->components.push_tail(comp);
 923       }
 924    }
 925
 926    return c;
 927 }
 928
 929 bool
 930 ir_constant::get_bool_component(unsigned i) const
 931 {
 932    switch (this->type->base_type) {
 933    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
 934    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
 935    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
 936    case GLSL_TYPE_BOOL:  return this->value.b[i];
 937    case GLSL_TYPE_DOUBLE: return this->value.d[i] != 0.0;
 938    case GLSL_TYPE_UINT64: return this->value.u64[i] != 0;
 939    case GLSL_TYPE_INT64:  return this->value.i64[i] != 0;
 940    default:              assert(!"Should not get here."); break;
 941    }
 942
 943    /* Must return something to make the compiler happy.  This is clearly an
 944     * error case.
 945     */
 946    return false;
 947 }
 948
 949 float
 950 ir_constant::get_float_component(unsigned i) const
 951 {
 952    switch (this->type->base_type) {
 953    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
 954    case GLSL_TYPE_INT:   return (float) this->value.i[i];
 955    case GLSL_TYPE_FLOAT: return this->value.f[i];
 956    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0f : 0.0f;
 957    case GLSL_TYPE_DOUBLE: return (float) this->value.d[i];
 958    case GLSL_TYPE_UINT64: return (float) this->value.u64[i];
 959    case GLSL_TYPE_INT64:  return (float) this->value.i64[i];
 960    default:              assert(!"Should not get here."); break;
 961    }
 962
 963    /* Must return something to make the compiler happy.  This is clearly an
 964     * error case.
 965     */
 966    return 0.0;
 967 }
 968
 969 double
 970 ir_constant::get_double_component(unsigned i) const
 971 {
 972    switch (this->type->base_type) {
 973    case GLSL_TYPE_UINT:  return (double) this->value.u[i];
 974    case GLSL_TYPE_INT:   return (double) this->value.i[i];
 975    case GLSL_TYPE_FLOAT: return (double) this->value.f[i];
 976    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0 : 0.0;
 977    case GLSL_TYPE_DOUBLE: return this->value.d[i];
 978    case GLSL_TYPE_UINT64: return (double) this->value.u64[i];
 979    case GLSL_TYPE_INT64:  return (double) this->value.i64[i];
 980    default:              assert(!"Should not get here."); break;
 981    }
 982
 983    /* Must return something to make the compiler happy.  This is clearly an
 984     * error case.
 985     */
 986    return 0.0;
 987 }
 988
 989 int
 990 ir_constant::get_int_component(unsigned i) const
 991 {
 992    switch (this->type->base_type) {
 993    case GLSL_TYPE_UINT:  return this->value.u[i];
 994    case GLSL_TYPE_INT:   return this->value.i[i];
 995    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
 996    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 997    case GLSL_TYPE_DOUBLE: return (int) this->value.d[i];
 998    case GLSL_TYPE_UINT64: return (int) this->value.u64[i];
 999    case GLSL_TYPE_INT64:  return (int) this->value.i64[i];
1000    default:              assert(!"Should not get here."); break;
1001    }
1002
1003    /* Must return something to make the compiler happy.  This is clearly an
1004     * error case.
1005     */
1006    return 0;
1007 }
1008
1009 unsigned
1010 ir_constant::get_uint_component(unsigned i) const
1011 {
1012    switch (this->type->base_type) {
1013    case GLSL_TYPE_UINT:  return this->value.u[i];
1014    case GLSL_TYPE_INT:   return this->value.i[i];
1015    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
1016    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1017    case GLSL_TYPE_DOUBLE: return (unsigned) this->value.d[i];
1018    case GLSL_TYPE_UINT64: return (unsigned) this->value.u64[i];
1019    case GLSL_TYPE_INT64:  return (unsigned) this->value.i64[i];
1020    default:              assert(!"Should not get here."); break;
1021    }
1022
1023    /* Must return something to make the compiler happy.  This is clearly an
1024     * error case.
1025     */
1026    return 0;
1027 }
1028
1029 int64_t
1030 ir_constant::get_int64_component(unsigned i) const
1031 {
1032    switch (this->type->base_type) {
1033    case GLSL_TYPE_UINT:  return this->value.u[i];
1034    case GLSL_TYPE_INT:   return this->value.i[i];
1035    case GLSL_TYPE_FLOAT: return (int64_t) this->value.f[i];
1036    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1037    case GLSL_TYPE_DOUBLE: return (int64_t) this->value.d[i];
1038    case GLSL_TYPE_UINT64: return (int64_t) this->value.u64[i];
1039    case GLSL_TYPE_INT64:  return this->value.i64[i];
1040    default:              assert(!"Should not get here."); break;
1041    }
1042
1043    /* Must return something to make the compiler happy.  This is clearly an
1044     * error case.
1045     */
1046    return 0;
1047 }
1048
1049 uint64_t
1050 ir_constant::get_uint64_component(unsigned i) const
1051 {
1052    switch (this->type->base_type) {
1053    case GLSL_TYPE_UINT:  return this->value.u[i];
1054    case GLSL_TYPE_INT:   return this->value.i[i];
1055    case GLSL_TYPE_FLOAT: return (uint64_t) this->value.f[i];
1056    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
1057    case GLSL_TYPE_DOUBLE: return (uint64_t) this->value.d[i];
1058    case GLSL_TYPE_UINT64: return this->value.u64[i];
1059    case GLSL_TYPE_INT64:  return (uint64_t) this->value.i64[i];
1060    default:              assert(!"Should not get here."); break;
1061    }
1062
1063    /* Must return something to make the compiler happy.  This is clearly an
1064     * error case.
1065     */
1066    return 0;
1067 }
1068
1069 ir_constant *
1070 ir_constant::get_array_element(unsigned i) const
1071 {
1072    assert(this->type->is_array());
1073
1074    /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
1075     *
1076     *     "Behavior is undefined if a shader subscripts an array with an index
1077     *     less than 0 or greater than or equal to the size the array was
1078     *     declared with."
1079     *
1080     * Most out-of-bounds accesses are removed before things could get this far.
1081     * There are cases where non-constant array index values can get constant
1082     * folded.
1083     */
1084    if (int(i) < 0)
1085       i = 0;
1086    else if (i >= this->type->length)
1087       i = this->type->length - 1;
1088
1089    return array_elements[i];
1090 }
1091
1092 ir_constant *
1093 ir_constant::get_record_field(const char *name)
1094 {
1095    int idx = this->type->field_index(name);
1096
1097    if (idx < 0)
1098       return NULL;
1099
1100    if (this->components.is_empty())
1101       return NULL;
1102
1103    exec_node *node = this->components.get_head_raw();
1104    for (int i = 0; i < idx; i++) {
1105       node = node->next;
1106
1107       /* If the end of the list is encountered before the element matching the
1108        * requested field is found, return NULL.
1109        */
1110       if (node->is_tail_sentinel())
1111          return NULL;
1112    }
1113
1114    return (ir_constant *) node;
1115 }
1116
1117 void
1118 ir_constant::copy_offset(ir_constant *src, int offset)
1119 {
1120    switch (this->type->base_type) {
1121    case GLSL_TYPE_UINT:
1122    case GLSL_TYPE_INT:
1123    case GLSL_TYPE_FLOAT:
1124    case GLSL_TYPE_DOUBLE:
1125    case GLSL_TYPE_UINT64:
1126    case GLSL_TYPE_INT64:
1127    case GLSL_TYPE_BOOL: {
1128       unsigned int size = src->type->components();
1129       assert (size <= this->type->components() - offset);
1130       for (unsigned int i=0; i<size; i++) {
1131          switch (this->type->base_type) {
1132          case GLSL_TYPE_UINT:
1133             value.u[i+offset] = src->get_uint_component(i);
1134             break;
1135          case GLSL_TYPE_INT:
1136             value.i[i+offset] = src->get_int_component(i);
1137             break;
1138          case GLSL_TYPE_FLOAT:
1139             value.f[i+offset] = src->get_float_component(i);
1140             break;
1141          case GLSL_TYPE_BOOL:
1142             value.b[i+offset] = src->get_bool_component(i);
1143             break;
1144          case GLSL_TYPE_DOUBLE:
1145             value.d[i+offset] = src->get_double_component(i);
1146             break;
1147          case GLSL_TYPE_UINT64:
1148             value.u64[i+offset] = src->get_uint64_component(i);
1149             break;
1150          case GLSL_TYPE_INT64:
1151             value.i64[i+offset] = src->get_int64_component(i);
1152             break;
1153          default: // Shut up the compiler
1154             break;
1155          }
1156       }
1157       break;
1158    }
1159
1160    case GLSL_TYPE_STRUCT: {
1161       assert (src->type == this->type);
1162       this->components.make_empty();
1163       foreach_in_list(ir_constant, orig, &src->components) {
1164          this->components.push_tail(orig->clone(this, NULL));
1165       }
1166       break;
1167    }
1168
1169    case GLSL_TYPE_ARRAY: {
1170       assert (src->type == this->type);
1171       for (unsigned i = 0; i < this->type->length; i++) {
1172          this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
1173       }
1174       break;
1175    }
1176
1177    default:
1178       assert(!"Should not get here.");
1179       break;
1180    }
1181 }
1182
1183 void
1184 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
1185 {
1186    assert (!type->is_array() && !type->is_record());
1187
1188    if (!type->is_vector() && !type->is_matrix()) {
1189       offset = 0;
1190       mask = 1;
1191    }
1192
1193    int id = 0;
1194    for (int i=0; i<4; i++) {
1195       if (mask & (1 << i)) {
1196          switch (this->type->base_type) {
1197          case GLSL_TYPE_UINT:
1198             value.u[i+offset] = src->get_uint_component(id++);
1199             break;
1200          case GLSL_TYPE_INT:
1201             value.i[i+offset] = src->get_int_component(id++);
1202             break;
1203          case GLSL_TYPE_FLOAT:
1204             value.f[i+offset] = src->get_float_component(id++);
1205             break;
1206          case GLSL_TYPE_BOOL:
1207             value.b[i+offset] = src->get_bool_component(id++);
1208             break;
1209          case GLSL_TYPE_DOUBLE:
1210             value.d[i+offset] = src->get_double_component(id++);
1211             break;
1212          case GLSL_TYPE_UINT64:
1213             value.u64[i+offset] = src->get_uint64_component(id++);
1214             break;
1215          case GLSL_TYPE_INT64:
1216             value.i64[i+offset] = src->get_int64_component(id++);
1217             break;
1218          default:
1219             assert(!"Should not get here.");
1220             return;
1221          }
1222       }
1223    }
1224 }
1225
1226 bool
1227 ir_constant::has_value(const ir_constant *c) const
1228 {
1229    if (this->type != c->type)
1230       return false;
1231
1232    if (this->type->is_array()) {
1233       for (unsigned i = 0; i < this->type->length; i++) {
1234          if (!this->array_elements[i]->has_value(c->array_elements[i]))
1235             return false;
1236       }
1237       return true;
1238    }
1239
1240    if (this->type->is_record()) {
1241       const exec_node *a_node = this->components.get_head_raw();
1242       const exec_node *b_node = c->components.get_head_raw();
1243
1244       while (!a_node->is_tail_sentinel()) {
1245          assert(!b_node->is_tail_sentinel());
1246
1247          const ir_constant *const a_field = (ir_constant *) a_node;
1248          const ir_constant *const b_field = (ir_constant *) b_node;
1249
1250          if (!a_field->has_value(b_field))
1251             return false;
1252
1253          a_node = a_node->next;
1254          b_node = b_node->next;
1255       }
1256
1257       return true;
1258    }
1259
1260    for (unsigned i = 0; i < this->type->components(); i++) {
1261       switch (this->type->base_type) {
1262       case GLSL_TYPE_UINT:
1263          if (this->value.u[i] != c->value.u[i])
1264             return false;
1265          break;
1266       case GLSL_TYPE_INT:
1267          if (this->value.i[i] != c->value.i[i])
1268             return false;
1269          break;
1270       case GLSL_TYPE_FLOAT:
1271          if (this->value.f[i] != c->value.f[i])
1272             return false;
1273          break;
1274       case GLSL_TYPE_BOOL:
1275          if (this->value.b[i] != c->value.b[i])
1276             return false;
1277          break;
1278       case GLSL_TYPE_DOUBLE:
1279          if (this->value.d[i] != c->value.d[i])
1280             return false;
1281          break;
1282       case GLSL_TYPE_UINT64:
1283          if (this->value.u64[i] != c->value.u64[i])
1284             return false;
1285          break;
1286       case GLSL_TYPE_INT64:
1287          if (this->value.i64[i] != c->value.i64[i])
1288             return false;
1289          break;
1290       default:
1291          assert(!"Should not get here.");
1292          return false;
1293       }
1294    }
1295
1296    return true;
1297 }
1298
1299 bool
1300 ir_constant::is_value(float f, int i) const
1301 {
1302    if (!this->type->is_scalar() && !this->type->is_vector())
1303       return false;
1304
1305    /* Only accept boolean values for 0/1. */
1306    if (int(bool(i)) != i && this->type->is_boolean())
1307       return false;
1308
1309    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1310       switch (this->type->base_type) {
1311       case GLSL_TYPE_FLOAT:
1312          if (this->value.f[c] != f)
1313             return false;
1314          break;
1315       case GLSL_TYPE_INT:
1316          if (this->value.i[c] != i)
1317             return false;
1318          break;
1319       case GLSL_TYPE_UINT:
1320          if (this->value.u[c] != unsigned(i))
1321             return false;
1322          break;
1323       case GLSL_TYPE_BOOL:
1324          if (this->value.b[c] != bool(i))
1325             return false;
1326          break;
1327       case GLSL_TYPE_DOUBLE:
1328          if (this->value.d[c] != double(f))
1329             return false;
1330          break;
1331       case GLSL_TYPE_UINT64:
1332          if (this->value.u64[c] != uint64_t(i))
1333             return false;
1334          break;
1335       case GLSL_TYPE_INT64:
1336          if (this->value.i64[c] != i)
1337             return false;
1338          break;
1339       default:
1340          /* The only other base types are structures, arrays, and samplers.
1341           * Samplers cannot be constants, and the others should have been
1342           * filtered out above.
1343           */
1344          assert(!"Should not get here.");
1345          return false;
1346       }
1347    }
1348
1349    return true;
1350 }
1351
1352 bool
1353 ir_constant::is_zero() const
1354 {
1355    return is_value(0.0, 0);
1356 }
1357
1358 bool
1359 ir_constant::is_one() const
1360 {
1361    return is_value(1.0, 1);
1362 }
1363
1364 bool
1365 ir_constant::is_negative_one() const
1366 {
1367    return is_value(-1.0, -1);
1368 }
1369
1370 bool
1371 ir_constant::is_uint16_constant() const
1372 {
1373    if (!type->is_integer())
1374       return false;
1375
1376    return value.u[0] < (1 << 16);
1377 }
1378
1379 ir_loop::ir_loop()
1380    : ir_instruction(ir_type_loop)
1381 {
1382 }
1383
1384
1385 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1386    : ir_dereference(ir_type_dereference_variable)
1387 {
1388    assert(var != NULL);
1389
1390    this->var = var;
1391    this->type = var->type;
1392 }
1393
1394
1395 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1396                                            ir_rvalue *array_index)
1397    : ir_dereference(ir_type_dereference_array)
1398 {
1399    this->array_index = array_index;
1400    this->set_array(value);
1401 }
1402
1403
1404 ir_dereference_array::ir_dereference_array(ir_variable *var,
1405                                            ir_rvalue *array_index)
1406    : ir_dereference(ir_type_dereference_array)
1407 {
1408    void *ctx = ralloc_parent(var);
1409
1410    this->array_index = array_index;
1411    this->set_array(new(ctx) ir_dereference_variable(var));
1412 }
1413
1414
1415 void
1416 ir_dereference_array::set_array(ir_rvalue *value)
1417 {
1418    assert(value != NULL);
1419
1420    this->array = value;
1421
1422    const glsl_type *const vt = this->array->type;
1423
1424    if (vt->is_array()) {
1425       type = vt->fields.array;
1426    } else if (vt->is_matrix()) {
1427       type = vt->column_type();
1428    } else if (vt->is_vector()) {
1429       type = vt->get_base_type();
1430    }
1431 }
1432
1433
1434 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1435                                              const char *field)
1436    : ir_dereference(ir_type_dereference_record)
1437 {
1438    assert(value != NULL);
1439
1440    this->record = value;
1441    this->field = ralloc_strdup(this, field);
1442    this->type = this->record->type->field_type(field);
1443 }
1444
1445
1446 ir_dereference_record::ir_dereference_record(ir_variable *var,
1447                                              const char *field)
1448    : ir_dereference(ir_type_dereference_record)
1449 {
1450    void *ctx = ralloc_parent(var);
1451
1452    this->record = new(ctx) ir_dereference_variable(var);
1453    this->field = ralloc_strdup(this, field);
1454    this->type = this->record->type->field_type(field);
1455 }
1456
1457 bool
1458 ir_dereference::is_lvalue() const
1459 {
1460    ir_variable *var = this->variable_referenced();
1461
1462    /* Every l-value derference chain eventually ends in a variable.
1463     */
1464    if ((var == NULL) || var->data.read_only)
1465       return false;
1466
1467    /* From section 4.1.7 of the GLSL 4.40 spec:
1468     *
1469     *   "Opaque variables cannot be treated as l-values; hence cannot
1470     *    be used as out or inout function parameters, nor can they be
1471     *    assigned into."
1472     */
1473    if (this->type->contains_opaque())
1474       return false;
1475
1476    return true;
1477 }
1478
1479
1480 static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels", "texture_samples", "samples_identical" };
1481
1482 const char *ir_texture::opcode_string()
1483 {
1484    assert((unsigned int) op < ARRAY_SIZE(tex_opcode_strs));
1485    return tex_opcode_strs[op];
1486 }
1487
1488 ir_texture_opcode
1489 ir_texture::get_opcode(const char *str)
1490 {
1491    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1492    for (int op = 0; op < count; op++) {
1493       if (strcmp(str, tex_opcode_strs[op]) == 0)
1494          return (ir_texture_opcode) op;
1495    }
1496    return (ir_texture_opcode) -1;
1497 }
1498
1499
1500 void
1501 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1502 {
1503    assert(sampler != NULL);
1504    assert(type != NULL);
1505    this->sampler = sampler;
1506    this->type = type;
1507
1508    if (this->op == ir_txs || this->op == ir_query_levels ||
1509        this->op == ir_texture_samples) {
1510       assert(type->base_type == GLSL_TYPE_INT);
1511    } else if (this->op == ir_lod) {
1512       assert(type->vector_elements == 2);
1513       assert(type->base_type == GLSL_TYPE_FLOAT);
1514    } else if (this->op == ir_samples_identical) {
1515       assert(type == glsl_type::bool_type);
1516       assert(sampler->type->is_sampler());
1517       assert(sampler->type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS);
1518    } else {
1519       assert(sampler->type->sampled_type == (int) type->base_type);
1520       if (sampler->type->sampler_shadow)
1521          assert(type->vector_elements == 4 || type->vector_elements == 1);
1522       else
1523          assert(type->vector_elements == 4);
1524    }
1525 }
1526
1527
1528 void
1529 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1530 {
1531    assert((count >= 1) && (count <= 4));
1532
1533    memset(&this->mask, 0, sizeof(this->mask));
1534    this->mask.num_components = count;
1535
1536    unsigned dup_mask = 0;
1537    switch (count) {
1538    case 4:
1539       assert(comp[3] <= 3);
1540       dup_mask |= (1U << comp[3])
1541          & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1542       this->mask.w = comp[3];
1543
1544    case 3:
1545       assert(comp[2] <= 3);
1546       dup_mask |= (1U << comp[2])
1547          & ((1U << comp[0]) | (1U << comp[1]));
1548       this->mask.z = comp[2];
1549
1550    case 2:
1551       assert(comp[1] <= 3);
1552       dup_mask |= (1U << comp[1])
1553          & ((1U << comp[0]));
1554       this->mask.y = comp[1];
1555
1556    case 1:
1557       assert(comp[0] <= 3);
1558       this->mask.x = comp[0];
1559    }
1560
1561    this->mask.has_duplicates = dup_mask != 0;
1562
1563    /* Based on the number of elements in the swizzle and the base type
1564     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1565     * generate the type of the resulting value.
1566     */
1567    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1568 }
1569
1570 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1571                        unsigned w, unsigned count)
1572    : ir_rvalue(ir_type_swizzle), val(val)
1573 {
1574    const unsigned components[4] = { x, y, z, w };
1575    this->init_mask(components, count);
1576 }
1577
1578 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1579                        unsigned count)
1580    : ir_rvalue(ir_type_swizzle), val(val)
1581 {
1582    this->init_mask(comp, count);
1583 }
1584
1585 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1586    : ir_rvalue(ir_type_swizzle)
1587 {
1588    this->val = val;
1589    this->mask = mask;
1590    this->type = glsl_type::get_instance(val->type->base_type,
1591                                         mask.num_components, 1);
1592 }
1593
1594 #define X 1
1595 #define R 5
1596 #define S 9
1597 #define I 13
1598
1599 ir_swizzle *
1600 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1601 {
1602    void *ctx = ralloc_parent(val);
1603
1604    /* For each possible swizzle character, this table encodes the value in
1605     * \c idx_map that represents the 0th element of the vector.  For invalid
1606     * swizzle characters (e.g., 'k'), a special value is used that will allow
1607     * detection of errors.
1608     */
1609    static const unsigned char base_idx[26] = {
1610    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
1611       R, R, I, I, I, I, R, I, I, I, I, I, I,
1612    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
1613       I, I, S, S, R, S, S, I, I, X, X, X, X
1614    };
1615
1616    /* Each valid swizzle character has an entry in the previous table.  This
1617     * table encodes the base index encoded in the previous table plus the actual
1618     * index of the swizzle character.  When processing swizzles, the first
1619     * character in the string is indexed in the previous table.  Each character
1620     * in the string is indexed in this table, and the value found there has the
1621     * value form the first table subtracted.  The result must be on the range
1622     * [0,3].
1623     *
1624     * For example, the string "wzyx" will get X from the first table.  Each of
1625     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
1626     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1627     *
1628     * The string "wzrg" will get X from the first table.  Each of the characters
1629     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
1630     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
1631     * [0,3], the error is detected.
1632     */
1633    static const unsigned char idx_map[26] = {
1634    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
1635       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
1636    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
1637       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
1638    };
1639
1640    int swiz_idx[4] = { 0, 0, 0, 0 };
1641    unsigned i;
1642
1643
1644    /* Validate the first character in the swizzle string and look up the base
1645     * index value as described above.
1646     */
1647    if ((str[0] < 'a') || (str[0] > 'z'))
1648       return NULL;
1649
1650    const unsigned base = base_idx[str[0] - 'a'];
1651
1652
1653    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1654       /* Validate the next character, and, as described above, convert it to a
1655        * swizzle index.
1656        */
1657       if ((str[i] < 'a') || (str[i] > 'z'))
1658          return NULL;
1659
1660       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1661       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1662          return NULL;
1663    }
1664
1665    if (str[i] != '\0')
1666          return NULL;
1667
1668    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1669                               swiz_idx[3], i);
1670 }
1671
1672 #undef X
1673 #undef R
1674 #undef S
1675 #undef I
1676
1677 ir_variable *
1678 ir_swizzle::variable_referenced() const
1679 {
1680    return this->val->variable_referenced();
1681 }
1682
1683
1684 bool ir_variable::temporaries_allocate_names = false;
1685
1686 const char ir_variable::tmp_name[] = "compiler_temp";
1687
1688 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1689                          ir_variable_mode mode)
1690    : ir_instruction(ir_type_variable)
1691 {
1692    this->type = type;
1693
1694    if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)
1695       name = NULL;
1696
1697    /* The ir_variable clone method may call this constructor with name set to
1698     * tmp_name.
1699     */
1700    assert(name != NULL
1701           || mode == ir_var_temporary
1702           || mode == ir_var_function_in
1703           || mode == ir_var_function_out
1704           || mode == ir_var_function_inout);
1705    assert(name != ir_variable::tmp_name
1706           || mode == ir_var_temporary);
1707    if (mode == ir_var_temporary
1708        && (name == NULL || name == ir_variable::tmp_name)) {
1709       this->name = ir_variable::tmp_name;
1710    } else if (name == NULL ||
1711               strlen(name) < ARRAY_SIZE(this->name_storage)) {
1712       strcpy(this->name_storage, name ? name : "");
1713       this->name = this->name_storage;
1714    } else {
1715       this->name = ralloc_strdup(this, name);
1716    }
1717
1718    this->u.max_ifc_array_access = NULL;
1719
1720    this->data.explicit_location = false;
1721    this->data.has_initializer = false;
1722    this->data.location = -1;
1723    this->data.location_frac = 0;
1724    this->data.binding = 0;
1725    this->data.warn_extension_index = 0;
1726    this->constant_value = NULL;
1727    this->constant_initializer = NULL;
1728    this->data.origin_upper_left = false;
1729    this->data.pixel_center_integer = false;
1730    this->data.depth_layout = ir_depth_layout_none;
1731    this->data.used = false;
1732    this->data.always_active_io = false;
1733    this->data.read_only = false;
1734    this->data.centroid = false;
1735    this->data.sample = false;
1736    this->data.patch = false;
1737    this->data.invariant = false;
1738    this->data.how_declared = ir_var_declared_normally;
1739    this->data.mode = mode;
1740    this->data.interpolation = INTERP_MODE_NONE;
1741    this->data.max_array_access = -1;
1742    this->data.offset = 0;
1743    this->data.precision = GLSL_PRECISION_NONE;
1744    this->data.image_read_only = false;
1745    this->data.image_write_only = false;
1746    this->data.image_coherent = false;
1747    this->data.image_volatile = false;
1748    this->data.image_restrict = false;
1749    this->data.from_ssbo_unsized_array = false;
1750    this->data.fb_fetch_output = false;
1751
1752    if (type != NULL) {
1753       if (type->is_sampler())
1754          this->data.read_only = true;
1755
1756       if (type->is_interface())
1757          this->init_interface_type(type);
1758       else if (type->without_array()->is_interface())
1759          this->init_interface_type(type->without_array());
1760    }
1761 }
1762
1763
1764 const char *
1765 interpolation_string(unsigned interpolation)
1766 {
1767    switch (interpolation) {
1768    case INTERP_MODE_NONE:          return "no";
1769    case INTERP_MODE_SMOOTH:        return "smooth";
1770    case INTERP_MODE_FLAT:          return "flat";
1771    case INTERP_MODE_NOPERSPECTIVE: return "noperspective";
1772    }
1773
1774    assert(!"Should not get here.");
1775    return "";
1776 }
1777
1778 const char *const ir_variable::warn_extension_table[] = {
1779    "",
1780    "GL_ARB_shader_stencil_export",
1781    "GL_AMD_shader_stencil_export",
1782 };
1783
1784 void
1785 ir_variable::enable_extension_warning(const char *extension)
1786 {
1787    for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {
1788       if (strcmp(warn_extension_table[i], extension) == 0) {
1789          this->data.warn_extension_index = i;
1790          return;
1791       }
1792    }
1793
1794    assert(!"Should not get here.");
1795    this->data.warn_extension_index = 0;
1796 }
1797
1798 const char *
1799 ir_variable::get_extension_warning() const
1800 {
1801    return this->data.warn_extension_index == 0
1802       ? NULL : warn_extension_table[this->data.warn_extension_index];
1803 }
1804
1805 ir_function_signature::ir_function_signature(const glsl_type *return_type,
1806                                              builtin_available_predicate b)
1807    : ir_instruction(ir_type_function_signature),
1808      return_type(return_type), is_defined(false),
1809      intrinsic_id(ir_intrinsic_invalid), builtin_avail(b), _function(NULL)
1810 {
1811    this->origin = NULL;
1812 }
1813
1814
1815 bool
1816 ir_function_signature::is_builtin() const
1817 {
1818    return builtin_avail != NULL;
1819 }
1820
1821
1822 bool
1823 ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const
1824 {
1825    /* We can't call the predicate without a state pointer, so just say that
1826     * the signature is available.  At compile time, we need the filtering,
1827     * but also receive a valid state pointer.  At link time, we're resolving
1828     * imported built-in prototypes to their definitions, which will always
1829     * be an exact match.  So we can skip the filtering.
1830     */
1831    if (state == NULL)
1832       return true;
1833
1834    assert(builtin_avail != NULL);
1835    return builtin_avail(state);
1836 }
1837
1838
1839 static bool
1840 modes_match(unsigned a, unsigned b)
1841 {
1842    if (a == b)
1843       return true;
1844
1845    /* Accept "in" vs. "const in" */
1846    if ((a == ir_var_const_in && b == ir_var_function_in) ||
1847        (b == ir_var_const_in && a == ir_var_function_in))
1848       return true;
1849
1850    return false;
1851 }
1852
1853
1854 const char *
1855 ir_function_signature::qualifiers_match(exec_list *params)
1856 {
1857    /* check that the qualifiers match. */
1858    foreach_two_lists(a_node, &this->parameters, b_node, params) {
1859       ir_variable *a = (ir_variable *) a_node;
1860       ir_variable *b = (ir_variable *) b_node;
1861
1862       if (a->data.read_only != b->data.read_only ||
1863           !modes_match(a->data.mode, b->data.mode) ||
1864           a->data.interpolation != b->data.interpolation ||
1865           a->data.centroid != b->data.centroid ||
1866           a->data.sample != b->data.sample ||
1867           a->data.patch != b->data.patch ||
1868           a->data.image_read_only != b->data.image_read_only ||
1869           a->data.image_write_only != b->data.image_write_only ||
1870           a->data.image_coherent != b->data.image_coherent ||
1871           a->data.image_volatile != b->data.image_volatile ||
1872           a->data.image_restrict != b->data.image_restrict) {
1873
1874          /* parameter a's qualifiers don't match */
1875          return a->name;
1876       }
1877    }
1878    return NULL;
1879 }
1880
1881
1882 void
1883 ir_function_signature::replace_parameters(exec_list *new_params)
1884 {
1885    /* Destroy all of the previous parameter information.  If the previous
1886     * parameter information comes from the function prototype, it may either
1887     * specify incorrect parameter names or not have names at all.
1888     */
1889    new_params->move_nodes_to(&parameters);
1890 }
1891
1892
1893 ir_function::ir_function(const char *name)
1894    : ir_instruction(ir_type_function)
1895 {
1896    this->subroutine_index = -1;
1897    this->name = ralloc_strdup(this, name);
1898 }
1899
1900
1901 bool
1902 ir_function::has_user_signature()
1903 {
1904    foreach_in_list(ir_function_signature, sig, &this->signatures) {
1905       if (!sig->is_builtin())
1906          return true;
1907    }
1908    return false;
1909 }
1910
1911
1912 ir_rvalue *
1913 ir_rvalue::error_value(void *mem_ctx)
1914 {
1915    ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);
1916
1917    v->type = glsl_type::error_type;
1918    return v;
1919 }
1920
1921
1922 void
1923 visit_exec_list(exec_list *list, ir_visitor *visitor)
1924 {
1925    foreach_in_list_safe(ir_instruction, node, list) {
1926       node->accept(visitor);
1927    }
1928 }
1929
1930
1931 static void
1932 steal_memory(ir_instruction *ir, void *new_ctx)
1933 {
1934    ir_variable *var = ir->as_variable();
1935    ir_function *fn = ir->as_function();
1936    ir_constant *constant = ir->as_constant();
1937    if (var != NULL && var->constant_value != NULL)
1938       steal_memory(var->constant_value, ir);
1939
1940    if (var != NULL && var->constant_initializer != NULL)
1941       steal_memory(var->constant_initializer, ir);
1942
1943    if (fn != NULL && fn->subroutine_types)
1944       ralloc_steal(new_ctx, fn->subroutine_types);
1945
1946    /* The components of aggregate constants are not visited by the normal
1947     * visitor, so steal their values by hand.
1948     */
1949    if (constant != NULL) {
1950       if (constant->type->is_record()) {
1951          foreach_in_list(ir_constant, field, &constant->components) {
1952             steal_memory(field, ir);
1953          }
1954       } else if (constant->type->is_array()) {
1955          for (unsigned int i = 0; i < constant->type->length; i++) {
1956             steal_memory(constant->array_elements[i], ir);
1957          }
1958       }
1959    }
1960
1961    ralloc_steal(new_ctx, ir);
1962 }
1963
1964
1965 void
1966 reparent_ir(exec_list *list, void *mem_ctx)
1967 {
1968    foreach_in_list(ir_instruction, node, list) {
1969       visit_tree(node, steal_memory, mem_ctx);
1970    }
1971 }
1972
1973
1974 static ir_rvalue *
1975 try_min_one(ir_rvalue *ir)
1976 {
1977    ir_expression *expr = ir->as_expression();
1978
1979    if (!expr || expr->operation != ir_binop_min)
1980       return NULL;
1981
1982    if (expr->operands[0]->is_one())
1983       return expr->operands[1];
1984
1985    if (expr->operands[1]->is_one())
1986       return expr->operands[0];
1987
1988    return NULL;
1989 }
1990
1991 static ir_rvalue *
1992 try_max_zero(ir_rvalue *ir)
1993 {
1994    ir_expression *expr = ir->as_expression();
1995
1996    if (!expr || expr->operation != ir_binop_max)
1997       return NULL;
1998
1999    if (expr->operands[0]->is_zero())
2000       return expr->operands[1];
2001
2002    if (expr->operands[1]->is_zero())
2003       return expr->operands[0];
2004
2005    return NULL;
2006 }
2007
2008 ir_rvalue *
2009 ir_rvalue::as_rvalue_to_saturate()
2010 {
2011    ir_expression *expr = this->as_expression();
2012
2013    if (!expr)
2014       return NULL;
2015
2016    ir_rvalue *max_zero = try_max_zero(expr);
2017    if (max_zero) {
2018       return try_min_one(max_zero);
2019    } else {
2020       ir_rvalue *min_one = try_min_one(expr);
2021       if (min_one) {
2022          return try_max_zero(min_one);
2023       }
2024    }
2025
2026    return NULL;
2027 }
2028
2029
2030 unsigned
2031 vertices_per_prim(GLenum prim)
2032 {
2033    switch (prim) {
2034    case GL_POINTS:
2035       return 1;
2036    case GL_LINES:
2037       return 2;
2038    case GL_TRIANGLES:
2039       return 3;
2040    case GL_LINES_ADJACENCY:
2041       return 4;
2042    case GL_TRIANGLES_ADJACENCY:
2043       return 6;
2044    default:
2045       assert(!"Bad primitive");
2046       return 3;
2047    }
2048 }
2049
2050 /**
2051  * Generate a string describing the mode of a variable
2052  */
2053 const char *
2054 mode_string(const ir_variable *var)
2055 {
2056    switch (var->data.mode) {
2057    case ir_var_auto:
2058       return (var->data.read_only) ? "global constant" : "global variable";
2059
2060    case ir_var_uniform:
2061       return "uniform";
2062
2063    case ir_var_shader_storage:
2064       return "buffer";
2065
2066    case ir_var_shader_in:
2067       return "shader input";
2068
2069    case ir_var_shader_out:
2070       return "shader output";
2071
2072    case ir_var_function_in:
2073    case ir_var_const_in:
2074       return "function input";
2075
2076    case ir_var_function_out:
2077       return "function output";
2078
2079    case ir_var_function_inout:
2080       return "function inout";
2081
2082    case ir_var_system_value:
2083       return "shader input";
2084
2085    case ir_var_temporary:
2086       return "compiler temporary";
2087
2088    case ir_var_mode_count:
2089       break;
2090    }
2091
2092    assert(!"Should not get here.");
2093    return "invalid variable";
2094 }