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