src/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 "ir_visitor.h"
  27 #include "glsl_types.h"
  28
  29 ir_rvalue::ir_rvalue()
  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    m.num_components = MAX2(m.num_components, (to + 1));
  68 }
  69
  70 void
  71 ir_assignment::set_lhs(ir_rvalue *lhs)
  72 {
  73    void *mem_ctx = this;
  74    bool swizzled = false;
  75
  76    while (lhs != NULL) {
  77       ir_swizzle *swiz = lhs->as_swizzle();
  78
  79       if (swiz == NULL)
  80          break;
  81
  82       unsigned write_mask = 0;
  83       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
  84
  85       for (unsigned i = 0; i < swiz->mask.num_components; i++) {
  86          unsigned c = 0;
  87
  88          switch (i) {
  89          case 0: c = swiz->mask.x; break;
  90          case 1: c = swiz->mask.y; break;
  91          case 2: c = swiz->mask.z; break;
  92          case 3: c = swiz->mask.w; break;
  93          default: assert(!"Should not get here.");
  94          }
  95
  96          write_mask |= (((this->write_mask >> i) & 1) << c);
  97          update_rhs_swizzle(rhs_swiz, i, c);
  98       }
  99
 100       this->write_mask = write_mask;
 101       lhs = swiz->val;
 102
 103       this->rhs = new(mem_ctx) ir_swizzle(this->rhs, rhs_swiz);
 104       swizzled = true;
 105    }
 106
 107    if (swizzled) {
 108       /* Now, RHS channels line up with the LHS writemask.  Collapse it
 109        * to just the channels that will be written.
 110        */
 111       ir_swizzle_mask rhs_swiz = { 0, 0, 0, 0, 0, 0 };
 112       int rhs_chan = 0;
 113       for (int i = 0; i < 4; i++) {
 114          if (write_mask & (1 << i))
 115             update_rhs_swizzle(rhs_swiz, i, rhs_chan++);
 116       }
 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 {
 152    this->ir_type = ir_type_assignment;
 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 {
 172    this->ir_type = ir_type_assignment;
 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
 194 ir_expression::ir_expression(int op, const struct glsl_type *type,
 195                              ir_rvalue *op0)
 196 {
 197    assert(get_num_operands(ir_expression_operation(op)) == 1);
 198    this->ir_type = ir_type_expression;
 199    this->type = type;
 200    this->operation = ir_expression_operation(op);
 201    this->operands[0] = op0;
 202    this->operands[1] = NULL;
 203    this->operands[2] = NULL;
 204    this->operands[3] = NULL;
 205 }
 206
 207 ir_expression::ir_expression(int op, const struct glsl_type *type,
 208                              ir_rvalue *op0, ir_rvalue *op1)
 209 {
 210    assert(((op1 == NULL) && (get_num_operands(ir_expression_operation(op)) == 1))
 211           || (get_num_operands(ir_expression_operation(op)) == 2));
 212    this->ir_type = ir_type_expression;
 213    this->type = type;
 214    this->operation = ir_expression_operation(op);
 215    this->operands[0] = op0;
 216    this->operands[1] = op1;
 217    this->operands[2] = NULL;
 218    this->operands[3] = NULL;
 219 }
 220
 221 ir_expression::ir_expression(int op, const struct glsl_type *type,
 222                              ir_rvalue *op0, ir_rvalue *op1,
 223                              ir_rvalue *op2, ir_rvalue *op3)
 224 {
 225    this->ir_type = ir_type_expression;
 226    this->type = type;
 227    this->operation = ir_expression_operation(op);
 228    this->operands[0] = op0;
 229    this->operands[1] = op1;
 230    this->operands[2] = op2;
 231    this->operands[3] = op3;
 232 }
 233
 234 ir_expression::ir_expression(int op, ir_rvalue *op0)
 235 {
 236    this->ir_type = ir_type_expression;
 237
 238    this->operation = ir_expression_operation(op);
 239    this->operands[0] = op0;
 240    this->operands[1] = NULL;
 241    this->operands[2] = NULL;
 242    this->operands[3] = NULL;
 243
 244    assert(op <= ir_last_unop);
 245
 246    switch (this->operation) {
 247    case ir_unop_bit_not:
 248    case ir_unop_logic_not:
 249    case ir_unop_neg:
 250    case ir_unop_abs:
 251    case ir_unop_sign:
 252    case ir_unop_rcp:
 253    case ir_unop_rsq:
 254    case ir_unop_sqrt:
 255    case ir_unop_exp:
 256    case ir_unop_log:
 257    case ir_unop_exp2:
 258    case ir_unop_log2:
 259    case ir_unop_trunc:
 260    case ir_unop_ceil:
 261    case ir_unop_floor:
 262    case ir_unop_fract:
 263    case ir_unop_round_even:
 264    case ir_unop_sin:
 265    case ir_unop_cos:
 266    case ir_unop_sin_reduced:
 267    case ir_unop_cos_reduced:
 268    case ir_unop_dFdx:
 269    case ir_unop_dFdy:
 270       this->type = op0->type;
 271       break;
 272
 273    case ir_unop_f2i:
 274    case ir_unop_b2i:
 275    case ir_unop_u2i:
 276    case ir_unop_bitcast_f2i:
 277       this->type = glsl_type::get_instance(GLSL_TYPE_INT,
 278                                            op0->type->vector_elements, 1);
 279       break;
 280
 281    case ir_unop_b2f:
 282    case ir_unop_i2f:
 283    case ir_unop_u2f:
 284    case ir_unop_bitcast_i2f:
 285    case ir_unop_bitcast_u2f:
 286       this->type = glsl_type::get_instance(GLSL_TYPE_FLOAT,
 287                                            op0->type->vector_elements, 1);
 288       break;
 289
 290    case ir_unop_f2b:
 291    case ir_unop_i2b:
 292       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
 293                                            op0->type->vector_elements, 1);
 294       break;
 295
 296    case ir_unop_i2u:
 297    case ir_unop_bitcast_f2u:
 298       this->type = glsl_type::get_instance(GLSL_TYPE_UINT,
 299                                            op0->type->vector_elements, 1);
 300       break;
 301
 302    case ir_unop_noise:
 303       this->type = glsl_type::float_type;
 304       break;
 305
 306    case ir_unop_any:
 307       this->type = glsl_type::bool_type;
 308       break;
 309
 310    default:
 311       assert(!"not reached: missing automatic type setup for ir_expression");
 312       this->type = op0->type;
 313       break;
 314    }
 315 }
 316
 317 ir_expression::ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1)
 318 {
 319    this->ir_type = ir_type_expression;
 320
 321    this->operation = ir_expression_operation(op);
 322    this->operands[0] = op0;
 323    this->operands[1] = op1;
 324    this->operands[2] = NULL;
 325    this->operands[3] = NULL;
 326
 327    assert(op > ir_last_unop);
 328
 329    switch (this->operation) {
 330    case ir_binop_all_equal:
 331    case ir_binop_any_nequal:
 332       this->type = glsl_type::bool_type;
 333       break;
 334
 335    case ir_binop_add:
 336    case ir_binop_sub:
 337    case ir_binop_min:
 338    case ir_binop_max:
 339    case ir_binop_pow:
 340    case ir_binop_mul:
 341    case ir_binop_div:
 342    case ir_binop_mod:
 343       if (op0->type->is_scalar()) {
 344          this->type = op1->type;
 345       } else if (op1->type->is_scalar()) {
 346          this->type = op0->type;
 347       } else {
 348          /* FINISHME: matrix types */
 349          assert(!op0->type->is_matrix() && !op1->type->is_matrix());
 350          assert(op0->type == op1->type);
 351          this->type = op0->type;
 352       }
 353       break;
 354
 355    case ir_binop_logic_and:
 356    case ir_binop_logic_xor:
 357    case ir_binop_logic_or:
 358    case ir_binop_bit_and:
 359    case ir_binop_bit_xor:
 360    case ir_binop_bit_or:
 361       if (op0->type->is_scalar()) {
 362          this->type = op1->type;
 363       } else if (op1->type->is_scalar()) {
 364          this->type = op0->type;
 365       }
 366       break;
 367
 368    case ir_binop_equal:
 369    case ir_binop_nequal:
 370    case ir_binop_lequal:
 371    case ir_binop_gequal:
 372    case ir_binop_less:
 373    case ir_binop_greater:
 374       assert(op0->type == op1->type);
 375       this->type = glsl_type::get_instance(GLSL_TYPE_BOOL,
 376                                            op0->type->vector_elements, 1);
 377       break;
 378
 379    case ir_binop_dot:
 380       this->type = glsl_type::float_type;
 381       break;
 382
 383    case ir_binop_lshift:
 384    case ir_binop_rshift:
 385       this->type = op0->type;
 386       break;
 387
 388    default:
 389       assert(!"not reached: missing automatic type setup for ir_expression");
 390       this->type = glsl_type::float_type;
 391    }
 392 }
 393
 394 unsigned int
 395 ir_expression::get_num_operands(ir_expression_operation op)
 396 {
 397    assert(op <= ir_last_opcode);
 398
 399    if (op <= ir_last_unop)
 400       return 1;
 401
 402    if (op <= ir_last_binop)
 403       return 2;
 404
 405    if (op == ir_quadop_vector)
 406       return 4;
 407
 408    assert(false);
 409    return 0;
 410 }
 411
 412 static const char *const operator_strs[] = {
 413    "~",
 414    "!",
 415    "neg",
 416    "abs",
 417    "sign",
 418    "rcp",
 419    "rsq",
 420    "sqrt",
 421    "exp",
 422    "log",
 423    "exp2",
 424    "log2",
 425    "f2i",
 426    "i2f",
 427    "f2b",
 428    "b2f",
 429    "i2b",
 430    "b2i",
 431    "u2f",
 432    "i2u",
 433    "u2i",
 434    "bitcast_i2f",
 435    "bitcast_f2i",
 436    "bitcast_u2f",
 437    "bitcast_f2u",
 438    "any",
 439    "trunc",
 440    "ceil",
 441    "floor",
 442    "fract",
 443    "round_even",
 444    "sin",
 445    "cos",
 446    "sin_reduced",
 447    "cos_reduced",
 448    "dFdx",
 449    "dFdy",
 450    "noise",
 451    "+",
 452    "-",
 453    "*",
 454    "/",
 455    "%",
 456    "<",
 457    ">",
 458    "<=",
 459    ">=",
 460    "==",
 461    "!=",
 462    "all_equal",
 463    "any_nequal",
 464    "<<",
 465    ">>",
 466    "&",
 467    "^",
 468    "|",
 469    "&&",
 470    "^^",
 471    "||",
 472    "dot",
 473    "min",
 474    "max",
 475    "pow",
 476    "vector",
 477 };
 478
 479 const char *ir_expression::operator_string(ir_expression_operation op)
 480 {
 481    assert((unsigned int) op < Elements(operator_strs));
 482    assert(Elements(operator_strs) == (ir_quadop_vector + 1));
 483    return operator_strs[op];
 484 }
 485
 486 const char *ir_expression::operator_string()
 487 {
 488    return operator_string(this->operation);
 489 }
 490
 491 const char*
 492 depth_layout_string(ir_depth_layout layout)
 493 {
 494    switch(layout) {
 495    case ir_depth_layout_none:      return "";
 496    case ir_depth_layout_any:       return "depth_any";
 497    case ir_depth_layout_greater:   return "depth_greater";
 498    case ir_depth_layout_less:      return "depth_less";
 499    case ir_depth_layout_unchanged: return "depth_unchanged";
 500
 501    default:
 502       assert(0);
 503       return "";
 504    }
 505 }
 506
 507 ir_expression_operation
 508 ir_expression::get_operator(const char *str)
 509 {
 510    const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
 511    for (int op = 0; op < operator_count; op++) {
 512       if (strcmp(str, operator_strs[op]) == 0)
 513          return (ir_expression_operation) op;
 514    }
 515    return (ir_expression_operation) -1;
 516 }
 517
 518 ir_constant::ir_constant()
 519 {
 520    this->ir_type = ir_type_constant;
 521 }
 522
 523 ir_constant::ir_constant(const struct glsl_type *type,
 524                          const ir_constant_data *data)
 525 {
 526    assert((type->base_type >= GLSL_TYPE_UINT)
 527           && (type->base_type <= GLSL_TYPE_BOOL));
 528
 529    this->ir_type = ir_type_constant;
 530    this->type = type;
 531    memcpy(& this->value, data, sizeof(this->value));
 532 }
 533
 534 ir_constant::ir_constant(float f)
 535 {
 536    this->ir_type = ir_type_constant;
 537    this->type = glsl_type::float_type;
 538    this->value.f[0] = f;
 539    for (int i = 1; i < 16; i++)  {
 540       this->value.f[i] = 0;
 541    }
 542 }
 543
 544 ir_constant::ir_constant(unsigned int u)
 545 {
 546    this->ir_type = ir_type_constant;
 547    this->type = glsl_type::uint_type;
 548    this->value.u[0] = u;
 549    for (int i = 1; i < 16; i++) {
 550       this->value.u[i] = 0;
 551    }
 552 }
 553
 554 ir_constant::ir_constant(int i)
 555 {
 556    this->ir_type = ir_type_constant;
 557    this->type = glsl_type::int_type;
 558    this->value.i[0] = i;
 559    for (int i = 1; i < 16; i++) {
 560       this->value.i[i] = 0;
 561    }
 562 }
 563
 564 ir_constant::ir_constant(bool b)
 565 {
 566    this->ir_type = ir_type_constant;
 567    this->type = glsl_type::bool_type;
 568    this->value.b[0] = b;
 569    for (int i = 1; i < 16; i++) {
 570       this->value.b[i] = false;
 571    }
 572 }
 573
 574 ir_constant::ir_constant(const ir_constant *c, unsigned i)
 575 {
 576    this->ir_type = ir_type_constant;
 577    this->type = c->type->get_base_type();
 578
 579    switch (this->type->base_type) {
 580    case GLSL_TYPE_UINT:  this->value.u[0] = c->value.u[i]; break;
 581    case GLSL_TYPE_INT:   this->value.i[0] = c->value.i[i]; break;
 582    case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
 583    case GLSL_TYPE_BOOL:  this->value.b[0] = c->value.b[i]; break;
 584    default:              assert(!"Should not get here."); break;
 585    }
 586 }
 587
 588 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
 589 {
 590    this->ir_type = ir_type_constant;
 591    this->type = type;
 592
 593    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 594           || type->is_record() || type->is_array());
 595
 596    if (type->is_array()) {
 597       this->array_elements = ralloc_array(this, ir_constant *, type->length);
 598       unsigned i = 0;
 599       foreach_list(node, value_list) {
 600          ir_constant *value = (ir_constant *) node;
 601          assert(value->as_constant() != NULL);
 602
 603          this->array_elements[i++] = value;
 604       }
 605       return;
 606    }
 607
 608    /* If the constant is a record, the types of each of the entries in
 609     * value_list must be a 1-for-1 match with the structure components.  Each
 610     * entry must also be a constant.  Just move the nodes from the value_list
 611     * to the list in the ir_constant.
 612     */
 613    /* FINISHME: Should there be some type checking and / or assertions here? */
 614    /* FINISHME: Should the new constant take ownership of the nodes from
 615     * FINISHME: value_list, or should it make copies?
 616     */
 617    if (type->is_record()) {
 618       value_list->move_nodes_to(& this->components);
 619       return;
 620    }
 621
 622    for (unsigned i = 0; i < 16; i++) {
 623       this->value.u[i] = 0;
 624    }
 625
 626    ir_constant *value = (ir_constant *) (value_list->head);
 627
 628    /* Constructors with exactly one scalar argument are special for vectors
 629     * and matrices.  For vectors, the scalar value is replicated to fill all
 630     * the components.  For matrices, the scalar fills the components of the
 631     * diagonal while the rest is filled with 0.
 632     */
 633    if (value->type->is_scalar() && value->next->is_tail_sentinel()) {
 634       if (type->is_matrix()) {
 635          /* Matrix - fill diagonal (rest is already set to 0) */
 636          assert(type->base_type == GLSL_TYPE_FLOAT);
 637          for (unsigned i = 0; i < type->matrix_columns; i++)
 638             this->value.f[i * type->vector_elements + i] = value->value.f[0];
 639       } else {
 640          /* Vector or scalar - fill all components */
 641          switch (type->base_type) {
 642          case GLSL_TYPE_UINT:
 643          case GLSL_TYPE_INT:
 644             for (unsigned i = 0; i < type->components(); i++)
 645                this->value.u[i] = value->value.u[0];
 646             break;
 647          case GLSL_TYPE_FLOAT:
 648             for (unsigned i = 0; i < type->components(); i++)
 649                this->value.f[i] = value->value.f[0];
 650             break;
 651          case GLSL_TYPE_BOOL:
 652             for (unsigned i = 0; i < type->components(); i++)
 653                this->value.b[i] = value->value.b[0];
 654             break;
 655          default:
 656             assert(!"Should not get here.");
 657             break;
 658          }
 659       }
 660       return;
 661    }
 662
 663    if (type->is_matrix() && value->type->is_matrix()) {
 664       assert(value->next->is_tail_sentinel());
 665
 666       /* From section 5.4.2 of the GLSL 1.20 spec:
 667        * "If a matrix is constructed from a matrix, then each component
 668        *  (column i, row j) in the result that has a corresponding component
 669        *  (column i, row j) in the argument will be initialized from there."
 670        */
 671       unsigned cols = MIN2(type->matrix_columns, value->type->matrix_columns);
 672       unsigned rows = MIN2(type->vector_elements, value->type->vector_elements);
 673       for (unsigned i = 0; i < cols; i++) {
 674          for (unsigned j = 0; j < rows; j++) {
 675             const unsigned src = i * value->type->vector_elements + j;
 676             const unsigned dst = i * type->vector_elements + j;
 677             this->value.f[dst] = value->value.f[src];
 678          }
 679       }
 680
 681       /* "All other components will be initialized to the identity matrix." */
 682       for (unsigned i = cols; i < type->matrix_columns; i++)
 683          this->value.f[i * type->vector_elements + i] = 1.0;
 684
 685       return;
 686    }
 687
 688    /* Use each component from each entry in the value_list to initialize one
 689     * component of the constant being constructed.
 690     */
 691    for (unsigned i = 0; i < type->components(); /* empty */) {
 692       assert(value->as_constant() != NULL);
 693       assert(!value->is_tail_sentinel());
 694
 695       for (unsigned j = 0; j < value->type->components(); j++) {
 696          switch (type->base_type) {
 697          case GLSL_TYPE_UINT:
 698             this->value.u[i] = value->get_uint_component(j);
 699             break;
 700          case GLSL_TYPE_INT:
 701             this->value.i[i] = value->get_int_component(j);
 702             break;
 703          case GLSL_TYPE_FLOAT:
 704             this->value.f[i] = value->get_float_component(j);
 705             break;
 706          case GLSL_TYPE_BOOL:
 707             this->value.b[i] = value->get_bool_component(j);
 708             break;
 709          default:
 710             /* FINISHME: What to do?  Exceptions are not the answer.
 711              */
 712             break;
 713          }
 714
 715          i++;
 716          if (i >= type->components())
 717             break;
 718       }
 719
 720       value = (ir_constant *) value->next;
 721    }
 722 }
 723
 724 ir_constant *
 725 ir_constant::zero(void *mem_ctx, const glsl_type *type)
 726 {
 727    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 728           || type->is_record() || type->is_array());
 729
 730    ir_constant *c = new(mem_ctx) ir_constant;
 731    c->type = type;
 732    memset(&c->value, 0, sizeof(c->value));
 733
 734    if (type->is_array()) {
 735       c->array_elements = ralloc_array(c, ir_constant *, type->length);
 736
 737       for (unsigned i = 0; i < type->length; i++)
 738          c->array_elements[i] = ir_constant::zero(c, type->element_type());
 739    }
 740
 741    if (type->is_record()) {
 742       for (unsigned i = 0; i < type->length; i++) {
 743          ir_constant *comp = ir_constant::zero(mem_ctx, type->fields.structure[i].type);
 744          c->components.push_tail(comp);
 745       }
 746    }
 747
 748    return c;
 749 }
 750
 751 bool
 752 ir_constant::get_bool_component(unsigned i) const
 753 {
 754    switch (this->type->base_type) {
 755    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
 756    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
 757    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
 758    case GLSL_TYPE_BOOL:  return this->value.b[i];
 759    default:              assert(!"Should not get here."); break;
 760    }
 761
 762    /* Must return something to make the compiler happy.  This is clearly an
 763     * error case.
 764     */
 765    return false;
 766 }
 767
 768 float
 769 ir_constant::get_float_component(unsigned i) const
 770 {
 771    switch (this->type->base_type) {
 772    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
 773    case GLSL_TYPE_INT:   return (float) this->value.i[i];
 774    case GLSL_TYPE_FLOAT: return this->value.f[i];
 775    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0 : 0.0;
 776    default:              assert(!"Should not get here."); break;
 777    }
 778
 779    /* Must return something to make the compiler happy.  This is clearly an
 780     * error case.
 781     */
 782    return 0.0;
 783 }
 784
 785 int
 786 ir_constant::get_int_component(unsigned i) const
 787 {
 788    switch (this->type->base_type) {
 789    case GLSL_TYPE_UINT:  return this->value.u[i];
 790    case GLSL_TYPE_INT:   return this->value.i[i];
 791    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
 792    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 793    default:              assert(!"Should not get here."); break;
 794    }
 795
 796    /* Must return something to make the compiler happy.  This is clearly an
 797     * error case.
 798     */
 799    return 0;
 800 }
 801
 802 unsigned
 803 ir_constant::get_uint_component(unsigned i) const
 804 {
 805    switch (this->type->base_type) {
 806    case GLSL_TYPE_UINT:  return this->value.u[i];
 807    case GLSL_TYPE_INT:   return this->value.i[i];
 808    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
 809    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 810    default:              assert(!"Should not get here."); break;
 811    }
 812
 813    /* Must return something to make the compiler happy.  This is clearly an
 814     * error case.
 815     */
 816    return 0;
 817 }
 818
 819 ir_constant *
 820 ir_constant::get_array_element(unsigned i) const
 821 {
 822    assert(this->type->is_array());
 823
 824    /* From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
 825     *
 826     *     "Behavior is undefined if a shader subscripts an array with an index
 827     *     less than 0 or greater than or equal to the size the array was
 828     *     declared with."
 829     *
 830     * Most out-of-bounds accesses are removed before things could get this far.
 831     * There are cases where non-constant array index values can get constant
 832     * folded.
 833     */
 834    if (int(i) < 0)
 835       i = 0;
 836    else if (i >= this->type->length)
 837       i = this->type->length - 1;
 838
 839    return array_elements[i];
 840 }
 841
 842 ir_constant *
 843 ir_constant::get_record_field(const char *name)
 844 {
 845    int idx = this->type->field_index(name);
 846
 847    if (idx < 0)
 848       return NULL;
 849
 850    if (this->components.is_empty())
 851       return NULL;
 852
 853    exec_node *node = this->components.head;
 854    for (int i = 0; i < idx; i++) {
 855       node = node->next;
 856
 857       /* If the end of the list is encountered before the element matching the
 858        * requested field is found, return NULL.
 859        */
 860       if (node->is_tail_sentinel())
 861          return NULL;
 862    }
 863
 864    return (ir_constant *) node;
 865 }
 866
 867 void
 868 ir_constant::copy_offset(ir_constant *src, int offset)
 869 {
 870    switch (this->type->base_type) {
 871    case GLSL_TYPE_UINT:
 872    case GLSL_TYPE_INT:
 873    case GLSL_TYPE_FLOAT:
 874    case GLSL_TYPE_BOOL: {
 875       unsigned int size = src->type->components();
 876       assert (size <= this->type->components() - offset);
 877       for (unsigned int i=0; i<size; i++) {
 878          switch (this->type->base_type) {
 879          case GLSL_TYPE_UINT:
 880             value.u[i+offset] = src->get_uint_component(i);
 881             break;
 882          case GLSL_TYPE_INT:
 883             value.i[i+offset] = src->get_int_component(i);
 884             break;
 885          case GLSL_TYPE_FLOAT:
 886             value.f[i+offset] = src->get_float_component(i);
 887             break;
 888          case GLSL_TYPE_BOOL:
 889             value.b[i+offset] = src->get_bool_component(i);
 890             break;
 891          default: // Shut up the compiler
 892             break;
 893          }
 894       }
 895       break;
 896    }
 897
 898    case GLSL_TYPE_STRUCT: {
 899       assert (src->type == this->type);
 900       this->components.make_empty();
 901       foreach_list(node, &src->components) {
 902          ir_constant *const orig = (ir_constant *) node;
 903
 904          this->components.push_tail(orig->clone(this, NULL));
 905       }
 906       break;
 907    }
 908
 909    case GLSL_TYPE_ARRAY: {
 910       assert (src->type == this->type);
 911       for (unsigned i = 0; i < this->type->length; i++) {
 912          this->array_elements[i] = src->array_elements[i]->clone(this, NULL);
 913       }
 914       break;
 915    }
 916
 917    default:
 918       assert(!"Should not get here.");
 919       break;
 920    }
 921 }
 922
 923 void
 924 ir_constant::copy_masked_offset(ir_constant *src, int offset, unsigned int mask)
 925 {
 926    assert (!type->is_array() && !type->is_record());
 927
 928    if (!type->is_vector() && !type->is_matrix()) {
 929       offset = 0;
 930       mask = 1;
 931    }
 932
 933    int id = 0;
 934    for (int i=0; i<4; i++) {
 935       if (mask & (1 << i)) {
 936          switch (this->type->base_type) {
 937          case GLSL_TYPE_UINT:
 938             value.u[i+offset] = src->get_uint_component(id++);
 939             break;
 940          case GLSL_TYPE_INT:
 941             value.i[i+offset] = src->get_int_component(id++);
 942             break;
 943          case GLSL_TYPE_FLOAT:
 944             value.f[i+offset] = src->get_float_component(id++);
 945             break;
 946          case GLSL_TYPE_BOOL:
 947             value.b[i+offset] = src->get_bool_component(id++);
 948             break;
 949          default:
 950             assert(!"Should not get here.");
 951             return;
 952          }
 953       }
 954    }
 955 }
 956
 957 bool
 958 ir_constant::has_value(const ir_constant *c) const
 959 {
 960    if (this->type != c->type)
 961       return false;
 962
 963    if (this->type->is_array()) {
 964       for (unsigned i = 0; i < this->type->length; i++) {
 965          if (!this->array_elements[i]->has_value(c->array_elements[i]))
 966             return false;
 967       }
 968       return true;
 969    }
 970
 971    if (this->type->base_type == GLSL_TYPE_STRUCT) {
 972       const exec_node *a_node = this->components.head;
 973       const exec_node *b_node = c->components.head;
 974
 975       while (!a_node->is_tail_sentinel()) {
 976          assert(!b_node->is_tail_sentinel());
 977
 978          const ir_constant *const a_field = (ir_constant *) a_node;
 979          const ir_constant *const b_field = (ir_constant *) b_node;
 980
 981          if (!a_field->has_value(b_field))
 982             return false;
 983
 984          a_node = a_node->next;
 985          b_node = b_node->next;
 986       }
 987
 988       return true;
 989    }
 990
 991    for (unsigned i = 0; i < this->type->components(); i++) {
 992       switch (this->type->base_type) {
 993       case GLSL_TYPE_UINT:
 994          if (this->value.u[i] != c->value.u[i])
 995             return false;
 996          break;
 997       case GLSL_TYPE_INT:
 998          if (this->value.i[i] != c->value.i[i])
 999             return false;
1000          break;
1001       case GLSL_TYPE_FLOAT:
1002          if (this->value.f[i] != c->value.f[i])
1003             return false;
1004          break;
1005       case GLSL_TYPE_BOOL:
1006          if (this->value.b[i] != c->value.b[i])
1007             return false;
1008          break;
1009       default:
1010          assert(!"Should not get here.");
1011          return false;
1012       }
1013    }
1014
1015    return true;
1016 }
1017
1018 bool
1019 ir_constant::is_zero() const
1020 {
1021    if (!this->type->is_scalar() && !this->type->is_vector())
1022       return false;
1023
1024    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1025       switch (this->type->base_type) {
1026       case GLSL_TYPE_FLOAT:
1027          if (this->value.f[c] != 0.0)
1028             return false;
1029          break;
1030       case GLSL_TYPE_INT:
1031          if (this->value.i[c] != 0)
1032             return false;
1033          break;
1034       case GLSL_TYPE_UINT:
1035          if (this->value.u[c] != 0)
1036             return false;
1037          break;
1038       case GLSL_TYPE_BOOL:
1039          if (this->value.b[c] != false)
1040             return false;
1041          break;
1042       default:
1043          /* The only other base types are structures, arrays, and samplers.
1044           * Samplers cannot be constants, and the others should have been
1045           * filtered out above.
1046           */
1047          assert(!"Should not get here.");
1048          return false;
1049       }
1050    }
1051
1052    return true;
1053 }
1054
1055 bool
1056 ir_constant::is_one() const
1057 {
1058    if (!this->type->is_scalar() && !this->type->is_vector())
1059       return false;
1060
1061    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1062       switch (this->type->base_type) {
1063       case GLSL_TYPE_FLOAT:
1064          if (this->value.f[c] != 1.0)
1065             return false;
1066          break;
1067       case GLSL_TYPE_INT:
1068          if (this->value.i[c] != 1)
1069             return false;
1070          break;
1071       case GLSL_TYPE_UINT:
1072          if (this->value.u[c] != 1)
1073             return false;
1074          break;
1075       case GLSL_TYPE_BOOL:
1076          if (this->value.b[c] != true)
1077             return false;
1078          break;
1079       default:
1080          /* The only other base types are structures, arrays, and samplers.
1081           * Samplers cannot be constants, and the others should have been
1082           * filtered out above.
1083           */
1084          assert(!"Should not get here.");
1085          return false;
1086       }
1087    }
1088
1089    return true;
1090 }
1091
1092 bool
1093 ir_constant::is_negative_one() const
1094 {
1095    if (!this->type->is_scalar() && !this->type->is_vector())
1096       return false;
1097
1098    if (this->type->is_boolean())
1099       return false;
1100
1101    for (unsigned c = 0; c < this->type->vector_elements; c++) {
1102       switch (this->type->base_type) {
1103       case GLSL_TYPE_FLOAT:
1104          if (this->value.f[c] != -1.0)
1105             return false;
1106          break;
1107       case GLSL_TYPE_INT:
1108          if (this->value.i[c] != -1)
1109             return false;
1110          break;
1111       case GLSL_TYPE_UINT:
1112          if (int(this->value.u[c]) != -1)
1113             return false;
1114          break;
1115       default:
1116          /* The only other base types are structures, arrays, samplers, and
1117           * booleans.  Samplers cannot be constants, and the others should
1118           * have been filtered out above.
1119           */
1120          assert(!"Should not get here.");
1121          return false;
1122       }
1123    }
1124
1125    return true;
1126 }
1127
1128 ir_loop::ir_loop()
1129 {
1130    this->ir_type = ir_type_loop;
1131    this->cmp = ir_unop_neg;
1132    this->from = NULL;
1133    this->to = NULL;
1134    this->increment = NULL;
1135    this->counter = NULL;
1136 }
1137
1138
1139 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
1140 {
1141    assert(var != NULL);
1142
1143    this->ir_type = ir_type_dereference_variable;
1144    this->var = var;
1145    this->type = var->type;
1146 }
1147
1148
1149 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
1150                                            ir_rvalue *array_index)
1151 {
1152    this->ir_type = ir_type_dereference_array;
1153    this->array_index = array_index;
1154    this->set_array(value);
1155 }
1156
1157
1158 ir_dereference_array::ir_dereference_array(ir_variable *var,
1159                                            ir_rvalue *array_index)
1160 {
1161    void *ctx = ralloc_parent(var);
1162
1163    this->ir_type = ir_type_dereference_array;
1164    this->array_index = array_index;
1165    this->set_array(new(ctx) ir_dereference_variable(var));
1166 }
1167
1168
1169 void
1170 ir_dereference_array::set_array(ir_rvalue *value)
1171 {
1172    assert(value != NULL);
1173
1174    this->array = value;
1175
1176    const glsl_type *const vt = this->array->type;
1177
1178    if (vt->is_array()) {
1179       type = vt->element_type();
1180    } else if (vt->is_matrix()) {
1181       type = vt->column_type();
1182    } else if (vt->is_vector()) {
1183       type = vt->get_base_type();
1184    }
1185 }
1186
1187
1188 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
1189                                              const char *field)
1190 {
1191    assert(value != NULL);
1192
1193    this->ir_type = ir_type_dereference_record;
1194    this->record = value;
1195    this->field = ralloc_strdup(this, field);
1196    this->type = this->record->type->field_type(field);
1197 }
1198
1199
1200 ir_dereference_record::ir_dereference_record(ir_variable *var,
1201                                              const char *field)
1202 {
1203    void *ctx = ralloc_parent(var);
1204
1205    this->ir_type = ir_type_dereference_record;
1206    this->record = new(ctx) ir_dereference_variable(var);
1207    this->field = ralloc_strdup(this, field);
1208    this->type = this->record->type->field_type(field);
1209 }
1210
1211 bool
1212 ir_dereference::is_lvalue() const
1213 {
1214    ir_variable *var = this->variable_referenced();
1215
1216    /* Every l-value derference chain eventually ends in a variable.
1217     */
1218    if ((var == NULL) || var->read_only)
1219       return false;
1220
1221    /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec:
1222     *
1223     *    "Samplers cannot be treated as l-values; hence cannot be used
1224     *     as out or inout function parameters, nor can they be
1225     *     assigned into."
1226     */
1227    if (this->type->contains_sampler())
1228       return false;
1229
1230    return true;
1231 }
1232
1233
1234 const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txs" };
1235
1236 const char *ir_texture::opcode_string()
1237 {
1238    assert((unsigned int) op <=
1239           sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
1240    return tex_opcode_strs[op];
1241 }
1242
1243 ir_texture_opcode
1244 ir_texture::get_opcode(const char *str)
1245 {
1246    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
1247    for (int op = 0; op < count; op++) {
1248       if (strcmp(str, tex_opcode_strs[op]) == 0)
1249          return (ir_texture_opcode) op;
1250    }
1251    return (ir_texture_opcode) -1;
1252 }
1253
1254
1255 void
1256 ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)
1257 {
1258    assert(sampler != NULL);
1259    assert(type != NULL);
1260    this->sampler = sampler;
1261    this->type = type;
1262
1263    if (this->op == ir_txs) {
1264       assert(type->base_type == GLSL_TYPE_INT);
1265    } else {
1266       assert(sampler->type->sampler_type == (int) type->base_type);
1267       if (sampler->type->sampler_shadow)
1268          assert(type->vector_elements == 4 || type->vector_elements == 1);
1269       else
1270          assert(type->vector_elements == 4);
1271    }
1272 }
1273
1274
1275 void
1276 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
1277 {
1278    assert((count >= 1) && (count <= 4));
1279
1280    memset(&this->mask, 0, sizeof(this->mask));
1281    this->mask.num_components = count;
1282
1283    unsigned dup_mask = 0;
1284    switch (count) {
1285    case 4:
1286       assert(comp[3] <= 3);
1287       dup_mask |= (1U << comp[3])
1288          & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
1289       this->mask.w = comp[3];
1290
1291    case 3:
1292       assert(comp[2] <= 3);
1293       dup_mask |= (1U << comp[2])
1294          & ((1U << comp[0]) | (1U << comp[1]));
1295       this->mask.z = comp[2];
1296
1297    case 2:
1298       assert(comp[1] <= 3);
1299       dup_mask |= (1U << comp[1])
1300          & ((1U << comp[0]));
1301       this->mask.y = comp[1];
1302
1303    case 1:
1304       assert(comp[0] <= 3);
1305       this->mask.x = comp[0];
1306    }
1307
1308    this->mask.has_duplicates = dup_mask != 0;
1309
1310    /* Based on the number of elements in the swizzle and the base type
1311     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
1312     * generate the type of the resulting value.
1313     */
1314    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
1315 }
1316
1317 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
1318                        unsigned w, unsigned count)
1319    : val(val)
1320 {
1321    const unsigned components[4] = { x, y, z, w };
1322    this->ir_type = ir_type_swizzle;
1323    this->init_mask(components, count);
1324 }
1325
1326 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
1327                        unsigned count)
1328    : val(val)
1329 {
1330    this->ir_type = ir_type_swizzle;
1331    this->init_mask(comp, count);
1332 }
1333
1334 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
1335 {
1336    this->ir_type = ir_type_swizzle;
1337    this->val = val;
1338    this->mask = mask;
1339    this->type = glsl_type::get_instance(val->type->base_type,
1340                                         mask.num_components, 1);
1341 }
1342
1343 #define X 1
1344 #define R 5
1345 #define S 9
1346 #define I 13
1347
1348 ir_swizzle *
1349 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
1350 {
1351    void *ctx = ralloc_parent(val);
1352
1353    /* For each possible swizzle character, this table encodes the value in
1354     * \c idx_map that represents the 0th element of the vector.  For invalid
1355     * swizzle characters (e.g., 'k'), a special value is used that will allow
1356     * detection of errors.
1357     */
1358    static const unsigned char base_idx[26] = {
1359    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
1360       R, R, I, I, I, I, R, I, I, I, I, I, I,
1361    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
1362       I, I, S, S, R, S, S, I, I, X, X, X, X
1363    };
1364
1365    /* Each valid swizzle character has an entry in the previous table.  This
1366     * table encodes the base index encoded in the previous table plus the actual
1367     * index of the swizzle character.  When processing swizzles, the first
1368     * character in the string is indexed in the previous table.  Each character
1369     * in the string is indexed in this table, and the value found there has the
1370     * value form the first table subtracted.  The result must be on the range
1371     * [0,3].
1372     *
1373     * For example, the string "wzyx" will get X from the first table.  Each of
1374     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
1375     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
1376     *
1377     * The string "wzrg" will get X from the first table.  Each of the characters
1378     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
1379     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
1380     * [0,3], the error is detected.
1381     */
1382    static const unsigned char idx_map[26] = {
1383    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
1384       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
1385    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
1386       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
1387    };
1388
1389    int swiz_idx[4] = { 0, 0, 0, 0 };
1390    unsigned i;
1391
1392
1393    /* Validate the first character in the swizzle string and look up the base
1394     * index value as described above.
1395     */
1396    if ((str[0] < 'a') || (str[0] > 'z'))
1397       return NULL;
1398
1399    const unsigned base = base_idx[str[0] - 'a'];
1400
1401
1402    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
1403       /* Validate the next character, and, as described above, convert it to a
1404        * swizzle index.
1405        */
1406       if ((str[i] < 'a') || (str[i] > 'z'))
1407          return NULL;
1408
1409       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
1410       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
1411          return NULL;
1412    }
1413
1414    if (str[i] != '\0')
1415          return NULL;
1416
1417    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
1418                               swiz_idx[3], i);
1419 }
1420
1421 #undef X
1422 #undef R
1423 #undef S
1424 #undef I
1425
1426 ir_variable *
1427 ir_swizzle::variable_referenced() const
1428 {
1429    return this->val->variable_referenced();
1430 }
1431
1432
1433 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
1434                          ir_variable_mode mode)
1435    : max_array_access(0), read_only(false), centroid(false), invariant(false),
1436      mode(mode), interpolation(INTERP_QUALIFIER_NONE)
1437 {
1438    this->ir_type = ir_type_variable;
1439    this->type = type;
1440    this->name = ralloc_strdup(this, name);
1441    this->explicit_location = false;
1442    this->has_initializer = false;
1443    this->location = -1;
1444    this->warn_extension = NULL;
1445    this->constant_value = NULL;
1446    this->constant_initializer = NULL;
1447    this->origin_upper_left = false;
1448    this->pixel_center_integer = false;
1449    this->depth_layout = ir_depth_layout_none;
1450    this->used = false;
1451
1452    if (type && type->base_type == GLSL_TYPE_SAMPLER)
1453       this->read_only = true;
1454 }
1455
1456
1457 const char *
1458 ir_variable::interpolation_string() const
1459 {
1460    switch (this->interpolation) {
1461    case INTERP_QUALIFIER_NONE:          return "no";
1462    case INTERP_QUALIFIER_SMOOTH:        return "smooth";
1463    case INTERP_QUALIFIER_FLAT:          return "flat";
1464    case INTERP_QUALIFIER_NOPERSPECTIVE: return "noperspective";
1465    }
1466
1467    assert(!"Should not get here.");
1468    return "";
1469 }
1470
1471
1472 glsl_interp_qualifier
1473 ir_variable::determine_interpolation_mode(bool flat_shade)
1474 {
1475    if (this->interpolation != INTERP_QUALIFIER_NONE)
1476       return (glsl_interp_qualifier) this->interpolation;
1477    int location = this->location;
1478    bool is_gl_Color =
1479       location == FRAG_ATTRIB_COL0 || location == FRAG_ATTRIB_COL1;
1480    if (flat_shade && is_gl_Color)
1481       return INTERP_QUALIFIER_FLAT;
1482    else
1483       return INTERP_QUALIFIER_SMOOTH;
1484 }
1485
1486
1487 ir_function_signature::ir_function_signature(const glsl_type *return_type)
1488    : return_type(return_type), is_defined(false), _function(NULL)
1489 {
1490    this->ir_type = ir_type_function_signature;
1491    this->is_builtin = false;
1492    this->origin = NULL;
1493 }
1494
1495
1496 static bool
1497 modes_match(unsigned a, unsigned b)
1498 {
1499    if (a == b)
1500       return true;
1501
1502    /* Accept "in" vs. "const in" */
1503    if ((a == ir_var_const_in && b == ir_var_in) ||
1504        (b == ir_var_const_in && a == ir_var_in))
1505       return true;
1506
1507    return false;
1508 }
1509
1510
1511 const char *
1512 ir_function_signature::qualifiers_match(exec_list *params)
1513 {
1514    exec_list_iterator iter_a = parameters.iterator();
1515    exec_list_iterator iter_b = params->iterator();
1516
1517    /* check that the qualifiers match. */
1518    while (iter_a.has_next()) {
1519       ir_variable *a = (ir_variable *)iter_a.get();
1520       ir_variable *b = (ir_variable *)iter_b.get();
1521
1522       if (a->read_only != b->read_only ||
1523           !modes_match(a->mode, b->mode) ||
1524           a->interpolation != b->interpolation ||
1525           a->centroid != b->centroid) {
1526
1527          /* parameter a's qualifiers don't match */
1528          return a->name;
1529       }
1530
1531       iter_a.next();
1532       iter_b.next();
1533    }
1534    return NULL;
1535 }
1536
1537
1538 void
1539 ir_function_signature::replace_parameters(exec_list *new_params)
1540 {
1541    /* Destroy all of the previous parameter information.  If the previous
1542     * parameter information comes from the function prototype, it may either
1543     * specify incorrect parameter names or not have names at all.
1544     */
1545    foreach_iter(exec_list_iterator, iter, parameters) {
1546       assert(((ir_instruction *) iter.get())->as_variable() != NULL);
1547
1548       iter.remove();
1549    }
1550
1551    new_params->move_nodes_to(&parameters);
1552 }
1553
1554
1555 ir_function::ir_function(const char *name)
1556 {
1557    this->ir_type = ir_type_function;
1558    this->name = ralloc_strdup(this, name);
1559 }
1560
1561
1562 bool
1563 ir_function::has_user_signature()
1564 {
1565    foreach_list(n, &this->signatures) {
1566       ir_function_signature *const sig = (ir_function_signature *) n;
1567       if (!sig->is_builtin)
1568          return true;
1569    }
1570    return false;
1571 }
1572
1573
1574 ir_rvalue *
1575 ir_rvalue::error_value(void *mem_ctx)
1576 {
1577    ir_rvalue *v = new(mem_ctx) ir_rvalue;
1578
1579    v->type = glsl_type::error_type;
1580    return v;
1581 }
1582
1583
1584 void
1585 visit_exec_list(exec_list *list, ir_visitor *visitor)
1586 {
1587    foreach_iter(exec_list_iterator, iter, *list) {
1588       ((ir_instruction *)iter.get())->accept(visitor);
1589    }
1590 }
1591
1592
1593 static void
1594 steal_memory(ir_instruction *ir, void *new_ctx)
1595 {
1596    ir_variable *var = ir->as_variable();
1597    ir_constant *constant = ir->as_constant();
1598    if (var != NULL && var->constant_value != NULL)
1599       steal_memory(var->constant_value, ir);
1600
1601    if (var != NULL && var->constant_initializer != NULL)
1602       steal_memory(var->constant_initializer, ir);
1603
1604    /* The components of aggregate constants are not visited by the normal
1605     * visitor, so steal their values by hand.
1606     */
1607    if (constant != NULL) {
1608       if (constant->type->is_record()) {
1609          foreach_iter(exec_list_iterator, iter, constant->components) {
1610             ir_constant *field = (ir_constant *)iter.get();
1611             steal_memory(field, ir);
1612          }
1613       } else if (constant->type->is_array()) {
1614          for (unsigned int i = 0; i < constant->type->length; i++) {
1615             steal_memory(constant->array_elements[i], ir);
1616          }
1617       }
1618    }
1619
1620    ralloc_steal(new_ctx, ir);
1621 }
1622
1623
1624 void
1625 reparent_ir(exec_list *list, void *mem_ctx)
1626 {
1627    foreach_list(node, list) {
1628       visit_tree((ir_instruction *) node, steal_memory, mem_ctx);
1629    }
1630 }
1631
1632
1633 static ir_rvalue *
1634 try_min_one(ir_rvalue *ir)
1635 {
1636    ir_expression *expr = ir->as_expression();
1637
1638    if (!expr || expr->operation != ir_binop_min)
1639       return NULL;
1640
1641    if (expr->operands[0]->is_one())
1642       return expr->operands[1];
1643
1644    if (expr->operands[1]->is_one())
1645       return expr->operands[0];
1646
1647    return NULL;
1648 }
1649
1650 static ir_rvalue *
1651 try_max_zero(ir_rvalue *ir)
1652 {
1653    ir_expression *expr = ir->as_expression();
1654
1655    if (!expr || expr->operation != ir_binop_max)
1656       return NULL;
1657
1658    if (expr->operands[0]->is_zero())
1659       return expr->operands[1];
1660
1661    if (expr->operands[1]->is_zero())
1662       return expr->operands[0];
1663
1664    return NULL;
1665 }
1666
1667 ir_rvalue *
1668 ir_rvalue::as_rvalue_to_saturate()
1669 {
1670    ir_expression *expr = this->as_expression();
1671
1672    if (!expr)
1673       return NULL;
1674
1675    ir_rvalue *max_zero = try_max_zero(expr);
1676    if (max_zero) {
1677       return try_min_one(max_zero);
1678    } else {
1679       ir_rvalue *min_one = try_min_one(expr);
1680       if (min_one) {
1681          return try_max_zero(min_one);
1682       }
1683    }
1684
1685    return NULL;
1686 }