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/imports.h"
  25 #include "ir.h"
  26 #include "ir_visitor.h"
  27 #include "glsl_types.h"
  28
  29 ir_assignment::ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs,
  30                              ir_rvalue *condition)
  31 {
  32    this->ir_type = ir_type_assignment;
  33    this->lhs = lhs;
  34    this->rhs = rhs;
  35    this->condition = condition;
  36 }
  37
  38
  39 ir_expression::ir_expression(int op, const struct glsl_type *type,
  40                              ir_rvalue *op0, ir_rvalue *op1)
  41 {
  42    this->ir_type = ir_type_expression;
  43    this->type = type;
  44    this->operation = ir_expression_operation(op);
  45    this->operands[0] = op0;
  46    this->operands[1] = op1;
  47 }
  48
  49 unsigned int
  50 ir_expression::get_num_operands(ir_expression_operation op)
  51 {
  52 /* Update ir_print_visitor.cpp when updating this list. */
  53    const int num_operands[] = {
  54       1, /* ir_unop_bit_not */
  55       1, /* ir_unop_logic_not */
  56       1, /* ir_unop_neg */
  57       1, /* ir_unop_abs */
  58       1, /* ir_unop_sign */
  59       1, /* ir_unop_rcp */
  60       1, /* ir_unop_rsq */
  61       1, /* ir_unop_sqrt */
  62       1, /* ir_unop_exp */
  63       1, /* ir_unop_log */
  64       1, /* ir_unop_exp2 */
  65       1, /* ir_unop_log2 */
  66       1, /* ir_unop_f2i */
  67       1, /* ir_unop_i2f */
  68       1, /* ir_unop_f2b */
  69       1, /* ir_unop_b2f */
  70       1, /* ir_unop_i2b */
  71       1, /* ir_unop_b2i */
  72       1, /* ir_unop_u2f */
  73
  74       1, /* ir_unop_trunc */
  75       1, /* ir_unop_ceil */
  76       1, /* ir_unop_floor */
  77       1, /* ir_unop_fract */
  78
  79       1, /* ir_unop_sin */
  80       1, /* ir_unop_cos */
  81
  82       1, /* ir_unop_dFdx */
  83       1, /* ir_unop_dFdy */
  84
  85       2, /* ir_binop_add */
  86       2, /* ir_binop_sub */
  87       2, /* ir_binop_mul */
  88       2, /* ir_binop_div */
  89       2, /* ir_binop_mod */
  90
  91       2, /* ir_binop_less */
  92       2, /* ir_binop_greater */
  93       2, /* ir_binop_lequal */
  94       2, /* ir_binop_gequal */
  95       2, /* ir_binop_equal */
  96       2, /* ir_binop_nequal */
  97
  98       2, /* ir_binop_lshift */
  99       2, /* ir_binop_rshift */
 100       2, /* ir_binop_bit_and */
 101       2, /* ir_binop_bit_xor */
 102       2, /* ir_binop_bit_or */
 103
 104       2, /* ir_binop_logic_and */
 105       2, /* ir_binop_logic_xor */
 106       2, /* ir_binop_logic_or */
 107
 108       2, /* ir_binop_dot */
 109       2, /* ir_binop_cross */
 110       2, /* ir_binop_min */
 111       2, /* ir_binop_max */
 112
 113       2, /* ir_binop_pow */
 114    };
 115
 116    assert(sizeof(num_operands) / sizeof(num_operands[0]) == ir_binop_pow + 1);
 117
 118    return num_operands[op];
 119 }
 120
 121 static const char *const operator_strs[] = {
 122    "~",
 123    "!",
 124    "neg",
 125    "abs",
 126    "sign",
 127    "rcp",
 128    "rsq",
 129    "sqrt",
 130    "exp",
 131    "log",
 132    "exp2",
 133    "log2",
 134    "f2i",
 135    "i2f",
 136    "f2b",
 137    "b2f",
 138    "i2b",
 139    "b2i",
 140    "u2f",
 141    "trunc",
 142    "ceil",
 143    "floor",
 144    "fract",
 145    "sin",
 146    "cos",
 147    "dFdx",
 148    "dFdy",
 149    "+",
 150    "-",
 151    "*",
 152    "/",
 153    "%",
 154    "<",
 155    ">",
 156    "<=",
 157    ">=",
 158    "==",
 159    "!=",
 160    "<<",
 161    ">>",
 162    "&",
 163    "^",
 164    "|",
 165    "&&",
 166    "^^",
 167    "||",
 168    "dot",
 169    "cross",
 170    "min",
 171    "max",
 172    "pow",
 173 };
 174
 175 const char *ir_expression::operator_string()
 176 {
 177    assert((unsigned int) operation <=
 178           sizeof(operator_strs) / sizeof(operator_strs[0]));
 179    return operator_strs[operation];
 180 }
 181
 182 ir_expression_operation
 183 ir_expression::get_operator(const char *str)
 184 {
 185    const int operator_count = sizeof(operator_strs) / sizeof(operator_strs[0]);
 186    for (int op = 0; op < operator_count; op++) {
 187       if (strcmp(str, operator_strs[op]) == 0)
 188          return (ir_expression_operation) op;
 189    }
 190    return (ir_expression_operation) -1;
 191 }
 192
 193 ir_constant::ir_constant()
 194 {
 195    this->ir_type = ir_type_constant;
 196 }
 197
 198 ir_constant::ir_constant(const struct glsl_type *type,
 199                          const ir_constant_data *data)
 200 {
 201    assert((type->base_type >= GLSL_TYPE_UINT)
 202           && (type->base_type <= GLSL_TYPE_BOOL));
 203
 204    this->ir_type = ir_type_constant;
 205    this->type = type;
 206    memcpy(& this->value, data, sizeof(this->value));
 207 }
 208
 209 ir_constant::ir_constant(float f)
 210 {
 211    this->ir_type = ir_type_constant;
 212    this->type = glsl_type::float_type;
 213    this->value.f[0] = f;
 214 }
 215
 216 ir_constant::ir_constant(unsigned int u)
 217 {
 218    this->ir_type = ir_type_constant;
 219    this->type = glsl_type::uint_type;
 220    this->value.u[0] = u;
 221 }
 222
 223 ir_constant::ir_constant(int i)
 224 {
 225    this->ir_type = ir_type_constant;
 226    this->type = glsl_type::int_type;
 227    this->value.i[0] = i;
 228 }
 229
 230 ir_constant::ir_constant(bool b)
 231 {
 232    this->ir_type = ir_type_constant;
 233    this->type = glsl_type::bool_type;
 234    this->value.b[0] = b;
 235 }
 236
 237 ir_constant::ir_constant(const ir_constant *c, unsigned i)
 238 {
 239    this->ir_type = ir_type_constant;
 240    this->type = c->type->get_base_type();
 241
 242    switch (this->type->base_type) {
 243    case GLSL_TYPE_UINT:  this->value.u[0] = c->value.u[i]; break;
 244    case GLSL_TYPE_INT:   this->value.i[0] = c->value.i[i]; break;
 245    case GLSL_TYPE_FLOAT: this->value.f[0] = c->value.f[i]; break;
 246    case GLSL_TYPE_BOOL:  this->value.b[0] = c->value.b[i]; break;
 247    default:              assert(!"Should not get here."); break;
 248    }
 249 }
 250
 251 ir_constant::ir_constant(const struct glsl_type *type, exec_list *value_list)
 252 {
 253    this->ir_type = ir_type_constant;
 254    this->type = type;
 255
 256    /* FINISHME: Support array types. */
 257    assert(type->is_scalar() || type->is_vector() || type->is_matrix()
 258           || type->is_record());
 259
 260    /* If the constant is a record, the types of each of the entries in
 261     * value_list must be a 1-for-1 match with the structure components.  Each
 262     * entry must also be a constant.  Just move the nodes from the value_list
 263     * to the list in the ir_constant.
 264     */
 265    /* FINISHME: Should there be some type checking and / or assertions here? */
 266    /* FINISHME: Should the new constant take ownership of the nodes from
 267     * FINISHME: value_list, or should it make copies?
 268     */
 269    if (type->is_record()) {
 270       value_list->move_nodes_to(& this->components);
 271       return;
 272    }
 273
 274
 275    ir_constant *value = (ir_constant *) (value_list->head);
 276
 277    /* Use each component from each entry in the value_list to initialize one
 278     * component of the constant being constructed.
 279     */
 280    for (unsigned i = 0; i < type->components(); /* empty */) {
 281       assert(value->as_constant() != NULL);
 282       assert(!value->is_tail_sentinal());
 283
 284       for (unsigned j = 0; j < value->type->components(); j++) {
 285          switch (type->base_type) {
 286          case GLSL_TYPE_UINT:
 287             this->value.u[i] = value->get_uint_component(j);
 288             break;
 289          case GLSL_TYPE_INT:
 290             this->value.i[i] = value->get_int_component(j);
 291             break;
 292          case GLSL_TYPE_FLOAT:
 293             this->value.f[i] = value->get_float_component(j);
 294             break;
 295          case GLSL_TYPE_BOOL:
 296             this->value.b[i] = value->get_bool_component(j);
 297             break;
 298          default:
 299             /* FINISHME: What to do?  Exceptions are not the answer.
 300              */
 301             break;
 302          }
 303
 304          i++;
 305          if (i >= type->components())
 306             break;
 307       }
 308
 309       value = (ir_constant *) value->next;
 310    }
 311 }
 312
 313 bool
 314 ir_constant::get_bool_component(unsigned i) const
 315 {
 316    switch (this->type->base_type) {
 317    case GLSL_TYPE_UINT:  return this->value.u[i] != 0;
 318    case GLSL_TYPE_INT:   return this->value.i[i] != 0;
 319    case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0;
 320    case GLSL_TYPE_BOOL:  return this->value.b[i];
 321    default:              assert(!"Should not get here."); break;
 322    }
 323
 324    /* Must return something to make the compiler happy.  This is clearly an
 325     * error case.
 326     */
 327    return false;
 328 }
 329
 330 float
 331 ir_constant::get_float_component(unsigned i) const
 332 {
 333    switch (this->type->base_type) {
 334    case GLSL_TYPE_UINT:  return (float) this->value.u[i];
 335    case GLSL_TYPE_INT:   return (float) this->value.i[i];
 336    case GLSL_TYPE_FLOAT: return this->value.f[i];
 337    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1.0 : 0.0;
 338    default:              assert(!"Should not get here."); break;
 339    }
 340
 341    /* Must return something to make the compiler happy.  This is clearly an
 342     * error case.
 343     */
 344    return 0.0;
 345 }
 346
 347 int
 348 ir_constant::get_int_component(unsigned i) const
 349 {
 350    switch (this->type->base_type) {
 351    case GLSL_TYPE_UINT:  return this->value.u[i];
 352    case GLSL_TYPE_INT:   return this->value.i[i];
 353    case GLSL_TYPE_FLOAT: return (int) this->value.f[i];
 354    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 355    default:              assert(!"Should not get here."); break;
 356    }
 357
 358    /* Must return something to make the compiler happy.  This is clearly an
 359     * error case.
 360     */
 361    return 0;
 362 }
 363
 364 unsigned
 365 ir_constant::get_uint_component(unsigned i) const
 366 {
 367    switch (this->type->base_type) {
 368    case GLSL_TYPE_UINT:  return this->value.u[i];
 369    case GLSL_TYPE_INT:   return this->value.i[i];
 370    case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i];
 371    case GLSL_TYPE_BOOL:  return this->value.b[i] ? 1 : 0;
 372    default:              assert(!"Should not get here."); break;
 373    }
 374
 375    /* Must return something to make the compiler happy.  This is clearly an
 376     * error case.
 377     */
 378    return 0;
 379 }
 380
 381
 382 ir_constant *
 383 ir_constant::get_record_field(const char *name)
 384 {
 385    int idx = this->type->field_index(name);
 386
 387    if (idx < 0)
 388       return NULL;
 389
 390    if (this->components.is_empty())
 391       return NULL;
 392
 393    exec_node *node = this->components.head;
 394    for (int i = 0; i < idx; i++) {
 395       node = node->next;
 396
 397       /* If the end of the list is encountered before the element matching the
 398        * requested field is found, return NULL.
 399        */
 400       if (node->is_tail_sentinal())
 401          return NULL;
 402    }
 403
 404    return (ir_constant *) node;
 405 }
 406
 407
 408 bool
 409 ir_constant::has_value(const ir_constant *c) const
 410 {
 411    if (this->type != c->type)
 412       return false;
 413
 414    /* FINISHME: This will probably also handle constant arrays as soon as those
 415     * FINISHME: are supported.
 416     */
 417    if (this->type->base_type == GLSL_TYPE_STRUCT) {
 418       const exec_node *a_node = this->components.head;
 419       const exec_node *b_node = c->components.head;
 420
 421       while (!a_node->is_tail_sentinal()) {
 422          assert(!b_node->is_tail_sentinal());
 423
 424          const ir_constant *const a_field = (ir_constant *) a_node;
 425          const ir_constant *const b_field = (ir_constant *) b_node;
 426
 427          if (!a_field->has_value(b_field))
 428             return false;
 429
 430          a_node = a_node->next;
 431          b_node = b_node->next;
 432       }
 433
 434       return true;
 435    }
 436
 437    for (unsigned i = 0; i < this->type->components(); i++) {
 438       switch (this->type->base_type) {
 439       case GLSL_TYPE_UINT:
 440          if (this->value.u[i] != c->value.u[i])
 441             return false;
 442          break;
 443       case GLSL_TYPE_INT:
 444          if (this->value.i[i] != c->value.i[i])
 445             return false;
 446          break;
 447       case GLSL_TYPE_FLOAT:
 448          if (this->value.f[i] != c->value.f[i])
 449             return false;
 450          break;
 451       case GLSL_TYPE_BOOL:
 452          if (this->value.b[i] != c->value.b[i])
 453             return false;
 454          break;
 455       default:
 456          assert(!"Should not get here.");
 457          return false;
 458       }
 459    }
 460
 461    return true;
 462 }
 463
 464 ir_dereference_variable::ir_dereference_variable(ir_variable *var)
 465 {
 466    this->ir_type = ir_type_dereference_variable;
 467    this->var = var;
 468    this->type = (var != NULL) ? var->type : glsl_type::error_type;
 469 }
 470
 471
 472 ir_dereference_array::ir_dereference_array(ir_rvalue *value,
 473                                            ir_rvalue *array_index)
 474 {
 475    this->ir_type = ir_type_dereference_array;
 476    this->array_index = array_index;
 477    this->set_array(value);
 478 }
 479
 480
 481 ir_dereference_array::ir_dereference_array(ir_variable *var,
 482                                            ir_rvalue *array_index)
 483 {
 484    void *ctx = talloc_parent(var);
 485
 486    this->ir_type = ir_type_dereference_array;
 487    this->array_index = array_index;
 488    this->set_array(new(ctx) ir_dereference_variable(var));
 489 }
 490
 491
 492 void
 493 ir_dereference_array::set_array(ir_rvalue *value)
 494 {
 495    this->array = value;
 496    this->type = glsl_type::error_type;
 497
 498    if (this->array != NULL) {
 499       const glsl_type *const vt = this->array->type;
 500
 501       if (vt->is_array()) {
 502          type = vt->element_type();
 503       } else if (vt->is_matrix()) {
 504          type = vt->column_type();
 505       } else if (vt->is_vector()) {
 506          type = vt->get_base_type();
 507       }
 508    }
 509 }
 510
 511
 512 ir_dereference_record::ir_dereference_record(ir_rvalue *value,
 513                                              const char *field)
 514 {
 515    this->ir_type = ir_type_dereference_record;
 516    this->record = value;
 517    this->field = talloc_strdup(this, field);
 518    this->type = (this->record != NULL)
 519       ? this->record->type->field_type(field) : glsl_type::error_type;
 520 }
 521
 522
 523 ir_dereference_record::ir_dereference_record(ir_variable *var,
 524                                              const char *field)
 525 {
 526    void *ctx = talloc_parent(var);
 527
 528    this->ir_type = ir_type_dereference_record;
 529    this->record = new(ctx) ir_dereference_variable(var);
 530    this->field = talloc_strdup(this, field);
 531    this->type = (this->record != NULL)
 532       ? this->record->type->field_type(field) : glsl_type::error_type;
 533 }
 534
 535
 536 bool
 537 ir_dereference::is_lvalue()
 538 {
 539    ir_variable *var = this->variable_referenced();
 540
 541    /* Every l-value derference chain eventually ends in a variable.
 542     */
 543    if ((var == NULL) || var->read_only)
 544       return false;
 545
 546    if (this->type->is_array() && !var->array_lvalue)
 547       return false;
 548
 549    return true;
 550 }
 551
 552
 553 const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf" };
 554
 555 const char *ir_texture::opcode_string()
 556 {
 557    assert((unsigned int) op <=
 558           sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]));
 559    return tex_opcode_strs[op];
 560 }
 561
 562 ir_texture_opcode
 563 ir_texture::get_opcode(const char *str)
 564 {
 565    const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);
 566    for (int op = 0; op < count; op++) {
 567       if (strcmp(str, tex_opcode_strs[op]) == 0)
 568          return (ir_texture_opcode) op;
 569    }
 570    return (ir_texture_opcode) -1;
 571 }
 572
 573
 574 void
 575 ir_texture::set_sampler(ir_dereference *sampler)
 576 {
 577    assert(sampler != NULL);
 578    this->sampler = sampler;
 579
 580    switch (sampler->type->sampler_type) {
 581    case GLSL_TYPE_FLOAT:
 582       this->type = glsl_type::vec4_type;
 583       break;
 584    case GLSL_TYPE_INT:
 585       this->type = glsl_type::ivec4_type;
 586       break;
 587    case GLSL_TYPE_UINT:
 588       this->type = glsl_type::uvec4_type;
 589       break;
 590    }
 591 }
 592
 593
 594 void
 595 ir_swizzle::init_mask(const unsigned *comp, unsigned count)
 596 {
 597    assert((count >= 1) && (count <= 4));
 598
 599    memset(&this->mask, 0, sizeof(this->mask));
 600    this->mask.num_components = count;
 601
 602    unsigned dup_mask = 0;
 603    switch (count) {
 604    case 4:
 605       assert(comp[3] <= 3);
 606       dup_mask |= (1U << comp[3])
 607          & ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));
 608       this->mask.w = comp[3];
 609
 610    case 3:
 611       assert(comp[2] <= 3);
 612       dup_mask |= (1U << comp[2])
 613          & ((1U << comp[0]) | (1U << comp[1]));
 614       this->mask.z = comp[2];
 615
 616    case 2:
 617       assert(comp[1] <= 3);
 618       dup_mask |= (1U << comp[1])
 619          & ((1U << comp[0]));
 620       this->mask.y = comp[1];
 621
 622    case 1:
 623       assert(comp[0] <= 3);
 624       this->mask.x = comp[0];
 625    }
 626
 627    this->mask.has_duplicates = dup_mask != 0;
 628
 629    /* Based on the number of elements in the swizzle and the base type
 630     * (i.e., float, int, unsigned, or bool) of the vector being swizzled,
 631     * generate the type of the resulting value.
 632     */
 633    type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);
 634 }
 635
 636 ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,
 637                        unsigned w, unsigned count)
 638    : val(val)
 639 {
 640    const unsigned components[4] = { x, y, z, w };
 641    this->ir_type = ir_type_swizzle;
 642    this->init_mask(components, count);
 643 }
 644
 645 ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,
 646                        unsigned count)
 647    : val(val)
 648 {
 649    this->ir_type = ir_type_swizzle;
 650    this->init_mask(comp, count);
 651 }
 652
 653 ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)
 654 {
 655    this->ir_type = ir_type_swizzle;
 656    this->val = val;
 657    this->mask = mask;
 658    this->type = glsl_type::get_instance(val->type->base_type,
 659                                         mask.num_components, 1);
 660 }
 661
 662 #define X 1
 663 #define R 5
 664 #define S 9
 665 #define I 13
 666
 667 ir_swizzle *
 668 ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)
 669 {
 670    void *ctx = talloc_parent(val);
 671
 672    /* For each possible swizzle character, this table encodes the value in
 673     * \c idx_map that represents the 0th element of the vector.  For invalid
 674     * swizzle characters (e.g., 'k'), a special value is used that will allow
 675     * detection of errors.
 676     */
 677    static const unsigned char base_idx[26] = {
 678    /* a  b  c  d  e  f  g  h  i  j  k  l  m */
 679       R, R, I, I, I, I, R, I, I, I, I, I, I,
 680    /* n  o  p  q  r  s  t  u  v  w  x  y  z */
 681       I, I, S, S, R, S, S, I, I, X, X, X, X
 682    };
 683
 684    /* Each valid swizzle character has an entry in the previous table.  This
 685     * table encodes the base index encoded in the previous table plus the actual
 686     * index of the swizzle character.  When processing swizzles, the first
 687     * character in the string is indexed in the previous table.  Each character
 688     * in the string is indexed in this table, and the value found there has the
 689     * value form the first table subtracted.  The result must be on the range
 690     * [0,3].
 691     *
 692     * For example, the string "wzyx" will get X from the first table.  Each of
 693     * the charcaters will get X+3, X+2, X+1, and X+0 from this table.  After
 694     * subtraction, the swizzle values are { 3, 2, 1, 0 }.
 695     *
 696     * The string "wzrg" will get X from the first table.  Each of the characters
 697     * will get X+3, X+2, R+0, and R+1 from this table.  After subtraction, the
 698     * swizzle values are { 3, 2, 4, 5 }.  Since 4 and 5 are outside the range
 699     * [0,3], the error is detected.
 700     */
 701    static const unsigned char idx_map[26] = {
 702    /* a    b    c    d    e    f    g    h    i    j    k    l    m */
 703       R+3, R+2, 0,   0,   0,   0,   R+1, 0,   0,   0,   0,   0,   0,
 704    /* n    o    p    q    r    s    t    u    v    w    x    y    z */
 705       0,   0,   S+2, S+3, R+0, S+0, S+1, 0,   0,   X+3, X+0, X+1, X+2
 706    };
 707
 708    int swiz_idx[4] = { 0, 0, 0, 0 };
 709    unsigned i;
 710
 711
 712    /* Validate the first character in the swizzle string and look up the base
 713     * index value as described above.
 714     */
 715    if ((str[0] < 'a') || (str[0] > 'z'))
 716       return NULL;
 717
 718    const unsigned base = base_idx[str[0] - 'a'];
 719
 720
 721    for (i = 0; (i < 4) && (str[i] != '\0'); i++) {
 722       /* Validate the next character, and, as described above, convert it to a
 723        * swizzle index.
 724        */
 725       if ((str[i] < 'a') || (str[i] > 'z'))
 726          return NULL;
 727
 728       swiz_idx[i] = idx_map[str[i] - 'a'] - base;
 729       if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))
 730          return NULL;
 731    }
 732
 733    if (str[i] != '\0')
 734          return NULL;
 735
 736    return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],
 737                               swiz_idx[3], i);
 738 }
 739
 740 #undef X
 741 #undef R
 742 #undef S
 743 #undef I
 744
 745 ir_variable *
 746 ir_swizzle::variable_referenced()
 747 {
 748    return this->val->variable_referenced();
 749 }
 750
 751
 752 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
 753                          ir_variable_mode mode)
 754    : max_array_access(0), read_only(false), centroid(false), invariant(false),
 755      shader_in(false), shader_out(false),
 756      mode(mode), interpolation(ir_var_smooth), array_lvalue(false)
 757 {
 758    this->ir_type = ir_type_variable;
 759    this->type = type;
 760    this->name = talloc_strdup(this, name);
 761    this->location = -1;
 762    this->warn_extension = NULL;
 763    this->constant_value = NULL;
 764
 765    if (type && type->base_type == GLSL_TYPE_SAMPLER)
 766       this->read_only = true;
 767 }
 768
 769
 770 const char *
 771 ir_variable::interpolation_string() const
 772 {
 773    if (!this->shader_in && !this->shader_out)
 774       return "";
 775
 776    switch (this->interpolation) {
 777    case ir_var_smooth:        return "smooth";
 778    case ir_var_flat:          return "flat";
 779    case ir_var_noperspective: return "noperspective";
 780    }
 781
 782    assert(!"Should not get here.");
 783    return "";
 784 }
 785
 786
 787 unsigned
 788 ir_variable::component_slots() const
 789 {
 790    /* FINISHME: Sparsely accessed arrays require fewer slots. */
 791    return this->type->component_slots();
 792 }
 793
 794
 795 ir_function_signature::ir_function_signature(const glsl_type *return_type)
 796    : return_type(return_type), is_defined(false), _function(NULL)
 797 {
 798    this->ir_type = ir_type_function_signature;
 799 }
 800
 801
 802 const char *
 803 ir_function_signature::qualifiers_match(exec_list *params)
 804 {
 805    exec_list_iterator iter_a = parameters.iterator();
 806    exec_list_iterator iter_b = params->iterator();
 807
 808    /* check that the qualifiers match. */
 809    while (iter_a.has_next()) {
 810       ir_variable *a = (ir_variable *)iter_a.get();
 811       ir_variable *b = (ir_variable *)iter_b.get();
 812
 813       if (a->read_only != b->read_only ||
 814           a->mode != b->mode ||
 815           a->interpolation != b->interpolation ||
 816           a->centroid != b->centroid) {
 817
 818          /* parameter a's qualifiers don't match */
 819          return a->name;
 820       }
 821
 822       iter_a.next();
 823       iter_b.next();
 824    }
 825    return NULL;
 826 }
 827
 828
 829 void
 830 ir_function_signature::replace_parameters(exec_list *new_params)
 831 {
 832    /* Destroy all of the previous parameter information.  If the previous
 833     * parameter information comes from the function prototype, it may either
 834     * specify incorrect parameter names or not have names at all.
 835     */
 836    foreach_iter(exec_list_iterator, iter, parameters) {
 837       assert(((ir_instruction *) iter.get())->as_variable() != NULL);
 838
 839       iter.remove();
 840    }
 841
 842    new_params->move_nodes_to(&parameters);
 843 }
 844
 845
 846 ir_function::ir_function(const char *name)
 847 {
 848    this->ir_type = ir_type_function;
 849    this->name = talloc_strdup(this, name);
 850 }
 851
 852
 853 ir_call *
 854 ir_call::get_error_instruction(void *ctx)
 855 {
 856    ir_call *call = new(ctx) ir_call;
 857
 858    call->type = glsl_type::error_type;
 859    return call;
 860 }
 861
 862 void
 863 ir_call::set_callee(ir_function_signature *sig)
 864 {
 865    assert((this->type == NULL) || (this->type == sig->return_type));
 866
 867    this->callee = sig;
 868 }
 869
 870 void
 871 visit_exec_list(exec_list *list, ir_visitor *visitor)
 872 {
 873    foreach_iter(exec_list_iterator, iter, *list) {
 874       ((ir_instruction *)iter.get())->accept(visitor);
 875    }
 876 }
 877
 878
 879 static void
 880 steal_memory(ir_instruction *ir, void *new_ctx)
 881 {
 882    talloc_steal(new_ctx, ir);
 883 }
 884
 885
 886 void
 887 reparent_ir(exec_list *list, void *mem_ctx)
 888 {
 889    foreach_list(node, list) {
 890       visit_tree((ir_instruction *) node, steal_memory, mem_ctx);
 891    }
 892 }