ir.h revision 363c14ae0cd2baa624d85e8c9db12cd1677190ea
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 92 /** ir_print_visitor helper for debugging. */ 93 void print(void) const; 94 95 virtual void accept(ir_visitor *) = 0; 96 virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0; 97 virtual ir_instruction *clone(void *mem_ctx, 98 struct hash_table *ht) const = 0; 99 100 /** 101 * \name IR instruction downcast functions 102 * 103 * These functions either cast the object to a derived class or return 104 * \c NULL if the object's type does not match the specified derived class. 105 * Additional downcast functions will be added as needed. 106 */ 107 /*@{*/ 108 virtual class ir_variable * as_variable() { return NULL; } 109 virtual class ir_function * as_function() { return NULL; } 110 virtual class ir_dereference * as_dereference() { return NULL; } 111 virtual class ir_dereference_array * as_dereference_array() { return NULL; } 112 virtual class ir_dereference_variable *as_dereference_variable() { return NULL; } 113 virtual class ir_expression * as_expression() { return NULL; } 114 virtual class ir_rvalue * as_rvalue() { return NULL; } 115 virtual class ir_loop * as_loop() { return NULL; } 116 virtual class ir_assignment * as_assignment() { return NULL; } 117 virtual class ir_call * as_call() { return NULL; } 118 virtual class ir_return * as_return() { return NULL; } 119 virtual class ir_if * as_if() { return NULL; } 120 virtual class ir_swizzle * as_swizzle() { return NULL; } 121 virtual class ir_constant * as_constant() { return NULL; } 122 virtual class ir_discard * as_discard() { return NULL; } 123 /*@}*/ 124 125protected: 126 ir_instruction() 127 { 128 ir_type = ir_type_unset; 129 } 130}; 131 132 133/** 134 * The base class for all "values"/expression trees. 135 */ 136class ir_rvalue : public ir_instruction { 137public: 138 const struct glsl_type *type; 139 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(struct hash_table *variable_context = NULL); 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 * Declared type of the variable 325 */ 326 const struct glsl_type *type; 327 328 /** 329 * Delcared name of the variable 330 */ 331 const char *name; 332 333 /** 334 * Highest element accessed with a constant expression array index 335 * 336 * Not used for non-array variables. 337 */ 338 unsigned max_array_access; 339 340 /** 341 * Is the variable read-only? 342 * 343 * This is set for variables declared as \c const, shader inputs, 344 * and uniforms. 345 */ 346 unsigned read_only:1; 347 unsigned centroid:1; 348 unsigned invariant:1; 349 350 /** 351 * Has this variable been used for reading or writing? 352 * 353 * Several GLSL semantic checks require knowledge of whether or not a 354 * variable has been used. For example, it is an error to redeclare a 355 * variable as invariant after it has been used. 356 * 357 * This is only maintained in the ast_to_hir.cpp path, not in 358 * Mesa's fixed function or ARB program paths. 359 */ 360 unsigned used:1; 361 362 /** 363 * Has this variable been statically assigned? 364 * 365 * This answers whether the variable was assigned in any path of 366 * the shader during ast_to_hir. This doesn't answer whether it is 367 * still written after dead code removal, nor is it maintained in 368 * non-ast_to_hir.cpp (GLSL parsing) paths. 369 */ 370 unsigned assigned:1; 371 372 /** 373 * Storage class of the variable. 374 * 375 * \sa ir_variable_mode 376 */ 377 unsigned mode:3; 378 379 /** 380 * Interpolation mode for shader inputs / outputs 381 * 382 * \sa ir_variable_interpolation 383 */ 384 unsigned interpolation:2; 385 386 /** 387 * \name ARB_fragment_coord_conventions 388 * @{ 389 */ 390 unsigned origin_upper_left:1; 391 unsigned pixel_center_integer:1; 392 /*@}*/ 393 394 /** 395 * Was the location explicitly set in the shader? 396 * 397 * If the location is explicitly set in the shader, it \b cannot be changed 398 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have 399 * no effect). 400 */ 401 unsigned explicit_location:1; 402 unsigned explicit_index:1; 403 404 /** 405 * Does this variable have an initializer? 406 * 407 * This is used by the linker to cross-validiate initializers of global 408 * variables. 409 */ 410 unsigned has_initializer:1; 411 412 /** 413 * \brief Layout qualifier for gl_FragDepth. 414 * 415 * This is not equal to \c ir_depth_layout_none if and only if this 416 * variable is \c gl_FragDepth and a layout qualifier is specified. 417 */ 418 ir_depth_layout depth_layout; 419 420 /** 421 * Storage location of the base of this variable 422 * 423 * The precise meaning of this field depends on the nature of the variable. 424 * 425 * - Vertex shader input: one of the values from \c gl_vert_attrib. 426 * - Vertex shader output: one of the values from \c gl_vert_result. 427 * - Fragment shader input: one of the values from \c gl_frag_attrib. 428 * - Fragment shader output: one of the values from \c gl_frag_result. 429 * - Uniforms: Per-stage uniform slot number. 430 * - Other: This field is not currently used. 431 * 432 * If the variable is a uniform, shader input, or shader output, and the 433 * slot has not been assigned, the value will be -1. 434 */ 435 int location; 436 437 /** 438 * output index for dual source blending. 439 */ 440 int index; 441 442 /** 443 * Built-in state that backs this uniform 444 * 445 * Once set at variable creation, \c state_slots must remain invariant. 446 * This is because, ideally, this array would be shared by all clones of 447 * this variable in the IR tree. In other words, we'd really like for it 448 * to be a fly-weight. 449 * 450 * If the variable is not a uniform, \c num_state_slots will be zero and 451 * \c state_slots will be \c NULL. 452 */ 453 /*@{*/ 454 unsigned num_state_slots; /**< Number of state slots used */ 455 ir_state_slot *state_slots; /**< State descriptors. */ 456 /*@}*/ 457 458 /** 459 * Emit a warning if this variable is accessed. 460 */ 461 const char *warn_extension; 462 463 /** 464 * Value assigned in the initializer of a variable declared "const" 465 */ 466 ir_constant *constant_value; 467 468 /** 469 * Constant expression assigned in the initializer of the variable 470 * 471 * \warning 472 * This field and \c ::constant_value are distinct. Even if the two fields 473 * refer to constants with the same value, they must point to separate 474 * objects. 475 */ 476 ir_constant *constant_initializer; 477}; 478 479 480/*@{*/ 481/** 482 * The representation of a function instance; may be the full definition or 483 * simply a prototype. 484 */ 485class ir_function_signature : public ir_instruction { 486 /* An ir_function_signature will be part of the list of signatures in 487 * an ir_function. 488 */ 489public: 490 ir_function_signature(const glsl_type *return_type); 491 492 virtual ir_function_signature *clone(void *mem_ctx, 493 struct hash_table *ht) const; 494 ir_function_signature *clone_prototype(void *mem_ctx, 495 struct hash_table *ht) const; 496 497 virtual void accept(ir_visitor *v) 498 { 499 v->visit(this); 500 } 501 502 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 503 504 /** 505 * Attempt to evaluate this function as a constant expression, 506 * given a list of the actual parameters and the variable context. 507 * Returns NULL for non-built-ins. 508 */ 509 ir_constant *constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context); 510 511 /** 512 * Get the name of the function for which this is a signature 513 */ 514 const char *function_name() const; 515 516 /** 517 * Get a handle to the function for which this is a signature 518 * 519 * There is no setter function, this function returns a \c const pointer, 520 * and \c ir_function_signature::_function is private for a reason. The 521 * only way to make a connection between a function and function signature 522 * is via \c ir_function::add_signature. This helps ensure that certain 523 * invariants (i.e., a function signature is in the list of signatures for 524 * its \c _function) are met. 525 * 526 * \sa ir_function::add_signature 527 */ 528 inline const class ir_function *function() const 529 { 530 return this->_function; 531 } 532 533 /** 534 * Check whether the qualifiers match between this signature's parameters 535 * and the supplied parameter list. If not, returns the name of the first 536 * parameter with mismatched qualifiers (for use in error messages). 537 */ 538 const char *qualifiers_match(exec_list *params); 539 540 /** 541 * Replace the current parameter list with the given one. This is useful 542 * if the current information came from a prototype, and either has invalid 543 * or missing parameter names. 544 */ 545 void replace_parameters(exec_list *new_params); 546 547 /** 548 * Function return type. 549 * 550 * \note This discards the optional precision qualifier. 551 */ 552 const struct glsl_type *return_type; 553 554 /** 555 * List of ir_variable of function parameters. 556 * 557 * This represents the storage. The paramaters passed in a particular 558 * call will be in ir_call::actual_paramaters. 559 */ 560 struct exec_list parameters; 561 562 /** Whether or not this function has a body (which may be empty). */ 563 unsigned is_defined:1; 564 565 /** Whether or not this function signature is a built-in. */ 566 unsigned is_builtin:1; 567 568 /** Body of instructions in the function. */ 569 struct exec_list body; 570 571private: 572 /** Function of which this signature is one overload. */ 573 class ir_function *_function; 574 575 /** Function signature of which this one is a prototype clone */ 576 const ir_function_signature *origin; 577 578 friend class ir_function; 579 580 /** 581 * Helper function to run a list of instructions for constant 582 * expression evaluation. 583 * 584 * The hash table represents the values of the visible variables. 585 * There are no scoping issues because the table is indexed on 586 * ir_variable pointers, not variable names. 587 * 588 * Returns false if the expression is not constant, true otherwise, 589 * and the value in *result if result is non-NULL. 590 */ 591 bool constant_expression_evaluate_expression_list(const struct exec_list &body, 592 struct hash_table *variable_context, 593 ir_constant **result); 594}; 595 596 597/** 598 * Header for tracking multiple overloaded functions with the same name. 599 * Contains a list of ir_function_signatures representing each of the 600 * actual functions. 601 */ 602class ir_function : public ir_instruction { 603public: 604 ir_function(const char *name); 605 606 virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const; 607 608 virtual ir_function *as_function() 609 { 610 return this; 611 } 612 613 virtual void accept(ir_visitor *v) 614 { 615 v->visit(this); 616 } 617 618 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 619 620 void add_signature(ir_function_signature *sig) 621 { 622 sig->_function = this; 623 this->signatures.push_tail(sig); 624 } 625 626 /** 627 * Get an iterator for the set of function signatures 628 */ 629 exec_list_iterator iterator() 630 { 631 return signatures.iterator(); 632 } 633 634 /** 635 * Find a signature that matches a set of actual parameters, taking implicit 636 * conversions into account. Also flags whether the match was exact. 637 */ 638 ir_function_signature *matching_signature(const exec_list *actual_param, 639 bool *match_is_exact); 640 641 /** 642 * Find a signature that matches a set of actual parameters, taking implicit 643 * conversions into account. 644 */ 645 ir_function_signature *matching_signature(const exec_list *actual_param); 646 647 /** 648 * Find a signature that exactly matches a set of actual parameters without 649 * any implicit type conversions. 650 */ 651 ir_function_signature *exact_matching_signature(const exec_list *actual_ps); 652 653 /** 654 * Name of the function. 655 */ 656 const char *name; 657 658 /** Whether or not this function has a signature that isn't a built-in. */ 659 bool has_user_signature(); 660 661 /** 662 * List of ir_function_signature for each overloaded function with this name. 663 */ 664 struct exec_list signatures; 665}; 666 667inline const char *ir_function_signature::function_name() const 668{ 669 return this->_function->name; 670} 671/*@}*/ 672 673 674/** 675 * IR instruction representing high-level if-statements 676 */ 677class ir_if : public ir_instruction { 678public: 679 ir_if(ir_rvalue *condition) 680 : condition(condition) 681 { 682 ir_type = ir_type_if; 683 } 684 685 virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const; 686 687 virtual ir_if *as_if() 688 { 689 return this; 690 } 691 692 virtual void accept(ir_visitor *v) 693 { 694 v->visit(this); 695 } 696 697 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 698 699 ir_rvalue *condition; 700 /** List of ir_instruction for the body of the then branch */ 701 exec_list then_instructions; 702 /** List of ir_instruction for the body of the else branch */ 703 exec_list else_instructions; 704}; 705 706 707/** 708 * IR instruction representing a high-level loop structure. 709 */ 710class ir_loop : public ir_instruction { 711public: 712 ir_loop(); 713 714 virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const; 715 716 virtual void accept(ir_visitor *v) 717 { 718 v->visit(this); 719 } 720 721 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 722 723 virtual ir_loop *as_loop() 724 { 725 return this; 726 } 727 728 /** 729 * Get an iterator for the instructions of the loop body 730 */ 731 exec_list_iterator iterator() 732 { 733 return body_instructions.iterator(); 734 } 735 736 /** List of ir_instruction that make up the body of the loop. */ 737 exec_list body_instructions; 738 739 /** 740 * \name Loop counter and controls 741 * 742 * Represents a loop like a FORTRAN \c do-loop. 743 * 744 * \note 745 * If \c from and \c to are the same value, the loop will execute once. 746 */ 747 /*@{*/ 748 ir_rvalue *from; /** Value of the loop counter on the first 749 * iteration of the loop. 750 */ 751 ir_rvalue *to; /** Value of the loop counter on the last 752 * iteration of the loop. 753 */ 754 ir_rvalue *increment; 755 ir_variable *counter; 756 757 /** 758 * Comparison operation in the loop terminator. 759 * 760 * If any of the loop control fields are non-\c NULL, this field must be 761 * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal, 762 * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal. 763 */ 764 int cmp; 765 /*@}*/ 766}; 767 768 769class ir_assignment : public ir_instruction { 770public: 771 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL); 772 773 /** 774 * Construct an assignment with an explicit write mask 775 * 776 * \note 777 * Since a write mask is supplied, the LHS must already be a bare 778 * \c ir_dereference. The cannot be any swizzles in the LHS. 779 */ 780 ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition, 781 unsigned write_mask); 782 783 virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const; 784 785 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 786 787 virtual void accept(ir_visitor *v) 788 { 789 v->visit(this); 790 } 791 792 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 793 794 virtual ir_assignment * as_assignment() 795 { 796 return this; 797 } 798 799 /** 800 * Get a whole variable written by an assignment 801 * 802 * If the LHS of the assignment writes a whole variable, the variable is 803 * returned. Otherwise \c NULL is returned. Examples of whole-variable 804 * assignment are: 805 * 806 * - Assigning to a scalar 807 * - Assigning to all components of a vector 808 * - Whole array (or matrix) assignment 809 * - Whole structure assignment 810 */ 811 ir_variable *whole_variable_written(); 812 813 /** 814 * Set the LHS of an assignment 815 */ 816 void set_lhs(ir_rvalue *lhs); 817 818 /** 819 * Left-hand side of the assignment. 820 * 821 * This should be treated as read only. If you need to set the LHS of an 822 * assignment, use \c ir_assignment::set_lhs. 823 */ 824 ir_dereference *lhs; 825 826 /** 827 * Value being assigned 828 */ 829 ir_rvalue *rhs; 830 831 /** 832 * Optional condition for the assignment. 833 */ 834 ir_rvalue *condition; 835 836 837 /** 838 * Component mask written 839 * 840 * For non-vector types in the LHS, this field will be zero. For vector 841 * types, a bit will be set for each component that is written. Note that 842 * for \c vec2 and \c vec3 types only the lower bits will ever be set. 843 * 844 * A partially-set write mask means that each enabled channel gets 845 * the value from a consecutive channel of the rhs. For example, 846 * to write just .xyw of gl_FrontColor with color: 847 * 848 * (assign (constant bool (1)) (xyw) 849 * (var_ref gl_FragColor) 850 * (swiz xyw (var_ref color))) 851 */ 852 unsigned write_mask:4; 853}; 854 855/* Update ir_expression::num_operands() and operator_strs when 856 * updating this list. 857 */ 858enum ir_expression_operation { 859 ir_unop_bit_not, 860 ir_unop_logic_not, 861 ir_unop_neg, 862 ir_unop_abs, 863 ir_unop_sign, 864 ir_unop_rcp, 865 ir_unop_rsq, 866 ir_unop_sqrt, 867 ir_unop_exp, /**< Log base e on gentype */ 868 ir_unop_log, /**< Natural log on gentype */ 869 ir_unop_exp2, 870 ir_unop_log2, 871 ir_unop_f2i, /**< Float-to-integer conversion. */ 872 ir_unop_i2f, /**< Integer-to-float conversion. */ 873 ir_unop_f2b, /**< Float-to-boolean conversion */ 874 ir_unop_b2f, /**< Boolean-to-float conversion */ 875 ir_unop_i2b, /**< int-to-boolean conversion */ 876 ir_unop_b2i, /**< Boolean-to-int conversion */ 877 ir_unop_u2f, /**< Unsigned-to-float conversion. */ 878 ir_unop_i2u, /**< Integer-to-unsigned conversion. */ 879 ir_unop_u2i, /**< Unsigned-to-integer conversion. */ 880 ir_unop_any, 881 882 /** 883 * \name Unary floating-point rounding operations. 884 */ 885 /*@{*/ 886 ir_unop_trunc, 887 ir_unop_ceil, 888 ir_unop_floor, 889 ir_unop_fract, 890 ir_unop_round_even, 891 /*@}*/ 892 893 /** 894 * \name Trigonometric operations. 895 */ 896 /*@{*/ 897 ir_unop_sin, 898 ir_unop_cos, 899 ir_unop_sin_reduced, /**< Reduced range sin. [-pi, pi] */ 900 ir_unop_cos_reduced, /**< Reduced range cos. [-pi, pi] */ 901 /*@}*/ 902 903 /** 904 * \name Partial derivatives. 905 */ 906 /*@{*/ 907 ir_unop_dFdx, 908 ir_unop_dFdy, 909 /*@}*/ 910 911 ir_unop_noise, 912 913 /** 914 * A sentinel marking the last of the unary operations. 915 */ 916 ir_last_unop = ir_unop_noise, 917 918 ir_binop_add, 919 ir_binop_sub, 920 ir_binop_mul, 921 ir_binop_div, 922 923 /** 924 * Takes one of two combinations of arguments: 925 * 926 * - mod(vecN, vecN) 927 * - mod(vecN, float) 928 * 929 * Does not take integer types. 930 */ 931 ir_binop_mod, 932 933 /** 934 * \name Binary comparison operators which return a boolean vector. 935 * The type of both operands must be equal. 936 */ 937 /*@{*/ 938 ir_binop_less, 939 ir_binop_greater, 940 ir_binop_lequal, 941 ir_binop_gequal, 942 ir_binop_equal, 943 ir_binop_nequal, 944 /** 945 * Returns single boolean for whether all components of operands[0] 946 * equal the components of operands[1]. 947 */ 948 ir_binop_all_equal, 949 /** 950 * Returns single boolean for whether any component of operands[0] 951 * is not equal to the corresponding component of operands[1]. 952 */ 953 ir_binop_any_nequal, 954 /*@}*/ 955 956 /** 957 * \name Bit-wise binary operations. 958 */ 959 /*@{*/ 960 ir_binop_lshift, 961 ir_binop_rshift, 962 ir_binop_bit_and, 963 ir_binop_bit_xor, 964 ir_binop_bit_or, 965 /*@}*/ 966 967 ir_binop_logic_and, 968 ir_binop_logic_xor, 969 ir_binop_logic_or, 970 971 ir_binop_dot, 972 ir_binop_min, 973 ir_binop_max, 974 975 ir_binop_pow, 976 977 /** 978 * A sentinel marking the last of the binary operations. 979 */ 980 ir_last_binop = ir_binop_pow, 981 982 ir_quadop_vector, 983 984 /** 985 * A sentinel marking the last of all operations. 986 */ 987 ir_last_opcode = ir_last_binop 988}; 989 990class ir_expression : public ir_rvalue { 991public: 992 /** 993 * Constructor for unary operation expressions 994 */ 995 ir_expression(int op, const struct glsl_type *type, ir_rvalue *); 996 ir_expression(int op, ir_rvalue *); 997 998 /** 999 * Constructor for binary operation expressions 1000 */ 1001 ir_expression(int op, const struct glsl_type *type, 1002 ir_rvalue *, ir_rvalue *); 1003 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1); 1004 1005 /** 1006 * Constructor for quad operator expressions 1007 */ 1008 ir_expression(int op, const struct glsl_type *type, 1009 ir_rvalue *, ir_rvalue *, ir_rvalue *, ir_rvalue *); 1010 1011 virtual ir_expression *as_expression() 1012 { 1013 return this; 1014 } 1015 1016 virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const; 1017 1018 /** 1019 * Attempt to constant-fold the expression 1020 * 1021 * The "variable_context" hash table links ir_variable * to ir_constant * 1022 * that represent the variables' values. \c NULL represents an empty 1023 * context. 1024 * 1025 * If the expression cannot be constant folded, this method will return 1026 * \c NULL. 1027 */ 1028 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1029 1030 /** 1031 * Determine the number of operands used by an expression 1032 */ 1033 static unsigned int get_num_operands(ir_expression_operation); 1034 1035 /** 1036 * Determine the number of operands used by an expression 1037 */ 1038 unsigned int get_num_operands() const 1039 { 1040 return (this->operation == ir_quadop_vector) 1041 ? this->type->vector_elements : get_num_operands(operation); 1042 } 1043 1044 /** 1045 * Return a string representing this expression's operator. 1046 */ 1047 const char *operator_string(); 1048 1049 /** 1050 * Return a string representing this expression's operator. 1051 */ 1052 static const char *operator_string(ir_expression_operation); 1053 1054 1055 /** 1056 * Do a reverse-lookup to translate the given string into an operator. 1057 */ 1058 static ir_expression_operation get_operator(const char *); 1059 1060 virtual void accept(ir_visitor *v) 1061 { 1062 v->visit(this); 1063 } 1064 1065 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1066 1067 ir_expression_operation operation; 1068 ir_rvalue *operands[4]; 1069}; 1070 1071 1072/** 1073 * HIR instruction representing a high-level function call, containing a list 1074 * of parameters and returning a value in the supplied temporary. 1075 */ 1076class ir_call : public ir_instruction { 1077public: 1078 ir_call(ir_function_signature *callee, 1079 ir_dereference_variable *return_deref, 1080 exec_list *actual_parameters) 1081 : return_deref(return_deref), callee(callee) 1082 { 1083 ir_type = ir_type_call; 1084 assert(callee->return_type != NULL); 1085 actual_parameters->move_nodes_to(& this->actual_parameters); 1086 this->use_builtin = callee->is_builtin; 1087 } 1088 1089 virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const; 1090 1091 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1092 1093 virtual ir_call *as_call() 1094 { 1095 return this; 1096 } 1097 1098 virtual void accept(ir_visitor *v) 1099 { 1100 v->visit(this); 1101 } 1102 1103 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1104 1105 /** 1106 * Get an iterator for the set of acutal parameters 1107 */ 1108 exec_list_iterator iterator() 1109 { 1110 return actual_parameters.iterator(); 1111 } 1112 1113 /** 1114 * Get the name of the function being called. 1115 */ 1116 const char *callee_name() const 1117 { 1118 return callee->function_name(); 1119 } 1120 1121 /** 1122 * Generates an inline version of the function before @ir, 1123 * storing the return value in return_deref. 1124 */ 1125 void generate_inline(ir_instruction *ir); 1126 1127 /** 1128 * Storage for the function's return value. 1129 * This must be NULL if the return type is void. 1130 */ 1131 ir_dereference_variable *return_deref; 1132 1133 /** 1134 * The specific function signature being called. 1135 */ 1136 ir_function_signature *callee; 1137 1138 /* List of ir_rvalue of paramaters passed in this call. */ 1139 exec_list actual_parameters; 1140 1141 /** Should this call only bind to a built-in function? */ 1142 bool use_builtin; 1143}; 1144 1145 1146/** 1147 * \name Jump-like IR instructions. 1148 * 1149 * These include \c break, \c continue, \c return, and \c discard. 1150 */ 1151/*@{*/ 1152class ir_jump : public ir_instruction { 1153protected: 1154 ir_jump() 1155 { 1156 ir_type = ir_type_unset; 1157 } 1158}; 1159 1160class ir_return : public ir_jump { 1161public: 1162 ir_return() 1163 : value(NULL) 1164 { 1165 this->ir_type = ir_type_return; 1166 } 1167 1168 ir_return(ir_rvalue *value) 1169 : value(value) 1170 { 1171 this->ir_type = ir_type_return; 1172 } 1173 1174 virtual ir_return *clone(void *mem_ctx, struct hash_table *) const; 1175 1176 virtual ir_return *as_return() 1177 { 1178 return this; 1179 } 1180 1181 ir_rvalue *get_value() const 1182 { 1183 return value; 1184 } 1185 1186 virtual void accept(ir_visitor *v) 1187 { 1188 v->visit(this); 1189 } 1190 1191 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1192 1193 ir_rvalue *value; 1194}; 1195 1196 1197/** 1198 * Jump instructions used inside loops 1199 * 1200 * These include \c break and \c continue. The \c break within a loop is 1201 * different from the \c break within a switch-statement. 1202 * 1203 * \sa ir_switch_jump 1204 */ 1205class ir_loop_jump : public ir_jump { 1206public: 1207 enum jump_mode { 1208 jump_break, 1209 jump_continue 1210 }; 1211 1212 ir_loop_jump(jump_mode mode) 1213 { 1214 this->ir_type = ir_type_loop_jump; 1215 this->mode = mode; 1216 this->loop = loop; 1217 } 1218 1219 virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const; 1220 1221 virtual void accept(ir_visitor *v) 1222 { 1223 v->visit(this); 1224 } 1225 1226 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1227 1228 bool is_break() const 1229 { 1230 return mode == jump_break; 1231 } 1232 1233 bool is_continue() const 1234 { 1235 return mode == jump_continue; 1236 } 1237 1238 /** Mode selector for the jump instruction. */ 1239 enum jump_mode mode; 1240private: 1241 /** Loop containing this break instruction. */ 1242 ir_loop *loop; 1243}; 1244 1245/** 1246 * IR instruction representing discard statements. 1247 */ 1248class ir_discard : public ir_jump { 1249public: 1250 ir_discard() 1251 { 1252 this->ir_type = ir_type_discard; 1253 this->condition = NULL; 1254 } 1255 1256 ir_discard(ir_rvalue *cond) 1257 { 1258 this->ir_type = ir_type_discard; 1259 this->condition = cond; 1260 } 1261 1262 virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const; 1263 1264 virtual void accept(ir_visitor *v) 1265 { 1266 v->visit(this); 1267 } 1268 1269 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1270 1271 virtual ir_discard *as_discard() 1272 { 1273 return this; 1274 } 1275 1276 ir_rvalue *condition; 1277}; 1278/*@}*/ 1279 1280 1281/** 1282 * Texture sampling opcodes used in ir_texture 1283 */ 1284enum ir_texture_opcode { 1285 ir_tex, /**< Regular texture look-up */ 1286 ir_txb, /**< Texture look-up with LOD bias */ 1287 ir_txl, /**< Texture look-up with explicit LOD */ 1288 ir_txd, /**< Texture look-up with partial derivatvies */ 1289 ir_txf, /**< Texel fetch with explicit LOD */ 1290 ir_txs /**< Texture size */ 1291}; 1292 1293 1294/** 1295 * IR instruction to sample a texture 1296 * 1297 * The specific form of the IR instruction depends on the \c mode value 1298 * selected from \c ir_texture_opcodes. In the printed IR, these will 1299 * appear as: 1300 * 1301 * Texel offset (0 or an expression) 1302 * | Projection divisor 1303 * | | Shadow comparitor 1304 * | | | 1305 * v v v 1306 * (tex <type> <sampler> <coordinate> 0 1 ( )) 1307 * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>) 1308 * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>) 1309 * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy)) 1310 * (txf <type> <sampler> <coordinate> 0 <lod>) 1311 * (txs <type> <sampler> <lod>) 1312 */ 1313class ir_texture : public ir_rvalue { 1314public: 1315 ir_texture(enum ir_texture_opcode op) 1316 : op(op), projector(NULL), shadow_comparitor(NULL), offset(NULL) 1317 { 1318 this->ir_type = ir_type_texture; 1319 } 1320 1321 virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const; 1322 1323 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1324 1325 virtual void accept(ir_visitor *v) 1326 { 1327 v->visit(this); 1328 } 1329 1330 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1331 1332 /** 1333 * Return a string representing the ir_texture_opcode. 1334 */ 1335 const char *opcode_string(); 1336 1337 /** Set the sampler and type. */ 1338 void set_sampler(ir_dereference *sampler, const glsl_type *type); 1339 1340 /** 1341 * Do a reverse-lookup to translate a string into an ir_texture_opcode. 1342 */ 1343 static ir_texture_opcode get_opcode(const char *); 1344 1345 enum ir_texture_opcode op; 1346 1347 /** Sampler to use for the texture access. */ 1348 ir_dereference *sampler; 1349 1350 /** Texture coordinate to sample */ 1351 ir_rvalue *coordinate; 1352 1353 /** 1354 * Value used for projective divide. 1355 * 1356 * If there is no projective divide (the common case), this will be 1357 * \c NULL. Optimization passes should check for this to point to a constant 1358 * of 1.0 and replace that with \c NULL. 1359 */ 1360 ir_rvalue *projector; 1361 1362 /** 1363 * Coordinate used for comparison on shadow look-ups. 1364 * 1365 * If there is no shadow comparison, this will be \c NULL. For the 1366 * \c ir_txf opcode, this *must* be \c NULL. 1367 */ 1368 ir_rvalue *shadow_comparitor; 1369 1370 /** Texel offset. */ 1371 ir_rvalue *offset; 1372 1373 union { 1374 ir_rvalue *lod; /**< Floating point LOD */ 1375 ir_rvalue *bias; /**< Floating point LOD bias */ 1376 struct { 1377 ir_rvalue *dPdx; /**< Partial derivative of coordinate wrt X */ 1378 ir_rvalue *dPdy; /**< Partial derivative of coordinate wrt Y */ 1379 } grad; 1380 } lod_info; 1381}; 1382 1383 1384struct ir_swizzle_mask { 1385 unsigned x:2; 1386 unsigned y:2; 1387 unsigned z:2; 1388 unsigned w:2; 1389 1390 /** 1391 * Number of components in the swizzle. 1392 */ 1393 unsigned num_components:3; 1394 1395 /** 1396 * Does the swizzle contain duplicate components? 1397 * 1398 * L-value swizzles cannot contain duplicate components. 1399 */ 1400 unsigned has_duplicates:1; 1401}; 1402 1403 1404class ir_swizzle : public ir_rvalue { 1405public: 1406 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w, 1407 unsigned count); 1408 1409 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count); 1410 1411 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask); 1412 1413 virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const; 1414 1415 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1416 1417 virtual ir_swizzle *as_swizzle() 1418 { 1419 return this; 1420 } 1421 1422 /** 1423 * Construct an ir_swizzle from the textual representation. Can fail. 1424 */ 1425 static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length); 1426 1427 virtual void accept(ir_visitor *v) 1428 { 1429 v->visit(this); 1430 } 1431 1432 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1433 1434 bool is_lvalue() const 1435 { 1436 return val->is_lvalue() && !mask.has_duplicates; 1437 } 1438 1439 /** 1440 * Get the variable that is ultimately referenced by an r-value 1441 */ 1442 virtual ir_variable *variable_referenced() const; 1443 1444 ir_rvalue *val; 1445 ir_swizzle_mask mask; 1446 1447private: 1448 /** 1449 * Initialize the mask component of a swizzle 1450 * 1451 * This is used by the \c ir_swizzle constructors. 1452 */ 1453 void init_mask(const unsigned *components, unsigned count); 1454}; 1455 1456 1457class ir_dereference : public ir_rvalue { 1458public: 1459 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0; 1460 1461 virtual ir_dereference *as_dereference() 1462 { 1463 return this; 1464 } 1465 1466 bool is_lvalue() const; 1467 1468 /** 1469 * Get the variable that is ultimately referenced by an r-value 1470 */ 1471 virtual ir_variable *variable_referenced() const = 0; 1472 1473 /** 1474 * Get the constant that is ultimately referenced by an r-value, 1475 * in a constant expression evaluation context. 1476 * 1477 * The offset is used when the reference is to a specific column of 1478 * a matrix. 1479 */ 1480 virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const = 0; 1481}; 1482 1483 1484class ir_dereference_variable : public ir_dereference { 1485public: 1486 ir_dereference_variable(ir_variable *var); 1487 1488 virtual ir_dereference_variable *clone(void *mem_ctx, 1489 struct hash_table *) const; 1490 1491 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1492 1493 virtual ir_dereference_variable *as_dereference_variable() 1494 { 1495 return this; 1496 } 1497 1498 /** 1499 * Get the variable that is ultimately referenced by an r-value 1500 */ 1501 virtual ir_variable *variable_referenced() const 1502 { 1503 return this->var; 1504 } 1505 1506 /** 1507 * Get the constant that is ultimately referenced by an r-value, 1508 * in a constant expression evaluation context. 1509 * 1510 * The offset is used when the reference is to a specific column of 1511 * a matrix. 1512 */ 1513 virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const; 1514 1515 virtual ir_variable *whole_variable_referenced() 1516 { 1517 /* ir_dereference_variable objects always dereference the entire 1518 * variable. However, if this dereference is dereferenced by anything 1519 * else, the complete deferefernce chain is not a whole-variable 1520 * dereference. This method should only be called on the top most 1521 * ir_rvalue in a dereference chain. 1522 */ 1523 return this->var; 1524 } 1525 1526 virtual void accept(ir_visitor *v) 1527 { 1528 v->visit(this); 1529 } 1530 1531 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1532 1533 /** 1534 * Object being dereferenced. 1535 */ 1536 ir_variable *var; 1537}; 1538 1539 1540class ir_dereference_array : public ir_dereference { 1541public: 1542 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index); 1543 1544 ir_dereference_array(ir_variable *var, ir_rvalue *array_index); 1545 1546 virtual ir_dereference_array *clone(void *mem_ctx, 1547 struct hash_table *) const; 1548 1549 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1550 1551 virtual ir_dereference_array *as_dereference_array() 1552 { 1553 return this; 1554 } 1555 1556 /** 1557 * Get the variable that is ultimately referenced by an r-value 1558 */ 1559 virtual ir_variable *variable_referenced() const 1560 { 1561 return this->array->variable_referenced(); 1562 } 1563 1564 /** 1565 * Get the constant that is ultimately referenced by an r-value, 1566 * in a constant expression evaluation context. 1567 * 1568 * The offset is used when the reference is to a specific column of 1569 * a matrix. 1570 */ 1571 virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const; 1572 1573 virtual void accept(ir_visitor *v) 1574 { 1575 v->visit(this); 1576 } 1577 1578 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1579 1580 ir_rvalue *array; 1581 ir_rvalue *array_index; 1582 1583private: 1584 void set_array(ir_rvalue *value); 1585}; 1586 1587 1588class ir_dereference_record : public ir_dereference { 1589public: 1590 ir_dereference_record(ir_rvalue *value, const char *field); 1591 1592 ir_dereference_record(ir_variable *var, const char *field); 1593 1594 virtual ir_dereference_record *clone(void *mem_ctx, 1595 struct hash_table *) const; 1596 1597 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1598 1599 /** 1600 * Get the variable that is ultimately referenced by an r-value 1601 */ 1602 virtual ir_variable *variable_referenced() const 1603 { 1604 return this->record->variable_referenced(); 1605 } 1606 1607 /** 1608 * Get the constant that is ultimately referenced by an r-value, 1609 * in a constant expression evaluation context. 1610 * 1611 * The offset is used when the reference is to a specific column of 1612 * a matrix. 1613 */ 1614 virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const; 1615 1616 virtual void accept(ir_visitor *v) 1617 { 1618 v->visit(this); 1619 } 1620 1621 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1622 1623 ir_rvalue *record; 1624 const char *field; 1625}; 1626 1627 1628/** 1629 * Data stored in an ir_constant 1630 */ 1631union ir_constant_data { 1632 unsigned u[16]; 1633 int i[16]; 1634 float f[16]; 1635 bool b[16]; 1636}; 1637 1638 1639class ir_constant : public ir_rvalue { 1640public: 1641 ir_constant(const struct glsl_type *type, const ir_constant_data *data); 1642 ir_constant(bool b); 1643 ir_constant(unsigned int u); 1644 ir_constant(int i); 1645 ir_constant(float f); 1646 1647 /** 1648 * Construct an ir_constant from a list of ir_constant values 1649 */ 1650 ir_constant(const struct glsl_type *type, exec_list *values); 1651 1652 /** 1653 * Construct an ir_constant from a scalar component of another ir_constant 1654 * 1655 * The new \c ir_constant inherits the type of the component from the 1656 * source constant. 1657 * 1658 * \note 1659 * In the case of a matrix constant, the new constant is a scalar, \b not 1660 * a vector. 1661 */ 1662 ir_constant(const ir_constant *c, unsigned i); 1663 1664 /** 1665 * Return a new ir_constant of the specified type containing all zeros. 1666 */ 1667 static ir_constant *zero(void *mem_ctx, const glsl_type *type); 1668 1669 virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const; 1670 1671 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL); 1672 1673 virtual ir_constant *as_constant() 1674 { 1675 return this; 1676 } 1677 1678 virtual void accept(ir_visitor *v) 1679 { 1680 v->visit(this); 1681 } 1682 1683 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1684 1685 /** 1686 * Get a particular component of a constant as a specific type 1687 * 1688 * This is useful, for example, to get a value from an integer constant 1689 * as a float or bool. This appears frequently when constructors are 1690 * called with all constant parameters. 1691 */ 1692 /*@{*/ 1693 bool get_bool_component(unsigned i) const; 1694 float get_float_component(unsigned i) const; 1695 int get_int_component(unsigned i) const; 1696 unsigned get_uint_component(unsigned i) const; 1697 /*@}*/ 1698 1699 ir_constant *get_array_element(unsigned i) const; 1700 1701 ir_constant *get_record_field(const char *name); 1702 1703 /** 1704 * Copy the values on another constant at a given offset. 1705 * 1706 * The offset is ignored for array or struct copies, it's only for 1707 * scalars or vectors into vectors or matrices. 1708 * 1709 * With identical types on both sides and zero offset it's clone() 1710 * without creating a new object. 1711 */ 1712 1713 void copy_offset(ir_constant *src, int offset); 1714 1715 /** 1716 * Copy the values on another constant at a given offset and 1717 * following an assign-like mask. 1718 * 1719 * The mask is ignored for scalars. 1720 * 1721 * Note that this function only handles what assign can handle, 1722 * i.e. at most a vector as source and a column of a matrix as 1723 * destination. 1724 */ 1725 1726 void copy_masked_offset(ir_constant *src, int offset, unsigned int mask); 1727 1728 /** 1729 * Determine whether a constant has the same value as another constant 1730 * 1731 * \sa ir_constant::is_zero, ir_constant::is_one, 1732 * ir_constant::is_negative_one 1733 */ 1734 bool has_value(const ir_constant *) const; 1735 1736 virtual bool is_zero() const; 1737 virtual bool is_one() const; 1738 virtual bool is_negative_one() const; 1739 1740 /** 1741 * Value of the constant. 1742 * 1743 * The field used to back the values supplied by the constant is determined 1744 * by the type associated with the \c ir_instruction. Constants may be 1745 * scalars, vectors, or matrices. 1746 */ 1747 union ir_constant_data value; 1748 1749 /* Array elements */ 1750 ir_constant **array_elements; 1751 1752 /* Structure fields */ 1753 exec_list components; 1754 1755private: 1756 /** 1757 * Parameterless constructor only used by the clone method 1758 */ 1759 ir_constant(void); 1760}; 1761 1762/*@}*/ 1763 1764/** 1765 * Apply a visitor to each IR node in a list 1766 */ 1767void 1768visit_exec_list(exec_list *list, ir_visitor *visitor); 1769 1770/** 1771 * Validate invariants on each IR node in a list 1772 */ 1773void validate_ir_tree(exec_list *instructions); 1774 1775struct _mesa_glsl_parse_state; 1776struct gl_shader_program; 1777 1778/** 1779 * Detect whether an unlinked shader contains static recursion 1780 * 1781 * If the list of instructions is determined to contain static recursion, 1782 * \c _mesa_glsl_error will be called to emit error messages for each function 1783 * that is in the recursion cycle. 1784 */ 1785void 1786detect_recursion_unlinked(struct _mesa_glsl_parse_state *state, 1787 exec_list *instructions); 1788 1789/** 1790 * Detect whether a linked shader contains static recursion 1791 * 1792 * If the list of instructions is determined to contain static recursion, 1793 * \c link_error_printf will be called to emit error messages for each function 1794 * that is in the recursion cycle. In addition, 1795 * \c gl_shader_program::LinkStatus will be set to false. 1796 */ 1797void 1798detect_recursion_linked(struct gl_shader_program *prog, 1799 exec_list *instructions); 1800 1801/** 1802 * Make a clone of each IR instruction in a list 1803 * 1804 * \param in List of IR instructions that are to be cloned 1805 * \param out List to hold the cloned instructions 1806 */ 1807void 1808clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in); 1809 1810extern void 1811_mesa_glsl_initialize_variables(exec_list *instructions, 1812 struct _mesa_glsl_parse_state *state); 1813 1814extern void 1815_mesa_glsl_initialize_functions(_mesa_glsl_parse_state *state); 1816 1817extern void 1818_mesa_glsl_release_functions(void); 1819 1820extern void 1821reparent_ir(exec_list *list, void *mem_ctx); 1822 1823struct glsl_symbol_table; 1824 1825extern void 1826import_prototypes(const exec_list *source, exec_list *dest, 1827 struct glsl_symbol_table *symbols, void *mem_ctx); 1828 1829extern bool 1830ir_has_call(ir_instruction *ir); 1831 1832extern void 1833do_set_program_inouts(exec_list *instructions, struct gl_program *prog, 1834 bool is_fragment_shader); 1835 1836extern char * 1837prototype_string(const glsl_type *return_type, const char *name, 1838 exec_list *parameters); 1839 1840#endif /* IR_H */ 1841