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