ir.h revision 82065fa20ee3f2880a070f1f4f75509b910cedde
1/* -*- c++ -*- */ 2/* 3 * Copyright © 2010 Intel Corporation 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25#pragma once 26#ifndef IR_H 27#define IR_H 28 29#include <stdio.h> 30#include <stdlib.h> 31 32#include "ralloc.h" 33#include "glsl_types.h" 34#include "list.h" 35#include "ir_visitor.h" 36#include "ir_hierarchical_visitor.h" 37#include "main/mtypes.h" 38 39/** 40 * \defgroup IR Intermediate representation nodes 41 * 42 * @{ 43 */ 44 45/** 46 * Class tags 47 * 48 * Each concrete class derived from \c ir_instruction has a value in this 49 * enumerant. The value for the type is stored in \c ir_instruction::ir_type 50 * by the constructor. While using type tags is not very C++, it is extremely 51 * convenient. For example, during debugging you can simply inspect 52 * \c ir_instruction::ir_type to find out the actual type of the object. 53 * 54 * In addition, it is possible to use a switch-statement based on \c 55 * \c ir_instruction::ir_type to select different behavior for different object 56 * types. For functions that have only slight differences for several object 57 * types, this allows writing very straightforward, readable code. 58 */ 59enum ir_node_type { 60 /** 61 * Zero is unused so that the IR validator can detect cases where 62 * \c ir_instruction::ir_type has not been initialized. 63 */ 64 ir_type_unset, 65 ir_type_variable, 66 ir_type_assignment, 67 ir_type_call, 68 ir_type_constant, 69 ir_type_dereference_array, 70 ir_type_dereference_record, 71 ir_type_dereference_variable, 72 ir_type_discard, 73 ir_type_expression, 74 ir_type_function, 75 ir_type_function_signature, 76 ir_type_if, 77 ir_type_loop, 78 ir_type_loop_jump, 79 ir_type_return, 80 ir_type_swizzle, 81 ir_type_texture, 82 ir_type_max /**< maximum ir_type enum number, for validation */ 83}; 84 85/** 86 * Base class of all IR instructions 87 */ 88class ir_instruction : public exec_node { 89public: 90 enum ir_node_type ir_type; 91 const struct glsl_type *type; 92 93 /** ir_print_visitor helper for debugging. */ 94 void print(void) const; 95 96 virtual void accept(ir_visitor *) = 0; 97 virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0; 98 virtual ir_instruction *clone(void *mem_ctx, 99 struct hash_table *ht) const = 0; 100 101 /** 102 * \name IR instruction downcast functions 103 * 104 * These functions either cast the object to a derived class or return 105 * \c NULL if the object's type does not match the specified derived class. 106 * Additional downcast functions will be added as needed. 107 */ 108 /*@{*/ 109 virtual class ir_variable * as_variable() { return NULL; } 110 virtual class ir_function * as_function() { return NULL; } 111 virtual class ir_dereference * as_dereference() { return NULL; } 112 virtual class ir_dereference_array * as_dereference_array() { return NULL; } 113 virtual class ir_dereference_variable *as_dereference_variable() { return NULL; } 114 virtual class ir_expression * as_expression() { return NULL; } 115 virtual class ir_rvalue * as_rvalue() { return NULL; } 116 virtual class ir_loop * as_loop() { return NULL; } 117 virtual class ir_assignment * as_assignment() { return NULL; } 118 virtual class ir_call * as_call() { return NULL; } 119 virtual class ir_return * as_return() { return NULL; } 120 virtual class ir_if * as_if() { return NULL; } 121 virtual class ir_swizzle * as_swizzle() { return NULL; } 122 virtual class ir_constant * as_constant() { return NULL; } 123 virtual class ir_discard * as_discard() { return NULL; } 124 /*@}*/ 125 126protected: 127 ir_instruction() 128 { 129 ir_type = ir_type_unset; 130 type = NULL; 131 } 132}; 133 134 135/** 136 * The base class for all "values"/expression trees. 137 */ 138class ir_rvalue : public ir_instruction { 139public: 140 virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const; 141 142 virtual void accept(ir_visitor *v) 143 { 144 v->visit(this); 145 } 146 147 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 148 149 virtual ir_constant *constant_expression_value(); 150 151 virtual ir_rvalue * as_rvalue() 152 { 153 return this; 154 } 155 156 ir_rvalue *as_rvalue_to_saturate(); 157 158 virtual bool is_lvalue() const 159 { 160 return false; 161 } 162 163 /** 164 * Get the variable that is ultimately referenced by an r-value 165 */ 166 virtual ir_variable *variable_referenced() const 167 { 168 return NULL; 169 } 170 171 172 /** 173 * If an r-value is a reference to a whole variable, get that variable 174 * 175 * \return 176 * Pointer to a variable that is completely dereferenced by the r-value. If 177 * the r-value is not a dereference or the dereference does not access the 178 * entire variable (i.e., it's just one array element, struct field), \c NULL 179 * is returned. 180 */ 181 virtual ir_variable *whole_variable_referenced() 182 { 183 return NULL; 184 } 185 186 /** 187 * Determine if an r-value has the value zero 188 * 189 * The base implementation of this function always returns \c false. The 190 * \c ir_constant class over-rides this function to return \c true \b only 191 * for vector and scalar types that have all elements set to the value 192 * zero (or \c false for booleans). 193 * 194 * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one 195 */ 196 virtual bool is_zero() const; 197 198 /** 199 * Determine if an r-value has the value one 200 * 201 * The base implementation of this function always returns \c false. The 202 * \c ir_constant class over-rides this function to return \c true \b only 203 * for vector and scalar types that have all elements set to the value 204 * one (or \c true for booleans). 205 * 206 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one 207 */ 208 virtual bool is_one() const; 209 210 /** 211 * Determine if an r-value has the value negative one 212 * 213 * The base implementation of this function always returns \c false. The 214 * \c ir_constant class over-rides this function to return \c true \b only 215 * for vector and scalar types that have all elements set to the value 216 * negative one. For boolean times, the result is always \c false. 217 * 218 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one 219 */ 220 virtual bool is_negative_one() const; 221 222 223 /** 224 * Return a generic value of error_type. 225 * 226 * Allocation will be performed with 'mem_ctx' as ralloc owner. 227 */ 228 static ir_rvalue *error_value(void *mem_ctx); 229 230protected: 231 ir_rvalue(); 232}; 233 234 235/** 236 * Variable storage classes 237 */ 238enum ir_variable_mode { 239 ir_var_auto = 0, /**< Function local variables and globals. */ 240 ir_var_uniform, /**< Variable declared as a uniform. */ 241 ir_var_in, 242 ir_var_out, 243 ir_var_inout, 244 ir_var_const_in, /**< "in" param that must be a constant expression */ 245 ir_var_system_value, /**< Ex: front-face, instance-id, etc. */ 246 ir_var_temporary /**< Temporary variable generated during compilation. */ 247}; 248 249/** 250 * \brief Layout qualifiers for gl_FragDepth. 251 * 252 * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared 253 * with a layout qualifier. 254 */ 255enum ir_depth_layout { 256 ir_depth_layout_none, /**< No depth layout is specified. */ 257 ir_depth_layout_any, 258 ir_depth_layout_greater, 259 ir_depth_layout_less, 260 ir_depth_layout_unchanged 261}; 262 263/** 264 * \brief Convert depth layout qualifier to string. 265 */ 266const char* 267depth_layout_string(ir_depth_layout layout); 268 269/** 270 * Description of built-in state associated with a uniform 271 * 272 * \sa ir_variable::state_slots 273 */ 274struct ir_state_slot { 275 int tokens[5]; 276 int swizzle; 277}; 278 279class ir_variable : public ir_instruction { 280public: 281 ir_variable(const struct glsl_type *, const char *, ir_variable_mode); 282 283 virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const; 284 285 virtual ir_variable *as_variable() 286 { 287 return this; 288 } 289 290 virtual void accept(ir_visitor *v) 291 { 292 v->visit(this); 293 } 294 295 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 296 297 298 /** 299 * Get the string value for the interpolation qualifier 300 * 301 * \return The string that would be used in a shader to specify \c 302 * mode will be returned. 303 * 304 * This function is used to generate error messages of the form "shader 305 * uses %s interpolation qualifier", so in the case where there is no 306 * interpolation qualifier, it returns "no". 307 * 308 * This function should only be used on a shader input or output variable. 309 */ 310 const char *interpolation_string() const; 311 312 /** 313 * Determine how this variable should be interpolated based on its 314 * interpolation qualifier (if present), whether it is gl_Color or 315 * gl_SecondaryColor, and whether flatshading is enabled in the current GL 316 * state. 317 * 318 * The return value will always be either INTERP_QUALIFIER_SMOOTH, 319 * INTERP_QUALIFIER_NOPERSPECTIVE, or INTERP_QUALIFIER_FLAT. 320 */ 321 glsl_interp_qualifier determine_interpolation_mode(bool flat_shade); 322 323 /** 324 * Delcared name of the variable 325 */ 326 const char *name; 327 328 /** 329 * Highest element accessed with a constant expression array index 330 * 331 * Not used for non-array variables. 332 */ 333 unsigned max_array_access; 334 335 /** 336 * Is the variable read-only? 337 * 338 * This is set for variables declared as \c const, shader inputs, 339 * and uniforms. 340 */ 341 unsigned read_only:1; 342 unsigned centroid:1; 343 unsigned invariant:1; 344 345 /** 346 * Has this variable been used for reading or writing? 347 * 348 * Several GLSL semantic checks require knowledge of whether or not a 349 * variable has been used. For example, it is an error to redeclare a 350 * variable as invariant after it has been used. 351 */ 352 unsigned used:1; 353 354 /** 355 * Storage class of the variable. 356 * 357 * \sa ir_variable_mode 358 */ 359 unsigned mode:3; 360 361 /** 362 * Interpolation mode for shader inputs / outputs 363 * 364 * \sa ir_variable_interpolation 365 */ 366 unsigned interpolation:2; 367 368 /** 369 * \name ARB_fragment_coord_conventions 370 * @{ 371 */ 372 unsigned origin_upper_left:1; 373 unsigned pixel_center_integer:1; 374 /*@}*/ 375 376 /** 377 * Was the location explicitly set in the shader? 378 * 379 * If the location is explicitly set in the shader, it \b cannot be changed 380 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have 381 * no effect). 382 */ 383 unsigned explicit_location:1; 384 385 /** 386 * Does this variable have an initializer? 387 * 388 * This is used by the linker to cross-validiate initializers of global 389 * variables. 390 */ 391 unsigned has_initializer:1; 392 393 /** 394 * \brief Layout qualifier for gl_FragDepth. 395 * 396 * This is not equal to \c ir_depth_layout_none if and only if this 397 * variable is \c gl_FragDepth and a layout qualifier is specified. 398 */ 399 ir_depth_layout depth_layout; 400 401 /** 402 * Storage location of the base of this variable 403 * 404 * The precise meaning of this field depends on the nature of the variable. 405 * 406 * - Vertex shader input: one of the values from \c gl_vert_attrib. 407 * - Vertex shader output: one of the values from \c gl_vert_result. 408 * - Fragment shader input: one of the values from \c gl_frag_attrib. 409 * - Fragment shader output: one of the values from \c gl_frag_result. 410 * - Uniforms: Per-stage uniform slot number. 411 * - Other: This field is not currently used. 412 * 413 * If the variable is a uniform, shader input, or shader output, and the 414 * slot has not been assigned, the value will be -1. 415 */ 416 int location; 417 418 /** 419 * Built-in state that backs this uniform 420 * 421 * Once set at variable creation, \c state_slots must remain invariant. 422 * This is because, ideally, this array would be shared by all clones of 423 * this variable in the IR tree. In other words, we'd really like for it 424 * to be a fly-weight. 425 * 426 * If the variable is not a uniform, \c num_state_slots will be zero and 427 * \c state_slots will be \c NULL. 428 */ 429 /*@{*/ 430 unsigned num_state_slots; /**< Number of state slots used */ 431 ir_state_slot *state_slots; /**< State descriptors. */ 432 /*@}*/ 433 434 /** 435 * Emit a warning if this variable is accessed. 436 */ 437 const char *warn_extension; 438 439 /** 440 * Value assigned in the initializer of a variable declared "const" 441 */ 442 ir_constant *constant_value; 443 444 /** 445 * Constant expression assigned in the initializer of the variable 446 * 447 * \warning 448 * This field and \c ::constant_value are distinct. Even if the two fields 449 * refer to constants with the same value, they must point to separate 450 * objects. 451 */ 452 ir_constant *constant_initializer; 453}; 454 455 456/*@{*/ 457/** 458 * The representation of a function instance; may be the full definition or 459 * simply a prototype. 460 */ 461class ir_function_signature : public ir_instruction { 462 /* An ir_function_signature will be part of the list of signatures in 463 * an ir_function. 464 */ 465public: 466 ir_function_signature(const glsl_type *return_type); 467 468 virtual ir_function_signature *clone(void *mem_ctx, 469 struct hash_table *ht) const; 470 ir_function_signature *clone_prototype(void *mem_ctx, 471 struct hash_table *ht) const; 472 473 virtual void accept(ir_visitor *v) 474 { 475 v->visit(this); 476 } 477 478 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 479 480 /** 481 * Attempt to evaluate this function as a constant expression, given 482 * a list of the actual parameters. Returns NULL for non-built-ins. 483 */ 484 ir_constant *constant_expression_value(exec_list *actual_parameters); 485 486 /** 487 * Get the name of the function for which this is a signature 488 */ 489 const char *function_name() const; 490 491 /** 492 * Get a handle to the function for which this is a signature 493 * 494 * There is no setter function, this function returns a \c const pointer, 495 * and \c ir_function_signature::_function is private for a reason. The 496 * only way to make a connection between a function and function signature 497 * is via \c ir_function::add_signature. This helps ensure that certain 498 * invariants (i.e., a function signature is in the list of signatures for 499 * its \c _function) are met. 500 * 501 * \sa ir_function::add_signature 502 */ 503 inline const class ir_function *function() const 504 { 505 return this->_function; 506 } 507 508 /** 509 * Check whether the qualifiers match between this signature's parameters 510 * and the supplied parameter list. If not, returns the name of the first 511 * parameter with mismatched qualifiers (for use in error messages). 512 */ 513 const char *qualifiers_match(exec_list *params); 514 515 /** 516 * Replace the current parameter list with the given one. This is useful 517 * if the current information came from a prototype, and either has invalid 518 * or missing parameter names. 519 */ 520 void replace_parameters(exec_list *new_params); 521 522 /** 523 * Function return type. 524 * 525 * \note This discards the optional precision qualifier. 526 */ 527 const struct glsl_type *return_type; 528 529 /** 530 * List of ir_variable of function parameters. 531 * 532 * This represents the storage. The paramaters passed in a particular 533 * call will be in ir_call::actual_paramaters. 534 */ 535 struct exec_list parameters; 536 537 /** Whether or not this function has a body (which may be empty). */ 538 unsigned is_defined:1; 539 540 /** Whether or not this function signature is a built-in. */ 541 unsigned is_builtin:1; 542 543 /** Body of instructions in the function. */ 544 struct exec_list body; 545 546private: 547 /** Function of which this signature is one overload. */ 548 class ir_function *_function; 549 550 friend class ir_function; 551}; 552 553 554/** 555 * Header for tracking multiple overloaded functions with the same name. 556 * Contains a list of ir_function_signatures representing each of the 557 * actual functions. 558 */ 559class ir_function : public ir_instruction { 560public: 561 ir_function(const char *name); 562 563 virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const; 564 565 virtual ir_function *as_function() 566 { 567 return this; 568 } 569 570 virtual void accept(ir_visitor *v) 571 { 572 v->visit(this); 573 } 574 575 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 576 577 void add_signature(ir_function_signature *sig) 578 { 579 sig->_function = this; 580 this->signatures.push_tail(sig); 581 } 582 583 /** 584 * Get an iterator for the set of function signatures 585 */ 586 exec_list_iterator iterator() 587 { 588 return signatures.iterator(); 589 } 590 591 /** 592 * Find a signature that matches a set of actual parameters, taking implicit 593 * conversions into account. Also flags whether the match was exact. 594 */ 595 ir_function_signature *matching_signature(const exec_list *actual_param, 596 bool *match_is_exact); 597 598 /** 599 * Find a signature that matches a set of actual parameters, taking implicit 600 * conversions into account. 601 */ 602 ir_function_signature *matching_signature(const exec_list *actual_param); 603 604 /** 605 * Find a signature that exactly matches a set of actual parameters without 606 * any implicit type conversions. 607 */ 608 ir_function_signature *exact_matching_signature(const exec_list *actual_ps); 609 610 /** 611 * Name of the function. 612 */ 613 const char *name; 614 615 /** Whether or not this function has a signature that isn't a built-in. */ 616 bool has_user_signature(); 617 618 /** 619 * List of ir_function_signature for each overloaded function with this name. 620 */ 621 struct exec_list signatures; 622}; 623 624inline const char *ir_function_signature::function_name() const 625{ 626 return this->_function->name; 627} 628/*@}*/ 629 630 631/** 632 * IR instruction representing high-level if-statements 633 */ 634class ir_if : public ir_instruction { 635public: 636 ir_if(ir_rvalue *condition) 637 : condition(condition) 638 { 639 ir_type = ir_type_if; 640 } 641 642 virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const; 643 644 virtual ir_if *as_if() 645 { 646 return this; 647 } 648 649 virtual void accept(ir_visitor *v) 650 { 651 v->visit(this); 652 } 653 654 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 655 656 ir_rvalue *condition; 657 /** List of ir_instruction for the body of the then branch */ 658 exec_list then_instructions; 659 /** List of ir_instruction for the body of the else branch */ 660 exec_list else_instructions; 661}; 662 663 664/** 665 * IR instruction representing a high-level loop structure. 666 */ 667class ir_loop : public ir_instruction { 668public: 669 ir_loop(); 670 671 virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const; 672 673 virtual void accept(ir_visitor *v) 674 { 675 v->visit(this); 676 } 677 678 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 679 680 virtual ir_loop *as_loop() 681 { 682 return this; 683 } 684 685 /** 686 * Get an iterator for the instructions of the loop body 687 */ 688 exec_list_iterator iterator() 689 { 690 return body_instructions.iterator(); 691 } 692 693 /** List of ir_instruction that make up the body of the loop. */ 694 exec_list body_instructions; 695 696 /** 697 * \name Loop counter and controls 698 * 699 * Represents a loop like a FORTRAN \c do-loop. 700 * 701 * \note 702 * If \c from and \c to are the same value, the loop will execute once. 703 */ 704 /*@{*/ 705 ir_rvalue *from; /** Value of the loop counter on the first 706 * iteration of the loop. 707 */ 708 ir_rvalue *to; /** Value of the loop counter on the last 709 * iteration of the loop. 710 */ 711 ir_rvalue *increment; 712 ir_variable *counter; 713 714 /** 715 * Comparison operation in the loop terminator. 716 * 717 * If any of the loop control fields are non-\c NULL, this field must be 718 * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal, 719 * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal. 720 */ 721 int cmp; 722 /*@}*/ 723}; 724 725 726class ir_assignment : public ir_instruction { 727public: 728 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL); 729 730 /** 731 * Construct an assignment with an explicit write mask 732 * 733 * \note 734 * Since a write mask is supplied, the LHS must already be a bare 735 * \c ir_dereference. The cannot be any swizzles in the LHS. 736 */ 737 ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition, 738 unsigned write_mask); 739 740 virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const; 741 742 virtual ir_constant *constant_expression_value(); 743 744 virtual void accept(ir_visitor *v) 745 { 746 v->visit(this); 747 } 748 749 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 750 751 virtual ir_assignment * as_assignment() 752 { 753 return this; 754 } 755 756 /** 757 * Get a whole variable written by an assignment 758 * 759 * If the LHS of the assignment writes a whole variable, the variable is 760 * returned. Otherwise \c NULL is returned. Examples of whole-variable 761 * assignment are: 762 * 763 * - Assigning to a scalar 764 * - Assigning to all components of a vector 765 * - Whole array (or matrix) assignment 766 * - Whole structure assignment 767 */ 768 ir_variable *whole_variable_written(); 769 770 /** 771 * Set the LHS of an assignment 772 */ 773 void set_lhs(ir_rvalue *lhs); 774 775 /** 776 * Left-hand side of the assignment. 777 * 778 * This should be treated as read only. If you need to set the LHS of an 779 * assignment, use \c ir_assignment::set_lhs. 780 */ 781 ir_dereference *lhs; 782 783 /** 784 * Value being assigned 785 */ 786 ir_rvalue *rhs; 787 788 /** 789 * Optional condition for the assignment. 790 */ 791 ir_rvalue *condition; 792 793 794 /** 795 * Component mask written 796 * 797 * For non-vector types in the LHS, this field will be zero. For vector 798 * types, a bit will be set for each component that is written. Note that 799 * for \c vec2 and \c vec3 types only the lower bits will ever be set. 800 * 801 * A partially-set write mask means that each enabled channel gets 802 * the value from a consecutive channel of the rhs. For example, 803 * to write just .xyw of gl_FrontColor with color: 804 * 805 * (assign (constant bool (1)) (xyw) 806 * (var_ref gl_FragColor) 807 * (swiz xyw (var_ref color))) 808 */ 809 unsigned write_mask:4; 810}; 811 812/* Update ir_expression::num_operands() and operator_strs when 813 * updating this list. 814 */ 815enum ir_expression_operation { 816 ir_unop_bit_not, 817 ir_unop_logic_not, 818 ir_unop_neg, 819 ir_unop_abs, 820 ir_unop_sign, 821 ir_unop_rcp, 822 ir_unop_rsq, 823 ir_unop_sqrt, 824 ir_unop_exp, /**< Log base e on gentype */ 825 ir_unop_log, /**< Natural log on gentype */ 826 ir_unop_exp2, 827 ir_unop_log2, 828 ir_unop_f2i, /**< Float-to-integer conversion. */ 829 ir_unop_i2f, /**< Integer-to-float conversion. */ 830 ir_unop_f2b, /**< Float-to-boolean conversion */ 831 ir_unop_b2f, /**< Boolean-to-float conversion */ 832 ir_unop_i2b, /**< int-to-boolean conversion */ 833 ir_unop_b2i, /**< Boolean-to-int conversion */ 834 ir_unop_u2f, /**< Unsigned-to-float conversion. */ 835 ir_unop_i2u, /**< Integer-to-unsigned conversion. */ 836 ir_unop_u2i, /**< Unsigned-to-integer conversion. */ 837 ir_unop_any, 838 839 /** 840 * \name Unary floating-point rounding operations. 841 */ 842 /*@{*/ 843 ir_unop_trunc, 844 ir_unop_ceil, 845 ir_unop_floor, 846 ir_unop_fract, 847 ir_unop_round_even, 848 /*@}*/ 849 850 /** 851 * \name Trigonometric operations. 852 */ 853 /*@{*/ 854 ir_unop_sin, 855 ir_unop_cos, 856 ir_unop_sin_reduced, /**< Reduced range sin. [-pi, pi] */ 857 ir_unop_cos_reduced, /**< Reduced range cos. [-pi, pi] */ 858 /*@}*/ 859 860 /** 861 * \name Partial derivatives. 862 */ 863 /*@{*/ 864 ir_unop_dFdx, 865 ir_unop_dFdy, 866 /*@}*/ 867 868 ir_unop_noise, 869 870 /** 871 * A sentinel marking the last of the unary operations. 872 */ 873 ir_last_unop = ir_unop_noise, 874 875 ir_binop_add, 876 ir_binop_sub, 877 ir_binop_mul, 878 ir_binop_div, 879 880 /** 881 * Takes one of two combinations of arguments: 882 * 883 * - mod(vecN, vecN) 884 * - mod(vecN, float) 885 * 886 * Does not take integer types. 887 */ 888 ir_binop_mod, 889 890 /** 891 * \name Binary comparison operators which return a boolean vector. 892 * The type of both operands must be equal. 893 */ 894 /*@{*/ 895 ir_binop_less, 896 ir_binop_greater, 897 ir_binop_lequal, 898 ir_binop_gequal, 899 ir_binop_equal, 900 ir_binop_nequal, 901 /** 902 * Returns single boolean for whether all components of operands[0] 903 * equal the components of operands[1]. 904 */ 905 ir_binop_all_equal, 906 /** 907 * Returns single boolean for whether any component of operands[0] 908 * is not equal to the corresponding component of operands[1]. 909 */ 910 ir_binop_any_nequal, 911 /*@}*/ 912 913 /** 914 * \name Bit-wise binary operations. 915 */ 916 /*@{*/ 917 ir_binop_lshift, 918 ir_binop_rshift, 919 ir_binop_bit_and, 920 ir_binop_bit_xor, 921 ir_binop_bit_or, 922 /*@}*/ 923 924 ir_binop_logic_and, 925 ir_binop_logic_xor, 926 ir_binop_logic_or, 927 928 ir_binop_dot, 929 ir_binop_min, 930 ir_binop_max, 931 932 ir_binop_pow, 933 934 /** 935 * A sentinel marking the last of the binary operations. 936 */ 937 ir_last_binop = ir_binop_pow, 938 939 ir_quadop_vector, 940 941 /** 942 * A sentinel marking the last of all operations. 943 */ 944 ir_last_opcode = ir_last_binop 945}; 946 947class ir_expression : public ir_rvalue { 948public: 949 /** 950 * Constructor for unary operation expressions 951 */ 952 ir_expression(int op, const struct glsl_type *type, ir_rvalue *); 953 ir_expression(int op, ir_rvalue *); 954 955 /** 956 * Constructor for binary operation expressions 957 */ 958 ir_expression(int op, const struct glsl_type *type, 959 ir_rvalue *, ir_rvalue *); 960 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1); 961 962 /** 963 * Constructor for quad operator expressions 964 */ 965 ir_expression(int op, const struct glsl_type *type, 966 ir_rvalue *, ir_rvalue *, ir_rvalue *, ir_rvalue *); 967 968 virtual ir_expression *as_expression() 969 { 970 return this; 971 } 972 973 virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const; 974 975 /** 976 * Attempt to constant-fold the expression 977 * 978 * If the expression cannot be constant folded, this method will return 979 * \c NULL. 980 */ 981 virtual ir_constant *constant_expression_value(); 982 983 /** 984 * Determine the number of operands used by an expression 985 */ 986 static unsigned int get_num_operands(ir_expression_operation); 987 988 /** 989 * Determine the number of operands used by an expression 990 */ 991 unsigned int get_num_operands() const 992 { 993 return (this->operation == ir_quadop_vector) 994 ? this->type->vector_elements : get_num_operands(operation); 995 } 996 997 /** 998 * Return a string representing this expression's operator. 999 */ 1000 const char *operator_string(); 1001 1002 /** 1003 * Return a string representing this expression's operator. 1004 */ 1005 static const char *operator_string(ir_expression_operation); 1006 1007 1008 /** 1009 * Do a reverse-lookup to translate the given string into an operator. 1010 */ 1011 static ir_expression_operation get_operator(const char *); 1012 1013 virtual void accept(ir_visitor *v) 1014 { 1015 v->visit(this); 1016 } 1017 1018 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1019 1020 ir_expression_operation operation; 1021 ir_rvalue *operands[4]; 1022}; 1023 1024 1025/** 1026 * HIR instruction representing a high-level function call, containing a list 1027 * of parameters and returning a value in the supplied temporary. 1028 */ 1029class ir_call : public ir_instruction { 1030public: 1031 ir_call(ir_function_signature *callee, 1032 ir_dereference_variable *return_deref, 1033 exec_list *actual_parameters) 1034 : return_deref(return_deref), callee(callee) 1035 { 1036 ir_type = ir_type_call; 1037 assert(callee->return_type != NULL); 1038 actual_parameters->move_nodes_to(& this->actual_parameters); 1039 this->use_builtin = callee->is_builtin; 1040 } 1041 1042 virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const; 1043 1044 virtual ir_constant *constant_expression_value(); 1045 1046 virtual ir_call *as_call() 1047 { 1048 return this; 1049 } 1050 1051 virtual void accept(ir_visitor *v) 1052 { 1053 v->visit(this); 1054 } 1055 1056 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1057 1058 /** 1059 * Get an iterator for the set of acutal parameters 1060 */ 1061 exec_list_iterator iterator() 1062 { 1063 return actual_parameters.iterator(); 1064 } 1065 1066 /** 1067 * Get the name of the function being called. 1068 */ 1069 const char *callee_name() const 1070 { 1071 return callee->function_name(); 1072 } 1073 1074 /** 1075 * Generates an inline version of the function before @ir, 1076 * storing the return value in return_deref. 1077 */ 1078 void generate_inline(ir_instruction *ir); 1079 1080 /** 1081 * Storage for the function's return value. 1082 * This must be NULL if the return type is void. 1083 */ 1084 ir_dereference_variable *return_deref; 1085 1086 /** 1087 * The specific function signature being called. 1088 */ 1089 ir_function_signature *callee; 1090 1091 /* List of ir_rvalue of paramaters passed in this call. */ 1092 exec_list actual_parameters; 1093 1094 /** Should this call only bind to a built-in function? */ 1095 bool use_builtin; 1096}; 1097 1098 1099/** 1100 * \name Jump-like IR instructions. 1101 * 1102 * These include \c break, \c continue, \c return, and \c discard. 1103 */ 1104/*@{*/ 1105class ir_jump : public ir_instruction { 1106protected: 1107 ir_jump() 1108 { 1109 ir_type = ir_type_unset; 1110 } 1111}; 1112 1113class ir_return : public ir_jump { 1114public: 1115 ir_return() 1116 : value(NULL) 1117 { 1118 this->ir_type = ir_type_return; 1119 } 1120 1121 ir_return(ir_rvalue *value) 1122 : value(value) 1123 { 1124 this->ir_type = ir_type_return; 1125 } 1126 1127 virtual ir_return *clone(void *mem_ctx, struct hash_table *) const; 1128 1129 virtual ir_return *as_return() 1130 { 1131 return this; 1132 } 1133 1134 ir_rvalue *get_value() const 1135 { 1136 return value; 1137 } 1138 1139 virtual void accept(ir_visitor *v) 1140 { 1141 v->visit(this); 1142 } 1143 1144 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1145 1146 ir_rvalue *value; 1147}; 1148 1149 1150/** 1151 * Jump instructions used inside loops 1152 * 1153 * These include \c break and \c continue. The \c break within a loop is 1154 * different from the \c break within a switch-statement. 1155 * 1156 * \sa ir_switch_jump 1157 */ 1158class ir_loop_jump : public ir_jump { 1159public: 1160 enum jump_mode { 1161 jump_break, 1162 jump_continue 1163 }; 1164 1165 ir_loop_jump(jump_mode mode) 1166 { 1167 this->ir_type = ir_type_loop_jump; 1168 this->mode = mode; 1169 this->loop = loop; 1170 } 1171 1172 virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const; 1173 1174 virtual void accept(ir_visitor *v) 1175 { 1176 v->visit(this); 1177 } 1178 1179 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1180 1181 bool is_break() const 1182 { 1183 return mode == jump_break; 1184 } 1185 1186 bool is_continue() const 1187 { 1188 return mode == jump_continue; 1189 } 1190 1191 /** Mode selector for the jump instruction. */ 1192 enum jump_mode mode; 1193private: 1194 /** Loop containing this break instruction. */ 1195 ir_loop *loop; 1196}; 1197 1198/** 1199 * IR instruction representing discard statements. 1200 */ 1201class ir_discard : public ir_jump { 1202public: 1203 ir_discard() 1204 { 1205 this->ir_type = ir_type_discard; 1206 this->condition = NULL; 1207 } 1208 1209 ir_discard(ir_rvalue *cond) 1210 { 1211 this->ir_type = ir_type_discard; 1212 this->condition = cond; 1213 } 1214 1215 virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const; 1216 1217 virtual void accept(ir_visitor *v) 1218 { 1219 v->visit(this); 1220 } 1221 1222 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1223 1224 virtual ir_discard *as_discard() 1225 { 1226 return this; 1227 } 1228 1229 ir_rvalue *condition; 1230}; 1231/*@}*/ 1232 1233 1234/** 1235 * Texture sampling opcodes used in ir_texture 1236 */ 1237enum ir_texture_opcode { 1238 ir_tex, /**< Regular texture look-up */ 1239 ir_txb, /**< Texture look-up with LOD bias */ 1240 ir_txl, /**< Texture look-up with explicit LOD */ 1241 ir_txd, /**< Texture look-up with partial derivatvies */ 1242 ir_txf, /**< Texel fetch with explicit LOD */ 1243 ir_txs /**< Texture size */ 1244}; 1245 1246 1247/** 1248 * IR instruction to sample a texture 1249 * 1250 * The specific form of the IR instruction depends on the \c mode value 1251 * selected from \c ir_texture_opcodes. In the printed IR, these will 1252 * appear as: 1253 * 1254 * Texel offset (0 or an expression) 1255 * | Projection divisor 1256 * | | Shadow comparitor 1257 * | | | 1258 * v v v 1259 * (tex <type> <sampler> <coordinate> 0 1 ( )) 1260 * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>) 1261 * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>) 1262 * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy)) 1263 * (txf <type> <sampler> <coordinate> 0 <lod>) 1264 * (txs <type> <sampler> <lod>) 1265 */ 1266class ir_texture : public ir_rvalue { 1267public: 1268 ir_texture(enum ir_texture_opcode op) 1269 : op(op), projector(NULL), shadow_comparitor(NULL), offset(NULL) 1270 { 1271 this->ir_type = ir_type_texture; 1272 } 1273 1274 virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const; 1275 1276 virtual ir_constant *constant_expression_value(); 1277 1278 virtual void accept(ir_visitor *v) 1279 { 1280 v->visit(this); 1281 } 1282 1283 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1284 1285 /** 1286 * Return a string representing the ir_texture_opcode. 1287 */ 1288 const char *opcode_string(); 1289 1290 /** Set the sampler and type. */ 1291 void set_sampler(ir_dereference *sampler, const glsl_type *type); 1292 1293 /** 1294 * Do a reverse-lookup to translate a string into an ir_texture_opcode. 1295 */ 1296 static ir_texture_opcode get_opcode(const char *); 1297 1298 enum ir_texture_opcode op; 1299 1300 /** Sampler to use for the texture access. */ 1301 ir_dereference *sampler; 1302 1303 /** Texture coordinate to sample */ 1304 ir_rvalue *coordinate; 1305 1306 /** 1307 * Value used for projective divide. 1308 * 1309 * If there is no projective divide (the common case), this will be 1310 * \c NULL. Optimization passes should check for this to point to a constant 1311 * of 1.0 and replace that with \c NULL. 1312 */ 1313 ir_rvalue *projector; 1314 1315 /** 1316 * Coordinate used for comparison on shadow look-ups. 1317 * 1318 * If there is no shadow comparison, this will be \c NULL. For the 1319 * \c ir_txf opcode, this *must* be \c NULL. 1320 */ 1321 ir_rvalue *shadow_comparitor; 1322 1323 /** Texel offset. */ 1324 ir_rvalue *offset; 1325 1326 union { 1327 ir_rvalue *lod; /**< Floating point LOD */ 1328 ir_rvalue *bias; /**< Floating point LOD bias */ 1329 struct { 1330 ir_rvalue *dPdx; /**< Partial derivative of coordinate wrt X */ 1331 ir_rvalue *dPdy; /**< Partial derivative of coordinate wrt Y */ 1332 } grad; 1333 } lod_info; 1334}; 1335 1336 1337struct ir_swizzle_mask { 1338 unsigned x:2; 1339 unsigned y:2; 1340 unsigned z:2; 1341 unsigned w:2; 1342 1343 /** 1344 * Number of components in the swizzle. 1345 */ 1346 unsigned num_components:3; 1347 1348 /** 1349 * Does the swizzle contain duplicate components? 1350 * 1351 * L-value swizzles cannot contain duplicate components. 1352 */ 1353 unsigned has_duplicates:1; 1354}; 1355 1356 1357class ir_swizzle : public ir_rvalue { 1358public: 1359 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w, 1360 unsigned count); 1361 1362 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count); 1363 1364 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask); 1365 1366 virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const; 1367 1368 virtual ir_constant *constant_expression_value(); 1369 1370 virtual ir_swizzle *as_swizzle() 1371 { 1372 return this; 1373 } 1374 1375 /** 1376 * Construct an ir_swizzle from the textual representation. Can fail. 1377 */ 1378 static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length); 1379 1380 virtual void accept(ir_visitor *v) 1381 { 1382 v->visit(this); 1383 } 1384 1385 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1386 1387 bool is_lvalue() const 1388 { 1389 return val->is_lvalue() && !mask.has_duplicates; 1390 } 1391 1392 /** 1393 * Get the variable that is ultimately referenced by an r-value 1394 */ 1395 virtual ir_variable *variable_referenced() const; 1396 1397 ir_rvalue *val; 1398 ir_swizzle_mask mask; 1399 1400private: 1401 /** 1402 * Initialize the mask component of a swizzle 1403 * 1404 * This is used by the \c ir_swizzle constructors. 1405 */ 1406 void init_mask(const unsigned *components, unsigned count); 1407}; 1408 1409 1410class ir_dereference : public ir_rvalue { 1411public: 1412 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0; 1413 1414 virtual ir_dereference *as_dereference() 1415 { 1416 return this; 1417 } 1418 1419 bool is_lvalue() const; 1420 1421 /** 1422 * Get the variable that is ultimately referenced by an r-value 1423 */ 1424 virtual ir_variable *variable_referenced() const = 0; 1425}; 1426 1427 1428class ir_dereference_variable : public ir_dereference { 1429public: 1430 ir_dereference_variable(ir_variable *var); 1431 1432 virtual ir_dereference_variable *clone(void *mem_ctx, 1433 struct hash_table *) const; 1434 1435 virtual ir_constant *constant_expression_value(); 1436 1437 virtual ir_dereference_variable *as_dereference_variable() 1438 { 1439 return this; 1440 } 1441 1442 /** 1443 * Get the variable that is ultimately referenced by an r-value 1444 */ 1445 virtual ir_variable *variable_referenced() const 1446 { 1447 return this->var; 1448 } 1449 1450 virtual ir_variable *whole_variable_referenced() 1451 { 1452 /* ir_dereference_variable objects always dereference the entire 1453 * variable. However, if this dereference is dereferenced by anything 1454 * else, the complete deferefernce chain is not a whole-variable 1455 * dereference. This method should only be called on the top most 1456 * ir_rvalue in a dereference chain. 1457 */ 1458 return this->var; 1459 } 1460 1461 virtual void accept(ir_visitor *v) 1462 { 1463 v->visit(this); 1464 } 1465 1466 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1467 1468 /** 1469 * Object being dereferenced. 1470 */ 1471 ir_variable *var; 1472}; 1473 1474 1475class ir_dereference_array : public ir_dereference { 1476public: 1477 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index); 1478 1479 ir_dereference_array(ir_variable *var, ir_rvalue *array_index); 1480 1481 virtual ir_dereference_array *clone(void *mem_ctx, 1482 struct hash_table *) const; 1483 1484 virtual ir_constant *constant_expression_value(); 1485 1486 virtual ir_dereference_array *as_dereference_array() 1487 { 1488 return this; 1489 } 1490 1491 /** 1492 * Get the variable that is ultimately referenced by an r-value 1493 */ 1494 virtual ir_variable *variable_referenced() const 1495 { 1496 return this->array->variable_referenced(); 1497 } 1498 1499 virtual void accept(ir_visitor *v) 1500 { 1501 v->visit(this); 1502 } 1503 1504 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1505 1506 ir_rvalue *array; 1507 ir_rvalue *array_index; 1508 1509private: 1510 void set_array(ir_rvalue *value); 1511}; 1512 1513 1514class ir_dereference_record : public ir_dereference { 1515public: 1516 ir_dereference_record(ir_rvalue *value, const char *field); 1517 1518 ir_dereference_record(ir_variable *var, const char *field); 1519 1520 virtual ir_dereference_record *clone(void *mem_ctx, 1521 struct hash_table *) const; 1522 1523 virtual ir_constant *constant_expression_value(); 1524 1525 /** 1526 * Get the variable that is ultimately referenced by an r-value 1527 */ 1528 virtual ir_variable *variable_referenced() const 1529 { 1530 return this->record->variable_referenced(); 1531 } 1532 1533 virtual void accept(ir_visitor *v) 1534 { 1535 v->visit(this); 1536 } 1537 1538 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1539 1540 ir_rvalue *record; 1541 const char *field; 1542}; 1543 1544 1545/** 1546 * Data stored in an ir_constant 1547 */ 1548union ir_constant_data { 1549 unsigned u[16]; 1550 int i[16]; 1551 float f[16]; 1552 bool b[16]; 1553}; 1554 1555 1556class ir_constant : public ir_rvalue { 1557public: 1558 ir_constant(const struct glsl_type *type, const ir_constant_data *data); 1559 ir_constant(bool b); 1560 ir_constant(unsigned int u); 1561 ir_constant(int i); 1562 ir_constant(float f); 1563 1564 /** 1565 * Construct an ir_constant from a list of ir_constant values 1566 */ 1567 ir_constant(const struct glsl_type *type, exec_list *values); 1568 1569 /** 1570 * Construct an ir_constant from a scalar component of another ir_constant 1571 * 1572 * The new \c ir_constant inherits the type of the component from the 1573 * source constant. 1574 * 1575 * \note 1576 * In the case of a matrix constant, the new constant is a scalar, \b not 1577 * a vector. 1578 */ 1579 ir_constant(const ir_constant *c, unsigned i); 1580 1581 /** 1582 * Return a new ir_constant of the specified type containing all zeros. 1583 */ 1584 static ir_constant *zero(void *mem_ctx, const glsl_type *type); 1585 1586 virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const; 1587 1588 virtual ir_constant *constant_expression_value(); 1589 1590 virtual ir_constant *as_constant() 1591 { 1592 return this; 1593 } 1594 1595 virtual void accept(ir_visitor *v) 1596 { 1597 v->visit(this); 1598 } 1599 1600 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1601 1602 /** 1603 * Get a particular component of a constant as a specific type 1604 * 1605 * This is useful, for example, to get a value from an integer constant 1606 * as a float or bool. This appears frequently when constructors are 1607 * called with all constant parameters. 1608 */ 1609 /*@{*/ 1610 bool get_bool_component(unsigned i) const; 1611 float get_float_component(unsigned i) const; 1612 int get_int_component(unsigned i) const; 1613 unsigned get_uint_component(unsigned i) const; 1614 /*@}*/ 1615 1616 ir_constant *get_array_element(unsigned i) const; 1617 1618 ir_constant *get_record_field(const char *name); 1619 1620 /** 1621 * Determine whether a constant has the same value as another constant 1622 * 1623 * \sa ir_constant::is_zero, ir_constant::is_one, 1624 * ir_constant::is_negative_one 1625 */ 1626 bool has_value(const ir_constant *) const; 1627 1628 virtual bool is_zero() const; 1629 virtual bool is_one() const; 1630 virtual bool is_negative_one() const; 1631 1632 /** 1633 * Value of the constant. 1634 * 1635 * The field used to back the values supplied by the constant is determined 1636 * by the type associated with the \c ir_instruction. Constants may be 1637 * scalars, vectors, or matrices. 1638 */ 1639 union ir_constant_data value; 1640 1641 /* Array elements */ 1642 ir_constant **array_elements; 1643 1644 /* Structure fields */ 1645 exec_list components; 1646 1647private: 1648 /** 1649 * Parameterless constructor only used by the clone method 1650 */ 1651 ir_constant(void); 1652}; 1653 1654/*@}*/ 1655 1656/** 1657 * Apply a visitor to each IR node in a list 1658 */ 1659void 1660visit_exec_list(exec_list *list, ir_visitor *visitor); 1661 1662/** 1663 * Validate invariants on each IR node in a list 1664 */ 1665void validate_ir_tree(exec_list *instructions); 1666 1667struct _mesa_glsl_parse_state; 1668struct gl_shader_program; 1669 1670/** 1671 * Detect whether an unlinked shader contains static recursion 1672 * 1673 * If the list of instructions is determined to contain static recursion, 1674 * \c _mesa_glsl_error will be called to emit error messages for each function 1675 * that is in the recursion cycle. 1676 */ 1677void 1678detect_recursion_unlinked(struct _mesa_glsl_parse_state *state, 1679 exec_list *instructions); 1680 1681/** 1682 * Detect whether a linked shader contains static recursion 1683 * 1684 * If the list of instructions is determined to contain static recursion, 1685 * \c link_error_printf will be called to emit error messages for each function 1686 * that is in the recursion cycle. In addition, 1687 * \c gl_shader_program::LinkStatus will be set to false. 1688 */ 1689void 1690detect_recursion_linked(struct gl_shader_program *prog, 1691 exec_list *instructions); 1692 1693/** 1694 * Make a clone of each IR instruction in a list 1695 * 1696 * \param in List of IR instructions that are to be cloned 1697 * \param out List to hold the cloned instructions 1698 */ 1699void 1700clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in); 1701 1702extern void 1703_mesa_glsl_initialize_variables(exec_list *instructions, 1704 struct _mesa_glsl_parse_state *state); 1705 1706extern void 1707_mesa_glsl_initialize_functions(_mesa_glsl_parse_state *state); 1708 1709extern void 1710_mesa_glsl_release_functions(void); 1711 1712extern void 1713reparent_ir(exec_list *list, void *mem_ctx); 1714 1715struct glsl_symbol_table; 1716 1717extern void 1718import_prototypes(const exec_list *source, exec_list *dest, 1719 struct glsl_symbol_table *symbols, void *mem_ctx); 1720 1721extern bool 1722ir_has_call(ir_instruction *ir); 1723 1724extern void 1725do_set_program_inouts(exec_list *instructions, struct gl_program *prog, 1726 bool is_fragment_shader); 1727 1728extern char * 1729prototype_string(const glsl_type *return_type, const char *name, 1730 exec_list *parameters); 1731 1732#endif /* IR_H */ 1733