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