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