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