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