ir.cpp revision 29285882676388aacff123e8bdf025904abf8ea9
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 29ir_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 38ir_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 47unsigned int 48ir_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 117static 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 169const 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 176ir_expression_operation 177ir_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 187ir_constant::ir_constant() 188{ 189 /* empty */ 190} 191 192ir_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 202ir_constant::ir_constant(float f) 203{ 204 this->type = glsl_type::float_type; 205 this->value.f[0] = f; 206} 207 208ir_constant::ir_constant(unsigned int u) 209{ 210 this->type = glsl_type::uint_type; 211 this->value.u[0] = u; 212} 213 214ir_constant::ir_constant(int i) 215{ 216 this->type = glsl_type::int_type; 217 this->value.i[0] = i; 218} 219 220ir_constant::ir_constant(bool b) 221{ 222 this->type = glsl_type::bool_type; 223 this->value.b[0] = b; 224} 225 226ir_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 239ir_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 300bool 301ir_constant::get_bool_component(unsigned i) const 302{ 303 switch (this->type->base_type) { 304 case GLSL_TYPE_UINT: return this->value.u[i] != 0; 305 case GLSL_TYPE_INT: return this->value.i[i] != 0; 306 case GLSL_TYPE_FLOAT: return ((int)this->value.f[i]) != 0; 307 case GLSL_TYPE_BOOL: return this->value.b[i]; 308 default: assert(!"Should not get here."); break; 309 } 310 311 /* Must return something to make the compiler happy. This is clearly an 312 * error case. 313 */ 314 return false; 315} 316 317float 318ir_constant::get_float_component(unsigned i) const 319{ 320 switch (this->type->base_type) { 321 case GLSL_TYPE_UINT: return (float) this->value.u[i]; 322 case GLSL_TYPE_INT: return (float) this->value.i[i]; 323 case GLSL_TYPE_FLOAT: return this->value.f[i]; 324 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1.0 : 0.0; 325 default: assert(!"Should not get here."); break; 326 } 327 328 /* Must return something to make the compiler happy. This is clearly an 329 * error case. 330 */ 331 return 0.0; 332} 333 334int 335ir_constant::get_int_component(unsigned i) const 336{ 337 switch (this->type->base_type) { 338 case GLSL_TYPE_UINT: return this->value.u[i]; 339 case GLSL_TYPE_INT: return this->value.i[i]; 340 case GLSL_TYPE_FLOAT: return (int) this->value.f[i]; 341 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0; 342 default: assert(!"Should not get here."); break; 343 } 344 345 /* Must return something to make the compiler happy. This is clearly an 346 * error case. 347 */ 348 return 0; 349} 350 351unsigned 352ir_constant::get_uint_component(unsigned i) const 353{ 354 switch (this->type->base_type) { 355 case GLSL_TYPE_UINT: return this->value.u[i]; 356 case GLSL_TYPE_INT: return this->value.i[i]; 357 case GLSL_TYPE_FLOAT: return (unsigned) this->value.f[i]; 358 case GLSL_TYPE_BOOL: return this->value.b[i] ? 1 : 0; 359 default: assert(!"Should not get here."); break; 360 } 361 362 /* Must return something to make the compiler happy. This is clearly an 363 * error case. 364 */ 365 return 0; 366} 367 368 369ir_constant * 370ir_constant::get_record_field(const char *name) 371{ 372 int idx = this->type->field_index(name); 373 374 if (idx < 0) 375 return NULL; 376 377 if (this->components.is_empty()) 378 return NULL; 379 380 exec_node *node = this->components.head; 381 for (int i = 0; i < idx; i++) { 382 node = node->next; 383 384 /* If the end of the list is encountered before the element matching the 385 * requested field is found, return NULL. 386 */ 387 if (node->is_tail_sentinal()) 388 return NULL; 389 } 390 391 return (ir_constant *) node; 392} 393 394 395bool 396ir_constant::has_value(const ir_constant *c) const 397{ 398 if (this->type != c->type) 399 return false; 400 401 /* FINISHME: This will probably also handle constant arrays as soon as those 402 * FINISHME: are supported. 403 */ 404 if (this->type->base_type == GLSL_TYPE_STRUCT) { 405 const exec_node *a_node = this->components.head; 406 const exec_node *b_node = c->components.head; 407 408 while (!a_node->is_tail_sentinal()) { 409 assert(!b_node->is_tail_sentinal()); 410 411 const ir_constant *const a_field = (ir_constant *) a_node; 412 const ir_constant *const b_field = (ir_constant *) b_node; 413 414 if (!a_field->has_value(b_field)) 415 return false; 416 417 a_node = a_node->next; 418 b_node = b_node->next; 419 } 420 421 return true; 422 } 423 424 for (unsigned i = 0; i < this->type->components(); i++) { 425 switch (this->type->base_type) { 426 case GLSL_TYPE_UINT: 427 if (this->value.u[i] != c->value.u[i]) 428 return false; 429 break; 430 case GLSL_TYPE_INT: 431 if (this->value.i[i] != c->value.i[i]) 432 return false; 433 break; 434 case GLSL_TYPE_FLOAT: 435 if (this->value.f[i] != c->value.f[i]) 436 return false; 437 break; 438 case GLSL_TYPE_BOOL: 439 if (this->value.b[i] != c->value.b[i]) 440 return false; 441 break; 442 default: 443 assert(!"Should not get here."); 444 return false; 445 } 446 } 447 448 return true; 449} 450 451ir_dereference_variable::ir_dereference_variable(ir_variable *var) 452{ 453 this->var = var; 454 this->type = (var != NULL) ? var->type : glsl_type::error_type; 455} 456 457 458ir_dereference_array::ir_dereference_array(ir_rvalue *value, 459 ir_rvalue *array_index) 460{ 461 this->array_index = array_index; 462 this->set_array(value); 463} 464 465 466ir_dereference_array::ir_dereference_array(ir_variable *var, 467 ir_rvalue *array_index) 468{ 469 void *ctx = talloc_parent(var); 470 471 this->array_index = array_index; 472 this->set_array(new(ctx) ir_dereference_variable(var)); 473} 474 475 476void 477ir_dereference_array::set_array(ir_rvalue *value) 478{ 479 this->array = value; 480 this->type = glsl_type::error_type; 481 482 if (this->array != NULL) { 483 const glsl_type *const vt = this->array->type; 484 485 if (vt->is_array()) { 486 type = vt->element_type(); 487 } else if (vt->is_matrix()) { 488 type = vt->column_type(); 489 } else if (vt->is_vector()) { 490 type = vt->get_base_type(); 491 } 492 } 493} 494 495 496ir_dereference_record::ir_dereference_record(ir_rvalue *value, 497 const char *field) 498{ 499 this->record = value; 500 this->field = field; 501 this->type = (this->record != NULL) 502 ? this->record->type->field_type(field) : glsl_type::error_type; 503} 504 505 506ir_dereference_record::ir_dereference_record(ir_variable *var, 507 const char *field) 508{ 509 void *ctx = talloc_parent(var); 510 511 this->record = new(ctx) ir_dereference_variable(var); 512 this->field = field; 513 this->type = (this->record != NULL) 514 ? this->record->type->field_type(field) : glsl_type::error_type; 515} 516 517 518bool 519ir_dereference::is_lvalue() 520{ 521 ir_variable *var = this->variable_referenced(); 522 523 /* Every l-value derference chain eventually ends in a variable. 524 */ 525 if ((var == NULL) || var->read_only) 526 return false; 527 528 if (this->type->is_array() && !var->array_lvalue) 529 return false; 530 531 return true; 532} 533 534 535const char *tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf" }; 536 537const char *ir_texture::opcode_string() 538{ 539 assert((unsigned int) op <= 540 sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0])); 541 return tex_opcode_strs[op]; 542} 543 544ir_texture_opcode 545ir_texture::get_opcode(const char *str) 546{ 547 const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]); 548 for (int op = 0; op < count; op++) { 549 if (strcmp(str, tex_opcode_strs[op]) == 0) 550 return (ir_texture_opcode) op; 551 } 552 return (ir_texture_opcode) -1; 553} 554 555 556void 557ir_texture::set_sampler(ir_dereference *sampler) 558{ 559 assert(sampler != NULL); 560 this->sampler = sampler; 561 562 switch (sampler->type->sampler_type) { 563 case GLSL_TYPE_FLOAT: 564 this->type = glsl_type::vec4_type; 565 break; 566 case GLSL_TYPE_INT: 567 this->type = glsl_type::ivec4_type; 568 break; 569 case GLSL_TYPE_UINT: 570 this->type = glsl_type::uvec4_type; 571 break; 572 } 573} 574 575 576ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z, 577 unsigned w, unsigned count) 578 : val(val) 579{ 580 assert((count >= 1) && (count <= 4)); 581 582 const unsigned dup_mask = 0 583 | ((count > 1) ? ((1U << y) & ((1U << x) )) : 0) 584 | ((count > 2) ? ((1U << z) & ((1U << x) | (1U << y) )) : 0) 585 | ((count > 3) ? ((1U << w) & ((1U << x) | (1U << y) | (1U << z))) : 0); 586 587 assert(x <= 3); 588 assert(y <= 3); 589 assert(z <= 3); 590 assert(w <= 3); 591 592 mask.x = x; 593 mask.y = y; 594 mask.z = z; 595 mask.w = w; 596 mask.num_components = count; 597 mask.has_duplicates = dup_mask != 0; 598 599 /* Based on the number of elements in the swizzle and the base type 600 * (i.e., float, int, unsigned, or bool) of the vector being swizzled, 601 * generate the type of the resulting value. 602 */ 603 type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1); 604} 605 606ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask) 607{ 608 this->val = val; 609 this->mask = mask; 610 this->type = glsl_type::get_instance(val->type->base_type, 611 mask.num_components, 1); 612} 613 614#define X 1 615#define R 5 616#define S 9 617#define I 13 618 619ir_swizzle * 620ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length) 621{ 622 void *ctx = talloc_parent(val); 623 624 /* For each possible swizzle character, this table encodes the value in 625 * \c idx_map that represents the 0th element of the vector. For invalid 626 * swizzle characters (e.g., 'k'), a special value is used that will allow 627 * detection of errors. 628 */ 629 static const unsigned char base_idx[26] = { 630 /* a b c d e f g h i j k l m */ 631 R, R, I, I, I, I, R, I, I, I, I, I, I, 632 /* n o p q r s t u v w x y z */ 633 I, I, S, S, R, S, S, I, I, X, X, X, X 634 }; 635 636 /* Each valid swizzle character has an entry in the previous table. This 637 * table encodes the base index encoded in the previous table plus the actual 638 * index of the swizzle character. When processing swizzles, the first 639 * character in the string is indexed in the previous table. Each character 640 * in the string is indexed in this table, and the value found there has the 641 * value form the first table subtracted. The result must be on the range 642 * [0,3]. 643 * 644 * For example, the string "wzyx" will get X from the first table. Each of 645 * the charcaters will get X+3, X+2, X+1, and X+0 from this table. After 646 * subtraction, the swizzle values are { 3, 2, 1, 0 }. 647 * 648 * The string "wzrg" will get X from the first table. Each of the characters 649 * will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the 650 * swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range 651 * [0,3], the error is detected. 652 */ 653 static const unsigned char idx_map[26] = { 654 /* a b c d e f g h i j k l m */ 655 R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0, 656 /* n o p q r s t u v w x y z */ 657 0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2 658 }; 659 660 int swiz_idx[4] = { 0, 0, 0, 0 }; 661 unsigned i; 662 663 664 /* Validate the first character in the swizzle string and look up the base 665 * index value as described above. 666 */ 667 if ((str[0] < 'a') || (str[0] > 'z')) 668 return NULL; 669 670 const unsigned base = base_idx[str[0] - 'a']; 671 672 673 for (i = 0; (i < 4) && (str[i] != '\0'); i++) { 674 /* Validate the next character, and, as described above, convert it to a 675 * swizzle index. 676 */ 677 if ((str[i] < 'a') || (str[i] > 'z')) 678 return NULL; 679 680 swiz_idx[i] = idx_map[str[i] - 'a'] - base; 681 if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length)) 682 return NULL; 683 } 684 685 if (str[i] != '\0') 686 return NULL; 687 688 return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2], 689 swiz_idx[3], i); 690} 691 692#undef X 693#undef R 694#undef S 695#undef I 696 697ir_variable * 698ir_swizzle::variable_referenced() 699{ 700 return this->val->variable_referenced(); 701} 702 703ir_variable::ir_variable(const struct glsl_type *type, const char *name) 704 : max_array_access(0), read_only(false), centroid(false), invariant(false), 705 shader_in(false), shader_out(false), 706 mode(ir_var_auto), interpolation(ir_var_smooth), array_lvalue(false) 707{ 708 this->type = type; 709 this->name = name; 710 this->location = -1; 711 this->warn_extension = NULL; 712 this->constant_value = NULL; 713 714 if (type && type->base_type == GLSL_TYPE_SAMPLER) 715 this->read_only = true; 716} 717 718 719const char * 720ir_variable::interpolation_string() const 721{ 722 if (!this->shader_in && !this->shader_out) 723 return ""; 724 725 switch (this->interpolation) { 726 case ir_var_smooth: return "smooth"; 727 case ir_var_flat: return "flat"; 728 case ir_var_noperspective: return "noperspective"; 729 } 730 731 assert(!"Should not get here."); 732 return ""; 733} 734 735 736unsigned 737ir_variable::component_slots() const 738{ 739 /* FINISHME: Sparsely accessed arrays require fewer slots. */ 740 return this->type->component_slots(); 741} 742 743 744ir_function_signature::ir_function_signature(const glsl_type *return_type) 745 : return_type(return_type), is_defined(false) 746{ 747 /* empty */ 748} 749 750 751const char * 752ir_function_signature::qualifiers_match(exec_list *params) 753{ 754 exec_list_iterator iter_a = parameters.iterator(); 755 exec_list_iterator iter_b = params->iterator(); 756 757 /* check that the qualifiers match. */ 758 while (iter_a.has_next()) { 759 ir_variable *a = (ir_variable *)iter_a.get(); 760 ir_variable *b = (ir_variable *)iter_b.get(); 761 762 if (a->read_only != b->read_only || 763 a->mode != b->mode || 764 a->interpolation != b->interpolation || 765 a->centroid != b->centroid) { 766 767 /* parameter a's qualifiers don't match */ 768 return a->name; 769 } 770 771 iter_a.next(); 772 iter_b.next(); 773 } 774 return NULL; 775} 776 777 778void 779ir_function_signature::replace_parameters(exec_list *new_params) 780{ 781 /* Destroy all of the previous parameter information. If the previous 782 * parameter information comes from the function prototype, it may either 783 * specify incorrect parameter names or not have names at all. 784 */ 785 foreach_iter(exec_list_iterator, iter, parameters) { 786 assert(((ir_instruction *) iter.get())->as_variable() != NULL); 787 788 iter.remove(); 789 } 790 791 new_params->move_nodes_to(¶meters); 792} 793 794 795ir_function::ir_function(const char *name) 796 : name(name) 797{ 798 /* empty */ 799} 800 801 802ir_call * 803ir_call::get_error_instruction(void *ctx) 804{ 805 ir_call *call = new(ctx) ir_call; 806 807 call->type = glsl_type::error_type; 808 return call; 809} 810 811void 812visit_exec_list(exec_list *list, ir_visitor *visitor) 813{ 814 foreach_iter(exec_list_iterator, iter, *list) { 815 ((ir_instruction *)iter.get())->accept(visitor); 816 } 817} 818 819