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