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 #ifndef IR_H 26 #define IR_H 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 31 #include "util/ralloc.h" 32 #include "compiler/glsl_types.h" 33 #include "list.h" 34 #include "ir_visitor.h" 35 #include "ir_hierarchical_visitor.h" 36 #include "main/mtypes.h" 37 38 #ifdef __cplusplus 39 40 /** 41 * \defgroup IR Intermediate representation nodes 42 * 43 * @{ 44 */ 45 46 /** 47 * Class tags 48 * 49 * Each concrete class derived from \c ir_instruction has a value in this 50 * enumerant. The value for the type is stored in \c ir_instruction::ir_type 51 * by the constructor. While using type tags is not very C++, it is extremely 52 * convenient. For example, during debugging you can simply inspect 53 * \c ir_instruction::ir_type to find out the actual type of the object. 54 * 55 * In addition, it is possible to use a switch-statement based on \c 56 * \c ir_instruction::ir_type to select different behavior for different object 57 * types. For functions that have only slight differences for several object 58 * types, this allows writing very straightforward, readable code. 59 */ 60 enum ir_node_type { 61 ir_type_dereference_array, 62 ir_type_dereference_record, 63 ir_type_dereference_variable, 64 ir_type_constant, 65 ir_type_expression, 66 ir_type_swizzle, 67 ir_type_texture, 68 ir_type_variable, 69 ir_type_assignment, 70 ir_type_call, 71 ir_type_function, 72 ir_type_function_signature, 73 ir_type_if, 74 ir_type_loop, 75 ir_type_loop_jump, 76 ir_type_return, 77 ir_type_discard, 78 ir_type_emit_vertex, 79 ir_type_end_primitive, 80 ir_type_barrier, 81 ir_type_max, /**< maximum ir_type enum number, for validation */ 82 ir_type_unset = ir_type_max 83 }; 84 85 86 /** 87 * Base class of all IR instructions 88 */ 89 class ir_instruction : public exec_node { 90 public: 91 enum ir_node_type ir_type; 92 93 /** 94 * GCC 4.7+ and clang warn when deleting an ir_instruction unless 95 * there's a virtual destructor present. Because we almost 96 * universally use ralloc for our memory management of 97 * ir_instructions, the destructor doesn't need to do any work. 98 */ 99 virtual ~ir_instruction() 100 { 101 } 102 103 /** ir_print_visitor helper for debugging. */ 104 void print(void) const; 105 void fprint(FILE *f) const; 106 107 virtual void accept(ir_visitor *) = 0; 108 virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0; 109 virtual ir_instruction *clone(void *mem_ctx, 110 struct hash_table *ht) const = 0; 111 112 bool is_rvalue() const 113 { 114 return ir_type == ir_type_dereference_array || 115 ir_type == ir_type_dereference_record || 116 ir_type == ir_type_dereference_variable || 117 ir_type == ir_type_constant || 118 ir_type == ir_type_expression || 119 ir_type == ir_type_swizzle || 120 ir_type == ir_type_texture; 121 } 122 123 bool is_dereference() const 124 { 125 return ir_type == ir_type_dereference_array || 126 ir_type == ir_type_dereference_record || 127 ir_type == ir_type_dereference_variable; 128 } 129 130 bool is_jump() const 131 { 132 return ir_type == ir_type_loop_jump || 133 ir_type == ir_type_return || 134 ir_type == ir_type_discard; 135 } 136 137 /** 138 * \name IR instruction downcast functions 139 * 140 * These functions either cast the object to a derived class or return 141 * \c NULL if the object's type does not match the specified derived class. 142 * Additional downcast functions will be added as needed. 143 */ 144 /*@{*/ 145 #define AS_BASE(TYPE) \ 146 class ir_##TYPE *as_##TYPE() \ 147 { \ 148 assume(this != NULL); \ 149 return is_##TYPE() ? (ir_##TYPE *) this : NULL; \ 150 } \ 151 const class ir_##TYPE *as_##TYPE() const \ 152 { \ 153 assume(this != NULL); \ 154 return is_##TYPE() ? (ir_##TYPE *) this : NULL; \ 155 } 156 157 AS_BASE(rvalue) 158 AS_BASE(dereference) 159 AS_BASE(jump) 160 #undef AS_BASE 161 162 #define AS_CHILD(TYPE) \ 163 class ir_##TYPE * as_##TYPE() \ 164 { \ 165 assume(this != NULL); \ 166 return ir_type == ir_type_##TYPE ? (ir_##TYPE *) this : NULL; \ 167 } \ 168 const class ir_##TYPE * as_##TYPE() const \ 169 { \ 170 assume(this != NULL); \ 171 return ir_type == ir_type_##TYPE ? (const ir_##TYPE *) this : NULL; \ 172 } 173 AS_CHILD(variable) 174 AS_CHILD(function) 175 AS_CHILD(dereference_array) 176 AS_CHILD(dereference_variable) 177 AS_CHILD(dereference_record) 178 AS_CHILD(expression) 179 AS_CHILD(loop) 180 AS_CHILD(assignment) 181 AS_CHILD(call) 182 AS_CHILD(return) 183 AS_CHILD(if) 184 AS_CHILD(swizzle) 185 AS_CHILD(texture) 186 AS_CHILD(constant) 187 AS_CHILD(discard) 188 #undef AS_CHILD 189 /*@}*/ 190 191 /** 192 * IR equality method: Return true if the referenced instruction would 193 * return the same value as this one. 194 * 195 * This intended to be used for CSE and algebraic optimizations, on rvalues 196 * in particular. No support for other instruction types (assignments, 197 * jumps, calls, etc.) is planned. 198 */ 199 virtual bool equals(const ir_instruction *ir, 200 enum ir_node_type ignore = ir_type_unset) const; 201 202 protected: 203 ir_instruction(enum ir_node_type t) 204 : ir_type(t) 205 { 206 } 207 208 private: 209 ir_instruction() 210 { 211 assert(!"Should not get here."); 212 } 213 }; 214 215 216 /** 217 * The base class for all "values"/expression trees. 218 */ 219 class ir_rvalue : public ir_instruction { 220 public: 221 const struct glsl_type *type; 222 223 virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const; 224 225 virtual void accept(ir_visitor *v) 226 { 227 v->visit(this); 228 } 229 230 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 231 232 virtual ir_constant *constant_expression_value(void *mem_ctx, 233 struct hash_table *variable_context = NULL); 234 235 ir_rvalue *as_rvalue_to_saturate(); 236 237 virtual bool is_lvalue(const struct _mesa_glsl_parse_state *state = NULL) const 238 { 239 return false; 240 } 241 242 /** 243 * Get the variable that is ultimately referenced by an r-value 244 */ 245 virtual ir_variable *variable_referenced() const 246 { 247 return NULL; 248 } 249 250 251 /** 252 * If an r-value is a reference to a whole variable, get that variable 253 * 254 * \return 255 * Pointer to a variable that is completely dereferenced by the r-value. If 256 * the r-value is not a dereference or the dereference does not access the 257 * entire variable (i.e., it's just one array element, struct field), \c NULL 258 * is returned. 259 */ 260 virtual ir_variable *whole_variable_referenced() 261 { 262 return NULL; 263 } 264 265 /** 266 * Determine if an r-value has the value zero 267 * 268 * The base implementation of this function always returns \c false. The 269 * \c ir_constant class over-rides this function to return \c true \b only 270 * for vector and scalar types that have all elements set to the value 271 * zero (or \c false for booleans). 272 * 273 * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one 274 */ 275 virtual bool is_zero() const; 276 277 /** 278 * Determine if an r-value has the value one 279 * 280 * The base implementation of this function always returns \c false. The 281 * \c ir_constant class over-rides this function to return \c true \b only 282 * for vector and scalar types that have all elements set to the value 283 * one (or \c true for booleans). 284 * 285 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one 286 */ 287 virtual bool is_one() const; 288 289 /** 290 * Determine if an r-value has the value negative one 291 * 292 * The base implementation of this function always returns \c false. The 293 * \c ir_constant class over-rides this function to return \c true \b only 294 * for vector and scalar types that have all elements set to the value 295 * negative one. For boolean types, the result is always \c false. 296 * 297 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one 298 */ 299 virtual bool is_negative_one() const; 300 301 /** 302 * Determine if an r-value is an unsigned integer constant which can be 303 * stored in 16 bits. 304 * 305 * \sa ir_constant::is_uint16_constant. 306 */ 307 virtual bool is_uint16_constant() const { return false; } 308 309 /** 310 * Return a generic value of error_type. 311 * 312 * Allocation will be performed with 'mem_ctx' as ralloc owner. 313 */ 314 static ir_rvalue *error_value(void *mem_ctx); 315 316 protected: 317 ir_rvalue(enum ir_node_type t); 318 }; 319 320 321 /** 322 * Variable storage classes 323 */ 324 enum ir_variable_mode { 325 ir_var_auto = 0, /**< Function local variables and globals. */ 326 ir_var_uniform, /**< Variable declared as a uniform. */ 327 ir_var_shader_storage, /**< Variable declared as an ssbo. */ 328 ir_var_shader_shared, /**< Variable declared as shared. */ 329 ir_var_shader_in, 330 ir_var_shader_out, 331 ir_var_function_in, 332 ir_var_function_out, 333 ir_var_function_inout, 334 ir_var_const_in, /**< "in" param that must be a constant expression */ 335 ir_var_system_value, /**< Ex: front-face, instance-id, etc. */ 336 ir_var_temporary, /**< Temporary variable generated during compilation. */ 337 ir_var_mode_count /**< Number of variable modes */ 338 }; 339 340 /** 341 * Enum keeping track of how a variable was declared. For error checking of 342 * the gl_PerVertex redeclaration rules. 343 */ 344 enum ir_var_declaration_type { 345 /** 346 * Normal declaration (for most variables, this means an explicit 347 * declaration. Exception: temporaries are always implicitly declared, but 348 * they still use ir_var_declared_normally). 349 * 350 * Note: an ir_variable that represents a named interface block uses 351 * ir_var_declared_normally. 352 */ 353 ir_var_declared_normally = 0, 354 355 /** 356 * Variable was explicitly declared (or re-declared) in an unnamed 357 * interface block. 358 */ 359 ir_var_declared_in_block, 360 361 /** 362 * Variable is an implicitly declared built-in that has not been explicitly 363 * re-declared by the shader. 364 */ 365 ir_var_declared_implicitly, 366 367 /** 368 * Variable is implicitly generated by the compiler and should not be 369 * visible via the API. 370 */ 371 ir_var_hidden, 372 }; 373 374 /** 375 * \brief Layout qualifiers for gl_FragDepth. 376 * 377 * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared 378 * with a layout qualifier. 379 */ 380 enum ir_depth_layout { 381 ir_depth_layout_none, /**< No depth layout is specified. */ 382 ir_depth_layout_any, 383 ir_depth_layout_greater, 384 ir_depth_layout_less, 385 ir_depth_layout_unchanged 386 }; 387 388 /** 389 * \brief Convert depth layout qualifier to string. 390 */ 391 const char* 392 depth_layout_string(ir_depth_layout layout); 393 394 /** 395 * Description of built-in state associated with a uniform 396 * 397 * \sa ir_variable::state_slots 398 */ 399 struct ir_state_slot { 400 int tokens[5]; 401 int swizzle; 402 }; 403 404 405 /** 406 * Get the string value for an interpolation qualifier 407 * 408 * \return The string that would be used in a shader to specify \c 409 * mode will be returned. 410 * 411 * This function is used to generate error messages of the form "shader 412 * uses %s interpolation qualifier", so in the case where there is no 413 * interpolation qualifier, it returns "no". 414 * 415 * This function should only be used on a shader input or output variable. 416 */ 417 const char *interpolation_string(unsigned interpolation); 418 419 420 class ir_variable : public ir_instruction { 421 public: 422 ir_variable(const struct glsl_type *, const char *, ir_variable_mode); 423 424 virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const; 425 426 virtual void accept(ir_visitor *v) 427 { 428 v->visit(this); 429 } 430 431 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 432 433 434 /** 435 * Determine whether or not a variable is part of a uniform or 436 * shader storage block. 437 */ 438 inline bool is_in_buffer_block() const 439 { 440 return (this->data.mode == ir_var_uniform || 441 this->data.mode == ir_var_shader_storage) && 442 this->interface_type != NULL; 443 } 444 445 /** 446 * Determine whether or not a variable is part of a shader storage block. 447 */ 448 inline bool is_in_shader_storage_block() const 449 { 450 return this->data.mode == ir_var_shader_storage && 451 this->interface_type != NULL; 452 } 453 454 /** 455 * Determine whether or not a variable is the declaration of an interface 456 * block 457 * 458 * For the first declaration below, there will be an \c ir_variable named 459 * "instance" whose type and whose instance_type will be the same 460 * \c glsl_type. For the second declaration, there will be an \c ir_variable 461 * named "f" whose type is float and whose instance_type is B2. 462 * 463 * "instance" is an interface instance variable, but "f" is not. 464 * 465 * uniform B1 { 466 * float f; 467 * } instance; 468 * 469 * uniform B2 { 470 * float f; 471 * }; 472 */ 473 inline bool is_interface_instance() const 474 { 475 return this->type->without_array() == this->interface_type; 476 } 477 478 /** 479 * Return whether this variable contains a bindless sampler/image. 480 */ 481 inline bool contains_bindless() const 482 { 483 if (!this->type->contains_sampler() && !this->type->contains_image()) 484 return false; 485 486 return this->data.bindless || this->data.mode != ir_var_uniform; 487 } 488 489 /** 490 * Set this->interface_type on a newly created variable. 491 */ 492 void init_interface_type(const struct glsl_type *type) 493 { 494 assert(this->interface_type == NULL); 495 this->interface_type = type; 496 if (this->is_interface_instance()) { 497 this->u.max_ifc_array_access = 498 ralloc_array(this, int, type->length); 499 for (unsigned i = 0; i < type->length; i++) { 500 this->u.max_ifc_array_access[i] = -1; 501 } 502 } 503 } 504 505 /** 506 * Change this->interface_type on a variable that previously had a 507 * different, but compatible, interface_type. This is used during linking 508 * to set the size of arrays in interface blocks. 509 */ 510 void change_interface_type(const struct glsl_type *type) 511 { 512 if (this->u.max_ifc_array_access != NULL) { 513 /* max_ifc_array_access has already been allocated, so make sure the 514 * new interface has the same number of fields as the old one. 515 */ 516 assert(this->interface_type->length == type->length); 517 } 518 this->interface_type = type; 519 } 520 521 /** 522 * Change this->interface_type on a variable that previously had a 523 * different, and incompatible, interface_type. This is used during 524 * compilation to handle redeclaration of the built-in gl_PerVertex 525 * interface block. 526 */ 527 void reinit_interface_type(const struct glsl_type *type) 528 { 529 if (this->u.max_ifc_array_access != NULL) { 530 #ifndef NDEBUG 531 /* Redeclaring gl_PerVertex is only allowed if none of the built-ins 532 * it defines have been accessed yet; so it's safe to throw away the 533 * old max_ifc_array_access pointer, since all of its values are 534 * zero. 535 */ 536 for (unsigned i = 0; i < this->interface_type->length; i++) 537 assert(this->u.max_ifc_array_access[i] == -1); 538 #endif 539 ralloc_free(this->u.max_ifc_array_access); 540 this->u.max_ifc_array_access = NULL; 541 } 542 this->interface_type = NULL; 543 init_interface_type(type); 544 } 545 546 const glsl_type *get_interface_type() const 547 { 548 return this->interface_type; 549 } 550 551 enum glsl_interface_packing get_interface_type_packing() const 552 { 553 return this->interface_type->get_interface_packing(); 554 } 555 /** 556 * Get the max_ifc_array_access pointer 557 * 558 * A "set" function is not needed because the array is dynmically allocated 559 * as necessary. 560 */ 561 inline int *get_max_ifc_array_access() 562 { 563 assert(this->data._num_state_slots == 0); 564 return this->u.max_ifc_array_access; 565 } 566 567 inline unsigned get_num_state_slots() const 568 { 569 assert(!this->is_interface_instance() 570 || this->data._num_state_slots == 0); 571 return this->data._num_state_slots; 572 } 573 574 inline void set_num_state_slots(unsigned n) 575 { 576 assert(!this->is_interface_instance() 577 || n == 0); 578 this->data._num_state_slots = n; 579 } 580 581 inline ir_state_slot *get_state_slots() 582 { 583 return this->is_interface_instance() ? NULL : this->u.state_slots; 584 } 585 586 inline const ir_state_slot *get_state_slots() const 587 { 588 return this->is_interface_instance() ? NULL : this->u.state_slots; 589 } 590 591 inline ir_state_slot *allocate_state_slots(unsigned n) 592 { 593 assert(!this->is_interface_instance()); 594 595 this->u.state_slots = ralloc_array(this, ir_state_slot, n); 596 this->data._num_state_slots = 0; 597 598 if (this->u.state_slots != NULL) 599 this->data._num_state_slots = n; 600 601 return this->u.state_slots; 602 } 603 604 inline bool is_interpolation_flat() const 605 { 606 return this->data.interpolation == INTERP_MODE_FLAT || 607 this->type->contains_integer() || 608 this->type->contains_double(); 609 } 610 611 inline bool is_name_ralloced() const 612 { 613 return this->name != ir_variable::tmp_name && 614 this->name != this->name_storage; 615 } 616 617 /** 618 * Enable emitting extension warnings for this variable 619 */ 620 void enable_extension_warning(const char *extension); 621 622 /** 623 * Get the extension warning string for this variable 624 * 625 * If warnings are not enabled, \c NULL is returned. 626 */ 627 const char *get_extension_warning() const; 628 629 /** 630 * Declared type of the variable 631 */ 632 const struct glsl_type *type; 633 634 /** 635 * Declared name of the variable 636 */ 637 const char *name; 638 639 private: 640 /** 641 * If the name length fits into name_storage, it's used, otherwise 642 * the name is ralloc'd. shader-db mining showed that 70% of variables 643 * fit here. This is a win over ralloc where only ralloc_header has 644 * 20 bytes on 64-bit (28 bytes with DEBUG), and we can also skip malloc. 645 */ 646 char name_storage[16]; 647 648 public: 649 struct ir_variable_data { 650 651 /** 652 * Is the variable read-only? 653 * 654 * This is set for variables declared as \c const, shader inputs, 655 * and uniforms. 656 */ 657 unsigned read_only:1; 658 unsigned centroid:1; 659 unsigned sample:1; 660 unsigned patch:1; 661 unsigned invariant:1; 662 unsigned precise:1; 663 664 /** 665 * Has this variable been used for reading or writing? 666 * 667 * Several GLSL semantic checks require knowledge of whether or not a 668 * variable has been used. For example, it is an error to redeclare a 669 * variable as invariant after it has been used. 670 * 671 * This is only maintained in the ast_to_hir.cpp path, not in 672 * Mesa's fixed function or ARB program paths. 673 */ 674 unsigned used:1; 675 676 /** 677 * Has this variable been statically assigned? 678 * 679 * This answers whether the variable was assigned in any path of 680 * the shader during ast_to_hir. This doesn't answer whether it is 681 * still written after dead code removal, nor is it maintained in 682 * non-ast_to_hir.cpp (GLSL parsing) paths. 683 */ 684 unsigned assigned:1; 685 686 /** 687 * When separate shader programs are enabled, only input/outputs between 688 * the stages of a multi-stage separate program can be safely removed 689 * from the shader interface. Other input/outputs must remains active. 690 */ 691 unsigned always_active_io:1; 692 693 /** 694 * Enum indicating how the variable was declared. See 695 * ir_var_declaration_type. 696 * 697 * This is used to detect certain kinds of illegal variable redeclarations. 698 */ 699 unsigned how_declared:2; 700 701 /** 702 * Storage class of the variable. 703 * 704 * \sa ir_variable_mode 705 */ 706 unsigned mode:4; 707 708 /** 709 * Interpolation mode for shader inputs / outputs 710 * 711 * \sa glsl_interp_mode 712 */ 713 unsigned interpolation:2; 714 715 /** 716 * \name ARB_fragment_coord_conventions 717 * @{ 718 */ 719 unsigned origin_upper_left:1; 720 unsigned pixel_center_integer:1; 721 /*@}*/ 722 723 /** 724 * Was the location explicitly set in the shader? 725 * 726 * If the location is explicitly set in the shader, it \b cannot be changed 727 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have 728 * no effect). 729 */ 730 unsigned explicit_location:1; 731 unsigned explicit_index:1; 732 733 /** 734 * Was an initial binding explicitly set in the shader? 735 * 736 * If so, constant_value contains an integer ir_constant representing the 737 * initial binding point. 738 */ 739 unsigned explicit_binding:1; 740 741 /** 742 * Was an initial component explicitly set in the shader? 743 */ 744 unsigned explicit_component:1; 745 746 /** 747 * Does this variable have an initializer? 748 * 749 * This is used by the linker to cross-validiate initializers of global 750 * variables. 751 */ 752 unsigned has_initializer:1; 753 754 /** 755 * Is this variable a generic output or input that has not yet been matched 756 * up to a variable in another stage of the pipeline? 757 * 758 * This is used by the linker as scratch storage while assigning locations 759 * to generic inputs and outputs. 760 */ 761 unsigned is_unmatched_generic_inout:1; 762 763 /** 764 * Is this varying used only by transform feedback? 765 * 766 * This is used by the linker to decide if its safe to pack the varying. 767 */ 768 unsigned is_xfb_only:1; 769 770 /** 771 * Was a transfor feedback buffer set in the shader? 772 */ 773 unsigned explicit_xfb_buffer:1; 774 775 /** 776 * Was a transfor feedback offset set in the shader? 777 */ 778 unsigned explicit_xfb_offset:1; 779 780 /** 781 * Was a transfor feedback stride set in the shader? 782 */ 783 unsigned explicit_xfb_stride:1; 784 785 /** 786 * If non-zero, then this variable may be packed along with other variables 787 * into a single varying slot, so this offset should be applied when 788 * accessing components. For example, an offset of 1 means that the x 789 * component of this variable is actually stored in component y of the 790 * location specified by \c location. 791 */ 792 unsigned location_frac:2; 793 794 /** 795 * Layout of the matrix. Uses glsl_matrix_layout values. 796 */ 797 unsigned matrix_layout:2; 798 799 /** 800 * Non-zero if this variable was created by lowering a named interface 801 * block. 802 */ 803 unsigned from_named_ifc_block:1; 804 805 /** 806 * Non-zero if the variable must be a shader input. This is useful for 807 * constraints on function parameters. 808 */ 809 unsigned must_be_shader_input:1; 810 811 /** 812 * Output index for dual source blending. 813 * 814 * \note 815 * The GLSL spec only allows the values 0 or 1 for the index in \b dual 816 * source blending. 817 */ 818 unsigned index:1; 819 820 /** 821 * Precision qualifier. 822 * 823 * In desktop GLSL we do not care about precision qualifiers at all, in 824 * fact, the spec says that precision qualifiers are ignored. 825 * 826 * To make things easy, we make it so that this field is always 827 * GLSL_PRECISION_NONE on desktop shaders. This way all the variables 828 * have the same precision value and the checks we add in the compiler 829 * for this field will never break a desktop shader compile. 830 */ 831 unsigned precision:2; 832 833 /** 834 * \brief Layout qualifier for gl_FragDepth. 835 * 836 * This is not equal to \c ir_depth_layout_none if and only if this 837 * variable is \c gl_FragDepth and a layout qualifier is specified. 838 */ 839 ir_depth_layout depth_layout:3; 840 841 /** 842 * Memory qualifiers. 843 */ 844 unsigned memory_read_only:1; /**< "readonly" qualifier. */ 845 unsigned memory_write_only:1; /**< "writeonly" qualifier. */ 846 unsigned memory_coherent:1; 847 unsigned memory_volatile:1; 848 unsigned memory_restrict:1; 849 850 /** 851 * ARB_shader_storage_buffer_object 852 */ 853 unsigned from_ssbo_unsized_array:1; /**< unsized array buffer variable. */ 854 855 unsigned implicit_sized_array:1; 856 857 /** 858 * Whether this is a fragment shader output implicitly initialized with 859 * the previous contents of the specified render target at the 860 * framebuffer location corresponding to this shader invocation. 861 */ 862 unsigned fb_fetch_output:1; 863 864 /** 865 * Non-zero if this variable is considered bindless as defined by 866 * ARB_bindless_texture. 867 */ 868 unsigned bindless:1; 869 870 /** 871 * Non-zero if this variable is considered bound as defined by 872 * ARB_bindless_texture. 873 */ 874 unsigned bound:1; 875 876 /** 877 * Emit a warning if this variable is accessed. 878 */ 879 private: 880 uint8_t warn_extension_index; 881 882 public: 883 /** Image internal format if specified explicitly, otherwise GL_NONE. */ 884 uint16_t image_format; 885 886 private: 887 /** 888 * Number of state slots used 889 * 890 * \note 891 * This could be stored in as few as 7-bits, if necessary. If it is made 892 * smaller, add an assertion to \c ir_variable::allocate_state_slots to 893 * be safe. 894 */ 895 uint16_t _num_state_slots; 896 897 public: 898 /** 899 * Initial binding point for a sampler, atomic, or UBO. 900 * 901 * For array types, this represents the binding point for the first element. 902 */ 903 int16_t binding; 904 905 /** 906 * Storage location of the base of this variable 907 * 908 * The precise meaning of this field depends on the nature of the variable. 909 * 910 * - Vertex shader input: one of the values from \c gl_vert_attrib. 911 * - Vertex shader output: one of the values from \c gl_varying_slot. 912 * - Geometry shader input: one of the values from \c gl_varying_slot. 913 * - Geometry shader output: one of the values from \c gl_varying_slot. 914 * - Fragment shader input: one of the values from \c gl_varying_slot. 915 * - Fragment shader output: one of the values from \c gl_frag_result. 916 * - Uniforms: Per-stage uniform slot number for default uniform block. 917 * - Uniforms: Index within the uniform block definition for UBO members. 918 * - Non-UBO Uniforms: explicit location until linking then reused to 919 * store uniform slot number. 920 * - Other: This field is not currently used. 921 * 922 * If the variable is a uniform, shader input, or shader output, and the 923 * slot has not been assigned, the value will be -1. 924 */ 925 int location; 926 927 /** 928 * for glsl->tgsi/mesa IR we need to store the index into the 929 * parameters for uniforms, initially the code overloaded location 930 * but this causes problems with indirect samplers and AoA. 931 * This is assigned in _mesa_generate_parameters_list_for_uniforms. 932 */ 933 int param_index; 934 935 /** 936 * Vertex stream output identifier. 937 * 938 * For packed outputs, bit 31 is set and bits [2*i+1,2*i] indicate the 939 * stream of the i-th component. 940 */ 941 unsigned stream; 942 943 /** 944 * Atomic, transform feedback or block member offset. 945 */ 946 unsigned offset; 947 948 /** 949 * Highest element accessed with a constant expression array index 950 * 951 * Not used for non-array variables. -1 is never accessed. 952 */ 953 int max_array_access; 954 955 /** 956 * Transform feedback buffer. 957 */ 958 unsigned xfb_buffer; 959 960 /** 961 * Transform feedback stride. 962 */ 963 unsigned xfb_stride; 964 965 /** 966 * Allow (only) ir_variable direct access private members. 967 */ 968 friend class ir_variable; 969 } data; 970 971 /** 972 * Value assigned in the initializer of a variable declared "const" 973 */ 974 ir_constant *constant_value; 975 976 /** 977 * Constant expression assigned in the initializer of the variable 978 * 979 * \warning 980 * This field and \c ::constant_value are distinct. Even if the two fields 981 * refer to constants with the same value, they must point to separate 982 * objects. 983 */ 984 ir_constant *constant_initializer; 985 986 private: 987 static const char *const warn_extension_table[]; 988 989 union { 990 /** 991 * For variables which satisfy the is_interface_instance() predicate, 992 * this points to an array of integers such that if the ith member of 993 * the interface block is an array, max_ifc_array_access[i] is the 994 * maximum array element of that member that has been accessed. If the 995 * ith member of the interface block is not an array, 996 * max_ifc_array_access[i] is unused. 997 * 998 * For variables whose type is not an interface block, this pointer is 999 * NULL. 1000 */ 1001 int *max_ifc_array_access; 1002 1003 /** 1004 * Built-in state that backs this uniform 1005 * 1006 * Once set at variable creation, \c state_slots must remain invariant. 1007 * 1008 * If the variable is not a uniform, \c _num_state_slots will be zero 1009 * and \c state_slots will be \c NULL. 1010 */ 1011 ir_state_slot *state_slots; 1012 } u; 1013 1014 /** 1015 * For variables that are in an interface block or are an instance of an 1016 * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block. 1017 * 1018 * \sa ir_variable::location 1019 */ 1020 const glsl_type *interface_type; 1021 1022 /** 1023 * Name used for anonymous compiler temporaries 1024 */ 1025 static const char tmp_name[]; 1026 1027 public: 1028 /** 1029 * Should the construct keep names for ir_var_temporary variables? 1030 * 1031 * When this global is false, names passed to the constructor for 1032 * \c ir_var_temporary variables will be dropped. Instead, the variable will 1033 * be named "compiler_temp". This name will be in static storage. 1034 * 1035 * \warning 1036 * \b NEVER change the mode of an \c ir_var_temporary. 1037 * 1038 * \warning 1039 * This variable is \b not thread-safe. It is global, \b not 1040 * per-context. It begins life false. A context can, at some point, make 1041 * it true. From that point on, it will be true forever. This should be 1042 * okay since it will only be set true while debugging. 1043 */ 1044 static bool temporaries_allocate_names; 1045 }; 1046 1047 /** 1048 * A function that returns whether a built-in function is available in the 1049 * current shading language (based on version, ES or desktop, and extensions). 1050 */ 1051 typedef bool (*builtin_available_predicate)(const _mesa_glsl_parse_state *); 1052 1053 #define MAKE_INTRINSIC_FOR_TYPE(op, t) \ 1054 ir_intrinsic_generic_ ## op - ir_intrinsic_generic_load + ir_intrinsic_ ## t ## _ ## load 1055 1056 #define MAP_INTRINSIC_TO_TYPE(i, t) \ 1057 ir_intrinsic_id(int(i) - int(ir_intrinsic_generic_load) + int(ir_intrinsic_ ## t ## _ ## load)) 1058 1059 enum ir_intrinsic_id { 1060 ir_intrinsic_invalid = 0, 1061 1062 /** 1063 * \name Generic intrinsics 1064 * 1065 * Each of these intrinsics has a specific version for shared variables and 1066 * SSBOs. 1067 */ 1068 /*@{*/ 1069 ir_intrinsic_generic_load, 1070 ir_intrinsic_generic_store, 1071 ir_intrinsic_generic_atomic_add, 1072 ir_intrinsic_generic_atomic_and, 1073 ir_intrinsic_generic_atomic_or, 1074 ir_intrinsic_generic_atomic_xor, 1075 ir_intrinsic_generic_atomic_min, 1076 ir_intrinsic_generic_atomic_max, 1077 ir_intrinsic_generic_atomic_exchange, 1078 ir_intrinsic_generic_atomic_comp_swap, 1079 /*@}*/ 1080 1081 ir_intrinsic_atomic_counter_read, 1082 ir_intrinsic_atomic_counter_increment, 1083 ir_intrinsic_atomic_counter_predecrement, 1084 ir_intrinsic_atomic_counter_add, 1085 ir_intrinsic_atomic_counter_and, 1086 ir_intrinsic_atomic_counter_or, 1087 ir_intrinsic_atomic_counter_xor, 1088 ir_intrinsic_atomic_counter_min, 1089 ir_intrinsic_atomic_counter_max, 1090 ir_intrinsic_atomic_counter_exchange, 1091 ir_intrinsic_atomic_counter_comp_swap, 1092 1093 ir_intrinsic_image_load, 1094 ir_intrinsic_image_store, 1095 ir_intrinsic_image_atomic_add, 1096 ir_intrinsic_image_atomic_and, 1097 ir_intrinsic_image_atomic_or, 1098 ir_intrinsic_image_atomic_xor, 1099 ir_intrinsic_image_atomic_min, 1100 ir_intrinsic_image_atomic_max, 1101 ir_intrinsic_image_atomic_exchange, 1102 ir_intrinsic_image_atomic_comp_swap, 1103 ir_intrinsic_image_size, 1104 ir_intrinsic_image_samples, 1105 1106 ir_intrinsic_ssbo_load, 1107 ir_intrinsic_ssbo_store = MAKE_INTRINSIC_FOR_TYPE(store, ssbo), 1108 ir_intrinsic_ssbo_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, ssbo), 1109 ir_intrinsic_ssbo_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, ssbo), 1110 ir_intrinsic_ssbo_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, ssbo), 1111 ir_intrinsic_ssbo_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, ssbo), 1112 ir_intrinsic_ssbo_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, ssbo), 1113 ir_intrinsic_ssbo_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, ssbo), 1114 ir_intrinsic_ssbo_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, ssbo), 1115 ir_intrinsic_ssbo_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, ssbo), 1116 1117 ir_intrinsic_memory_barrier, 1118 ir_intrinsic_shader_clock, 1119 ir_intrinsic_group_memory_barrier, 1120 ir_intrinsic_memory_barrier_atomic_counter, 1121 ir_intrinsic_memory_barrier_buffer, 1122 ir_intrinsic_memory_barrier_image, 1123 ir_intrinsic_memory_barrier_shared, 1124 1125 ir_intrinsic_vote_all, 1126 ir_intrinsic_vote_any, 1127 ir_intrinsic_vote_eq, 1128 ir_intrinsic_ballot, 1129 ir_intrinsic_read_invocation, 1130 ir_intrinsic_read_first_invocation, 1131 1132 ir_intrinsic_shared_load, 1133 ir_intrinsic_shared_store = MAKE_INTRINSIC_FOR_TYPE(store, shared), 1134 ir_intrinsic_shared_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, shared), 1135 ir_intrinsic_shared_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, shared), 1136 ir_intrinsic_shared_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, shared), 1137 ir_intrinsic_shared_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, shared), 1138 ir_intrinsic_shared_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, shared), 1139 ir_intrinsic_shared_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, shared), 1140 ir_intrinsic_shared_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, shared), 1141 ir_intrinsic_shared_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, shared), 1142 }; 1143 1144 /*@{*/ 1145 /** 1146 * The representation of a function instance; may be the full definition or 1147 * simply a prototype. 1148 */ 1149 class ir_function_signature : public ir_instruction { 1150 /* An ir_function_signature will be part of the list of signatures in 1151 * an ir_function. 1152 */ 1153 public: 1154 ir_function_signature(const glsl_type *return_type, 1155 builtin_available_predicate builtin_avail = NULL); 1156 1157 virtual ir_function_signature *clone(void *mem_ctx, 1158 struct hash_table *ht) const; 1159 ir_function_signature *clone_prototype(void *mem_ctx, 1160 struct hash_table *ht) const; 1161 1162 virtual void accept(ir_visitor *v) 1163 { 1164 v->visit(this); 1165 } 1166 1167 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1168 1169 /** 1170 * Attempt to evaluate this function as a constant expression, 1171 * given a list of the actual parameters and the variable context. 1172 * Returns NULL for non-built-ins. 1173 */ 1174 ir_constant *constant_expression_value(void *mem_ctx, 1175 exec_list *actual_parameters, 1176 struct hash_table *variable_context); 1177 1178 /** 1179 * Get the name of the function for which this is a signature 1180 */ 1181 const char *function_name() const; 1182 1183 /** 1184 * Get a handle to the function for which this is a signature 1185 * 1186 * There is no setter function, this function returns a \c const pointer, 1187 * and \c ir_function_signature::_function is private for a reason. The 1188 * only way to make a connection between a function and function signature 1189 * is via \c ir_function::add_signature. This helps ensure that certain 1190 * invariants (i.e., a function signature is in the list of signatures for 1191 * its \c _function) are met. 1192 * 1193 * \sa ir_function::add_signature 1194 */ 1195 inline const class ir_function *function() const 1196 { 1197 return this->_function; 1198 } 1199 1200 /** 1201 * Check whether the qualifiers match between this signature's parameters 1202 * and the supplied parameter list. If not, returns the name of the first 1203 * parameter with mismatched qualifiers (for use in error messages). 1204 */ 1205 const char *qualifiers_match(exec_list *params); 1206 1207 /** 1208 * Replace the current parameter list with the given one. This is useful 1209 * if the current information came from a prototype, and either has invalid 1210 * or missing parameter names. 1211 */ 1212 void replace_parameters(exec_list *new_params); 1213 1214 /** 1215 * Function return type. 1216 * 1217 * \note This discards the optional precision qualifier. 1218 */ 1219 const struct glsl_type *return_type; 1220 1221 /** 1222 * List of ir_variable of function parameters. 1223 * 1224 * This represents the storage. The paramaters passed in a particular 1225 * call will be in ir_call::actual_paramaters. 1226 */ 1227 struct exec_list parameters; 1228 1229 /** Whether or not this function has a body (which may be empty). */ 1230 unsigned is_defined:1; 1231 1232 /** Whether or not this function signature is a built-in. */ 1233 bool is_builtin() const; 1234 1235 /** 1236 * Whether or not this function is an intrinsic to be implemented 1237 * by the driver. 1238 */ 1239 inline bool is_intrinsic() const 1240 { 1241 return intrinsic_id != ir_intrinsic_invalid; 1242 } 1243 1244 /** Indentifier for this intrinsic. */ 1245 enum ir_intrinsic_id intrinsic_id; 1246 1247 /** Whether or not a built-in is available for this shader. */ 1248 bool is_builtin_available(const _mesa_glsl_parse_state *state) const; 1249 1250 /** Body of instructions in the function. */ 1251 struct exec_list body; 1252 1253 private: 1254 /** 1255 * A function pointer to a predicate that answers whether a built-in 1256 * function is available in the current shader. NULL if not a built-in. 1257 */ 1258 builtin_available_predicate builtin_avail; 1259 1260 /** Function of which this signature is one overload. */ 1261 class ir_function *_function; 1262 1263 /** Function signature of which this one is a prototype clone */ 1264 const ir_function_signature *origin; 1265 1266 friend class ir_function; 1267 1268 /** 1269 * Helper function to run a list of instructions for constant 1270 * expression evaluation. 1271 * 1272 * The hash table represents the values of the visible variables. 1273 * There are no scoping issues because the table is indexed on 1274 * ir_variable pointers, not variable names. 1275 * 1276 * Returns false if the expression is not constant, true otherwise, 1277 * and the value in *result if result is non-NULL. 1278 */ 1279 bool constant_expression_evaluate_expression_list(void *mem_ctx, 1280 const struct exec_list &body, 1281 struct hash_table *variable_context, 1282 ir_constant **result); 1283 }; 1284 1285 1286 /** 1287 * Header for tracking multiple overloaded functions with the same name. 1288 * Contains a list of ir_function_signatures representing each of the 1289 * actual functions. 1290 */ 1291 class ir_function : public ir_instruction { 1292 public: 1293 ir_function(const char *name); 1294 1295 virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const; 1296 1297 virtual void accept(ir_visitor *v) 1298 { 1299 v->visit(this); 1300 } 1301 1302 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1303 1304 void add_signature(ir_function_signature *sig) 1305 { 1306 sig->_function = this; 1307 this->signatures.push_tail(sig); 1308 } 1309 1310 /** 1311 * Find a signature that matches a set of actual parameters, taking implicit 1312 * conversions into account. Also flags whether the match was exact. 1313 */ 1314 ir_function_signature *matching_signature(_mesa_glsl_parse_state *state, 1315 const exec_list *actual_param, 1316 bool allow_builtins, 1317 bool *match_is_exact); 1318 1319 /** 1320 * Find a signature that matches a set of actual parameters, taking implicit 1321 * conversions into account. 1322 */ 1323 ir_function_signature *matching_signature(_mesa_glsl_parse_state *state, 1324 const exec_list *actual_param, 1325 bool allow_builtins); 1326 1327 /** 1328 * Find a signature that exactly matches a set of actual parameters without 1329 * any implicit type conversions. 1330 */ 1331 ir_function_signature *exact_matching_signature(_mesa_glsl_parse_state *state, 1332 const exec_list *actual_ps); 1333 1334 /** 1335 * Name of the function. 1336 */ 1337 const char *name; 1338 1339 /** Whether or not this function has a signature that isn't a built-in. */ 1340 bool has_user_signature(); 1341 1342 /** 1343 * List of ir_function_signature for each overloaded function with this name. 1344 */ 1345 struct exec_list signatures; 1346 1347 /** 1348 * is this function a subroutine type declaration 1349 * e.g. subroutine void type1(float arg1); 1350 */ 1351 bool is_subroutine; 1352 1353 /** 1354 * is this function associated to a subroutine type 1355 * e.g. subroutine (type1, type2) function_name { function_body }; 1356 * would have num_subroutine_types 2, 1357 * and pointers to the type1 and type2 types. 1358 */ 1359 int num_subroutine_types; 1360 const struct glsl_type **subroutine_types; 1361 1362 int subroutine_index; 1363 }; 1364 1365 inline const char *ir_function_signature::function_name() const 1366 { 1367 return this->_function->name; 1368 } 1369 /*@}*/ 1370 1371 1372 /** 1373 * IR instruction representing high-level if-statements 1374 */ 1375 class ir_if : public ir_instruction { 1376 public: 1377 ir_if(ir_rvalue *condition) 1378 : ir_instruction(ir_type_if), condition(condition) 1379 { 1380 } 1381 1382 virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const; 1383 1384 virtual void accept(ir_visitor *v) 1385 { 1386 v->visit(this); 1387 } 1388 1389 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1390 1391 ir_rvalue *condition; 1392 /** List of ir_instruction for the body of the then branch */ 1393 exec_list then_instructions; 1394 /** List of ir_instruction for the body of the else branch */ 1395 exec_list else_instructions; 1396 }; 1397 1398 1399 /** 1400 * IR instruction representing a high-level loop structure. 1401 */ 1402 class ir_loop : public ir_instruction { 1403 public: 1404 ir_loop(); 1405 1406 virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const; 1407 1408 virtual void accept(ir_visitor *v) 1409 { 1410 v->visit(this); 1411 } 1412 1413 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1414 1415 /** List of ir_instruction that make up the body of the loop. */ 1416 exec_list body_instructions; 1417 }; 1418 1419 1420 class ir_assignment : public ir_instruction { 1421 public: 1422 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL); 1423 1424 /** 1425 * Construct an assignment with an explicit write mask 1426 * 1427 * \note 1428 * Since a write mask is supplied, the LHS must already be a bare 1429 * \c ir_dereference. The cannot be any swizzles in the LHS. 1430 */ 1431 ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition, 1432 unsigned write_mask); 1433 1434 virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const; 1435 1436 virtual ir_constant *constant_expression_value(void *mem_ctx, 1437 struct hash_table *variable_context = NULL); 1438 1439 virtual void accept(ir_visitor *v) 1440 { 1441 v->visit(this); 1442 } 1443 1444 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1445 1446 /** 1447 * Get a whole variable written by an assignment 1448 * 1449 * If the LHS of the assignment writes a whole variable, the variable is 1450 * returned. Otherwise \c NULL is returned. Examples of whole-variable 1451 * assignment are: 1452 * 1453 * - Assigning to a scalar 1454 * - Assigning to all components of a vector 1455 * - Whole array (or matrix) assignment 1456 * - Whole structure assignment 1457 */ 1458 ir_variable *whole_variable_written(); 1459 1460 /** 1461 * Set the LHS of an assignment 1462 */ 1463 void set_lhs(ir_rvalue *lhs); 1464 1465 /** 1466 * Left-hand side of the assignment. 1467 * 1468 * This should be treated as read only. If you need to set the LHS of an 1469 * assignment, use \c ir_assignment::set_lhs. 1470 */ 1471 ir_dereference *lhs; 1472 1473 /** 1474 * Value being assigned 1475 */ 1476 ir_rvalue *rhs; 1477 1478 /** 1479 * Optional condition for the assignment. 1480 */ 1481 ir_rvalue *condition; 1482 1483 1484 /** 1485 * Component mask written 1486 * 1487 * For non-vector types in the LHS, this field will be zero. For vector 1488 * types, a bit will be set for each component that is written. Note that 1489 * for \c vec2 and \c vec3 types only the lower bits will ever be set. 1490 * 1491 * A partially-set write mask means that each enabled channel gets 1492 * the value from a consecutive channel of the rhs. For example, 1493 * to write just .xyw of gl_FrontColor with color: 1494 * 1495 * (assign (constant bool (1)) (xyw) 1496 * (var_ref gl_FragColor) 1497 * (swiz xyw (var_ref color))) 1498 */ 1499 unsigned write_mask:4; 1500 }; 1501 1502 #include "ir_expression_operation.h" 1503 1504 extern const char *const ir_expression_operation_strings[ir_last_opcode + 1]; 1505 extern const char *const ir_expression_operation_enum_strings[ir_last_opcode + 1]; 1506 1507 class ir_expression : public ir_rvalue { 1508 public: 1509 ir_expression(int op, const struct glsl_type *type, 1510 ir_rvalue *op0, ir_rvalue *op1 = NULL, 1511 ir_rvalue *op2 = NULL, ir_rvalue *op3 = NULL); 1512 1513 /** 1514 * Constructor for unary operation expressions 1515 */ 1516 ir_expression(int op, ir_rvalue *); 1517 1518 /** 1519 * Constructor for binary operation expressions 1520 */ 1521 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1); 1522 1523 /** 1524 * Constructor for ternary operation expressions 1525 */ 1526 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2); 1527 1528 virtual bool equals(const ir_instruction *ir, 1529 enum ir_node_type ignore = ir_type_unset) const; 1530 1531 virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const; 1532 1533 /** 1534 * Attempt to constant-fold the expression 1535 * 1536 * The "variable_context" hash table links ir_variable * to ir_constant * 1537 * that represent the variables' values. \c NULL represents an empty 1538 * context. 1539 * 1540 * If the expression cannot be constant folded, this method will return 1541 * \c NULL. 1542 */ 1543 virtual ir_constant *constant_expression_value(void *mem_ctx, 1544 struct hash_table *variable_context = NULL); 1545 1546 /** 1547 * This is only here for ir_reader to used for testing purposes please use 1548 * the precomputed num_operands field if you need the number of operands. 1549 */ 1550 static unsigned get_num_operands(ir_expression_operation); 1551 1552 /** 1553 * Return whether the expression operates on vectors horizontally. 1554 */ 1555 bool is_horizontal() const 1556 { 1557 return operation == ir_binop_all_equal || 1558 operation == ir_binop_any_nequal || 1559 operation == ir_binop_dot || 1560 operation == ir_binop_vector_extract || 1561 operation == ir_triop_vector_insert || 1562 operation == ir_binop_ubo_load || 1563 operation == ir_quadop_vector; 1564 } 1565 1566 /** 1567 * Do a reverse-lookup to translate the given string into an operator. 1568 */ 1569 static ir_expression_operation get_operator(const char *); 1570 1571 virtual void accept(ir_visitor *v) 1572 { 1573 v->visit(this); 1574 } 1575 1576 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1577 1578 virtual ir_variable *variable_referenced() const; 1579 1580 /** 1581 * Determine the number of operands used by an expression 1582 */ 1583 void init_num_operands() 1584 { 1585 if (operation == ir_quadop_vector) { 1586 num_operands = this->type->vector_elements; 1587 } else { 1588 num_operands = get_num_operands(operation); 1589 } 1590 } 1591 1592 ir_expression_operation operation; 1593 ir_rvalue *operands[4]; 1594 uint8_t num_operands; 1595 }; 1596 1597 1598 /** 1599 * HIR instruction representing a high-level function call, containing a list 1600 * of parameters and returning a value in the supplied temporary. 1601 */ 1602 class ir_call : public ir_instruction { 1603 public: 1604 ir_call(ir_function_signature *callee, 1605 ir_dereference_variable *return_deref, 1606 exec_list *actual_parameters) 1607 : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(NULL), array_idx(NULL) 1608 { 1609 assert(callee->return_type != NULL); 1610 actual_parameters->move_nodes_to(& this->actual_parameters); 1611 } 1612 1613 ir_call(ir_function_signature *callee, 1614 ir_dereference_variable *return_deref, 1615 exec_list *actual_parameters, 1616 ir_variable *var, ir_rvalue *array_idx) 1617 : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(var), array_idx(array_idx) 1618 { 1619 assert(callee->return_type != NULL); 1620 actual_parameters->move_nodes_to(& this->actual_parameters); 1621 } 1622 1623 virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const; 1624 1625 virtual ir_constant *constant_expression_value(void *mem_ctx, 1626 struct hash_table *variable_context = NULL); 1627 1628 virtual void accept(ir_visitor *v) 1629 { 1630 v->visit(this); 1631 } 1632 1633 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1634 1635 /** 1636 * Get the name of the function being called. 1637 */ 1638 const char *callee_name() const 1639 { 1640 return callee->function_name(); 1641 } 1642 1643 /** 1644 * Generates an inline version of the function before @ir, 1645 * storing the return value in return_deref. 1646 */ 1647 void generate_inline(ir_instruction *ir); 1648 1649 /** 1650 * Storage for the function's return value. 1651 * This must be NULL if the return type is void. 1652 */ 1653 ir_dereference_variable *return_deref; 1654 1655 /** 1656 * The specific function signature being called. 1657 */ 1658 ir_function_signature *callee; 1659 1660 /* List of ir_rvalue of paramaters passed in this call. */ 1661 exec_list actual_parameters; 1662 1663 /* 1664 * ARB_shader_subroutine support - 1665 * the subroutine uniform variable and array index 1666 * rvalue to be used in the lowering pass later. 1667 */ 1668 ir_variable *sub_var; 1669 ir_rvalue *array_idx; 1670 }; 1671 1672 1673 /** 1674 * \name Jump-like IR instructions. 1675 * 1676 * These include \c break, \c continue, \c return, and \c discard. 1677 */ 1678 /*@{*/ 1679 class ir_jump : public ir_instruction { 1680 protected: 1681 ir_jump(enum ir_node_type t) 1682 : ir_instruction(t) 1683 { 1684 } 1685 }; 1686 1687 class ir_return : public ir_jump { 1688 public: 1689 ir_return() 1690 : ir_jump(ir_type_return), value(NULL) 1691 { 1692 } 1693 1694 ir_return(ir_rvalue *value) 1695 : ir_jump(ir_type_return), value(value) 1696 { 1697 } 1698 1699 virtual ir_return *clone(void *mem_ctx, struct hash_table *) const; 1700 1701 ir_rvalue *get_value() const 1702 { 1703 return value; 1704 } 1705 1706 virtual void accept(ir_visitor *v) 1707 { 1708 v->visit(this); 1709 } 1710 1711 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1712 1713 ir_rvalue *value; 1714 }; 1715 1716 1717 /** 1718 * Jump instructions used inside loops 1719 * 1720 * These include \c break and \c continue. The \c break within a loop is 1721 * different from the \c break within a switch-statement. 1722 * 1723 * \sa ir_switch_jump 1724 */ 1725 class ir_loop_jump : public ir_jump { 1726 public: 1727 enum jump_mode { 1728 jump_break, 1729 jump_continue 1730 }; 1731 1732 ir_loop_jump(jump_mode mode) 1733 : ir_jump(ir_type_loop_jump) 1734 { 1735 this->mode = mode; 1736 } 1737 1738 virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const; 1739 1740 virtual void accept(ir_visitor *v) 1741 { 1742 v->visit(this); 1743 } 1744 1745 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1746 1747 bool is_break() const 1748 { 1749 return mode == jump_break; 1750 } 1751 1752 bool is_continue() const 1753 { 1754 return mode == jump_continue; 1755 } 1756 1757 /** Mode selector for the jump instruction. */ 1758 enum jump_mode mode; 1759 }; 1760 1761 /** 1762 * IR instruction representing discard statements. 1763 */ 1764 class ir_discard : public ir_jump { 1765 public: 1766 ir_discard() 1767 : ir_jump(ir_type_discard) 1768 { 1769 this->condition = NULL; 1770 } 1771 1772 ir_discard(ir_rvalue *cond) 1773 : ir_jump(ir_type_discard) 1774 { 1775 this->condition = cond; 1776 } 1777 1778 virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const; 1779 1780 virtual void accept(ir_visitor *v) 1781 { 1782 v->visit(this); 1783 } 1784 1785 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1786 1787 ir_rvalue *condition; 1788 }; 1789 /*@}*/ 1790 1791 1792 /** 1793 * Texture sampling opcodes used in ir_texture 1794 */ 1795 enum ir_texture_opcode { 1796 ir_tex, /**< Regular texture look-up */ 1797 ir_txb, /**< Texture look-up with LOD bias */ 1798 ir_txl, /**< Texture look-up with explicit LOD */ 1799 ir_txd, /**< Texture look-up with partial derivatvies */ 1800 ir_txf, /**< Texel fetch with explicit LOD */ 1801 ir_txf_ms, /**< Multisample texture fetch */ 1802 ir_txs, /**< Texture size */ 1803 ir_lod, /**< Texture lod query */ 1804 ir_tg4, /**< Texture gather */ 1805 ir_query_levels, /**< Texture levels query */ 1806 ir_texture_samples, /**< Texture samples query */ 1807 ir_samples_identical, /**< Query whether all samples are definitely identical. */ 1808 }; 1809 1810 1811 /** 1812 * IR instruction to sample a texture 1813 * 1814 * The specific form of the IR instruction depends on the \c mode value 1815 * selected from \c ir_texture_opcodes. In the printed IR, these will 1816 * appear as: 1817 * 1818 * Texel offset (0 or an expression) 1819 * | Projection divisor 1820 * | | Shadow comparator 1821 * | | | 1822 * v v v 1823 * (tex <type> <sampler> <coordinate> 0 1 ( )) 1824 * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>) 1825 * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>) 1826 * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy)) 1827 * (txf <type> <sampler> <coordinate> 0 <lod>) 1828 * (txf_ms 1829 * <type> <sampler> <coordinate> <sample_index>) 1830 * (txs <type> <sampler> <lod>) 1831 * (lod <type> <sampler> <coordinate>) 1832 * (tg4 <type> <sampler> <coordinate> <offset> <component>) 1833 * (query_levels <type> <sampler>) 1834 * (samples_identical <sampler> <coordinate>) 1835 */ 1836 class ir_texture : public ir_rvalue { 1837 public: 1838 ir_texture(enum ir_texture_opcode op) 1839 : ir_rvalue(ir_type_texture), 1840 op(op), sampler(NULL), coordinate(NULL), projector(NULL), 1841 shadow_comparator(NULL), offset(NULL) 1842 { 1843 memset(&lod_info, 0, sizeof(lod_info)); 1844 } 1845 1846 virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const; 1847 1848 virtual ir_constant *constant_expression_value(void *mem_ctx, 1849 struct hash_table *variable_context = NULL); 1850 1851 virtual void accept(ir_visitor *v) 1852 { 1853 v->visit(this); 1854 } 1855 1856 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1857 1858 virtual bool equals(const ir_instruction *ir, 1859 enum ir_node_type ignore = ir_type_unset) const; 1860 1861 /** 1862 * Return a string representing the ir_texture_opcode. 1863 */ 1864 const char *opcode_string(); 1865 1866 /** Set the sampler and type. */ 1867 void set_sampler(ir_dereference *sampler, const glsl_type *type); 1868 1869 /** 1870 * Do a reverse-lookup to translate a string into an ir_texture_opcode. 1871 */ 1872 static ir_texture_opcode get_opcode(const char *); 1873 1874 enum ir_texture_opcode op; 1875 1876 /** Sampler to use for the texture access. */ 1877 ir_dereference *sampler; 1878 1879 /** Texture coordinate to sample */ 1880 ir_rvalue *coordinate; 1881 1882 /** 1883 * Value used for projective divide. 1884 * 1885 * If there is no projective divide (the common case), this will be 1886 * \c NULL. Optimization passes should check for this to point to a constant 1887 * of 1.0 and replace that with \c NULL. 1888 */ 1889 ir_rvalue *projector; 1890 1891 /** 1892 * Coordinate used for comparison on shadow look-ups. 1893 * 1894 * If there is no shadow comparison, this will be \c NULL. For the 1895 * \c ir_txf opcode, this *must* be \c NULL. 1896 */ 1897 ir_rvalue *shadow_comparator; 1898 1899 /** Texel offset. */ 1900 ir_rvalue *offset; 1901 1902 union { 1903 ir_rvalue *lod; /**< Floating point LOD */ 1904 ir_rvalue *bias; /**< Floating point LOD bias */ 1905 ir_rvalue *sample_index; /**< MSAA sample index */ 1906 ir_rvalue *component; /**< Gather component selector */ 1907 struct { 1908 ir_rvalue *dPdx; /**< Partial derivative of coordinate wrt X */ 1909 ir_rvalue *dPdy; /**< Partial derivative of coordinate wrt Y */ 1910 } grad; 1911 } lod_info; 1912 }; 1913 1914 1915 struct ir_swizzle_mask { 1916 unsigned x:2; 1917 unsigned y:2; 1918 unsigned z:2; 1919 unsigned w:2; 1920 1921 /** 1922 * Number of components in the swizzle. 1923 */ 1924 unsigned num_components:3; 1925 1926 /** 1927 * Does the swizzle contain duplicate components? 1928 * 1929 * L-value swizzles cannot contain duplicate components. 1930 */ 1931 unsigned has_duplicates:1; 1932 }; 1933 1934 1935 class ir_swizzle : public ir_rvalue { 1936 public: 1937 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w, 1938 unsigned count); 1939 1940 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count); 1941 1942 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask); 1943 1944 virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const; 1945 1946 virtual ir_constant *constant_expression_value(void *mem_ctx, 1947 struct hash_table *variable_context = NULL); 1948 1949 /** 1950 * Construct an ir_swizzle from the textual representation. Can fail. 1951 */ 1952 static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length); 1953 1954 virtual void accept(ir_visitor *v) 1955 { 1956 v->visit(this); 1957 } 1958 1959 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 1960 1961 virtual bool equals(const ir_instruction *ir, 1962 enum ir_node_type ignore = ir_type_unset) const; 1963 1964 bool is_lvalue(const struct _mesa_glsl_parse_state *state) const 1965 { 1966 return val->is_lvalue(state) && !mask.has_duplicates; 1967 } 1968 1969 /** 1970 * Get the variable that is ultimately referenced by an r-value 1971 */ 1972 virtual ir_variable *variable_referenced() const; 1973 1974 ir_rvalue *val; 1975 ir_swizzle_mask mask; 1976 1977 private: 1978 /** 1979 * Initialize the mask component of a swizzle 1980 * 1981 * This is used by the \c ir_swizzle constructors. 1982 */ 1983 void init_mask(const unsigned *components, unsigned count); 1984 }; 1985 1986 1987 class ir_dereference : public ir_rvalue { 1988 public: 1989 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0; 1990 1991 bool is_lvalue(const struct _mesa_glsl_parse_state *state) const; 1992 1993 /** 1994 * Get the variable that is ultimately referenced by an r-value 1995 */ 1996 virtual ir_variable *variable_referenced() const = 0; 1997 1998 protected: 1999 ir_dereference(enum ir_node_type t) 2000 : ir_rvalue(t) 2001 { 2002 } 2003 }; 2004 2005 2006 class ir_dereference_variable : public ir_dereference { 2007 public: 2008 ir_dereference_variable(ir_variable *var); 2009 2010 virtual ir_dereference_variable *clone(void *mem_ctx, 2011 struct hash_table *) const; 2012 2013 virtual ir_constant *constant_expression_value(void *mem_ctx, 2014 struct hash_table *variable_context = NULL); 2015 2016 virtual bool equals(const ir_instruction *ir, 2017 enum ir_node_type ignore = ir_type_unset) const; 2018 2019 /** 2020 * Get the variable that is ultimately referenced by an r-value 2021 */ 2022 virtual ir_variable *variable_referenced() const 2023 { 2024 return this->var; 2025 } 2026 2027 virtual ir_variable *whole_variable_referenced() 2028 { 2029 /* ir_dereference_variable objects always dereference the entire 2030 * variable. However, if this dereference is dereferenced by anything 2031 * else, the complete deferefernce chain is not a whole-variable 2032 * dereference. This method should only be called on the top most 2033 * ir_rvalue in a dereference chain. 2034 */ 2035 return this->var; 2036 } 2037 2038 virtual void accept(ir_visitor *v) 2039 { 2040 v->visit(this); 2041 } 2042 2043 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2044 2045 /** 2046 * Object being dereferenced. 2047 */ 2048 ir_variable *var; 2049 }; 2050 2051 2052 class ir_dereference_array : public ir_dereference { 2053 public: 2054 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index); 2055 2056 ir_dereference_array(ir_variable *var, ir_rvalue *array_index); 2057 2058 virtual ir_dereference_array *clone(void *mem_ctx, 2059 struct hash_table *) const; 2060 2061 virtual ir_constant *constant_expression_value(void *mem_ctx, 2062 struct hash_table *variable_context = NULL); 2063 2064 virtual bool equals(const ir_instruction *ir, 2065 enum ir_node_type ignore = ir_type_unset) const; 2066 2067 /** 2068 * Get the variable that is ultimately referenced by an r-value 2069 */ 2070 virtual ir_variable *variable_referenced() const 2071 { 2072 return this->array->variable_referenced(); 2073 } 2074 2075 virtual void accept(ir_visitor *v) 2076 { 2077 v->visit(this); 2078 } 2079 2080 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2081 2082 ir_rvalue *array; 2083 ir_rvalue *array_index; 2084 2085 private: 2086 void set_array(ir_rvalue *value); 2087 }; 2088 2089 2090 class ir_dereference_record : public ir_dereference { 2091 public: 2092 ir_dereference_record(ir_rvalue *value, const char *field); 2093 2094 ir_dereference_record(ir_variable *var, const char *field); 2095 2096 virtual ir_dereference_record *clone(void *mem_ctx, 2097 struct hash_table *) const; 2098 2099 virtual ir_constant *constant_expression_value(void *mem_ctx, 2100 struct hash_table *variable_context = NULL); 2101 2102 /** 2103 * Get the variable that is ultimately referenced by an r-value 2104 */ 2105 virtual ir_variable *variable_referenced() const 2106 { 2107 return this->record->variable_referenced(); 2108 } 2109 2110 virtual void accept(ir_visitor *v) 2111 { 2112 v->visit(this); 2113 } 2114 2115 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2116 2117 ir_rvalue *record; 2118 int field_idx; 2119 }; 2120 2121 2122 /** 2123 * Data stored in an ir_constant 2124 */ 2125 union ir_constant_data { 2126 unsigned u[16]; 2127 int i[16]; 2128 float f[16]; 2129 bool b[16]; 2130 double d[16]; 2131 uint64_t u64[16]; 2132 int64_t i64[16]; 2133 }; 2134 2135 2136 class ir_constant : public ir_rvalue { 2137 public: 2138 ir_constant(const struct glsl_type *type, const ir_constant_data *data); 2139 ir_constant(bool b, unsigned vector_elements=1); 2140 ir_constant(unsigned int u, unsigned vector_elements=1); 2141 ir_constant(int i, unsigned vector_elements=1); 2142 ir_constant(float f, unsigned vector_elements=1); 2143 ir_constant(double d, unsigned vector_elements=1); 2144 ir_constant(uint64_t u64, unsigned vector_elements=1); 2145 ir_constant(int64_t i64, unsigned vector_elements=1); 2146 2147 /** 2148 * Construct an ir_constant from a list of ir_constant values 2149 */ 2150 ir_constant(const struct glsl_type *type, exec_list *values); 2151 2152 /** 2153 * Construct an ir_constant from a scalar component of another ir_constant 2154 * 2155 * The new \c ir_constant inherits the type of the component from the 2156 * source constant. 2157 * 2158 * \note 2159 * In the case of a matrix constant, the new constant is a scalar, \b not 2160 * a vector. 2161 */ 2162 ir_constant(const ir_constant *c, unsigned i); 2163 2164 /** 2165 * Return a new ir_constant of the specified type containing all zeros. 2166 */ 2167 static ir_constant *zero(void *mem_ctx, const glsl_type *type); 2168 2169 virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const; 2170 2171 virtual ir_constant *constant_expression_value(void *mem_ctx, 2172 struct hash_table *variable_context = NULL); 2173 2174 virtual void accept(ir_visitor *v) 2175 { 2176 v->visit(this); 2177 } 2178 2179 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2180 2181 virtual bool equals(const ir_instruction *ir, 2182 enum ir_node_type ignore = ir_type_unset) const; 2183 2184 /** 2185 * Get a particular component of a constant as a specific type 2186 * 2187 * This is useful, for example, to get a value from an integer constant 2188 * as a float or bool. This appears frequently when constructors are 2189 * called with all constant parameters. 2190 */ 2191 /*@{*/ 2192 bool get_bool_component(unsigned i) const; 2193 float get_float_component(unsigned i) const; 2194 double get_double_component(unsigned i) const; 2195 int get_int_component(unsigned i) const; 2196 unsigned get_uint_component(unsigned i) const; 2197 int64_t get_int64_component(unsigned i) const; 2198 uint64_t get_uint64_component(unsigned i) const; 2199 /*@}*/ 2200 2201 ir_constant *get_array_element(unsigned i) const; 2202 2203 ir_constant *get_record_field(int idx); 2204 2205 /** 2206 * Copy the values on another constant at a given offset. 2207 * 2208 * The offset is ignored for array or struct copies, it's only for 2209 * scalars or vectors into vectors or matrices. 2210 * 2211 * With identical types on both sides and zero offset it's clone() 2212 * without creating a new object. 2213 */ 2214 2215 void copy_offset(ir_constant *src, int offset); 2216 2217 /** 2218 * Copy the values on another constant at a given offset and 2219 * following an assign-like mask. 2220 * 2221 * The mask is ignored for scalars. 2222 * 2223 * Note that this function only handles what assign can handle, 2224 * i.e. at most a vector as source and a column of a matrix as 2225 * destination. 2226 */ 2227 2228 void copy_masked_offset(ir_constant *src, int offset, unsigned int mask); 2229 2230 /** 2231 * Determine whether a constant has the same value as another constant 2232 * 2233 * \sa ir_constant::is_zero, ir_constant::is_one, 2234 * ir_constant::is_negative_one 2235 */ 2236 bool has_value(const ir_constant *) const; 2237 2238 /** 2239 * Return true if this ir_constant represents the given value. 2240 * 2241 * For vectors, this checks that each component is the given value. 2242 */ 2243 virtual bool is_value(float f, int i) const; 2244 virtual bool is_zero() const; 2245 virtual bool is_one() const; 2246 virtual bool is_negative_one() const; 2247 2248 /** 2249 * Return true for constants that could be stored as 16-bit unsigned values. 2250 * 2251 * Note that this will return true even for signed integer ir_constants, as 2252 * long as the value is non-negative and fits in 16-bits. 2253 */ 2254 virtual bool is_uint16_constant() const; 2255 2256 /** 2257 * Value of the constant. 2258 * 2259 * The field used to back the values supplied by the constant is determined 2260 * by the type associated with the \c ir_instruction. Constants may be 2261 * scalars, vectors, or matrices. 2262 */ 2263 union ir_constant_data value; 2264 2265 /* Array elements and structure fields */ 2266 ir_constant **const_elements; 2267 2268 private: 2269 /** 2270 * Parameterless constructor only used by the clone method 2271 */ 2272 ir_constant(void); 2273 }; 2274 2275 /** 2276 * IR instruction to emit a vertex in a geometry shader. 2277 */ 2278 class ir_emit_vertex : public ir_instruction { 2279 public: 2280 ir_emit_vertex(ir_rvalue *stream) 2281 : ir_instruction(ir_type_emit_vertex), 2282 stream(stream) 2283 { 2284 assert(stream); 2285 } 2286 2287 virtual void accept(ir_visitor *v) 2288 { 2289 v->visit(this); 2290 } 2291 2292 virtual ir_emit_vertex *clone(void *mem_ctx, struct hash_table *ht) const 2293 { 2294 return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht)); 2295 } 2296 2297 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2298 2299 int stream_id() const 2300 { 2301 return stream->as_constant()->value.i[0]; 2302 } 2303 2304 ir_rvalue *stream; 2305 }; 2306 2307 /** 2308 * IR instruction to complete the current primitive and start a new one in a 2309 * geometry shader. 2310 */ 2311 class ir_end_primitive : public ir_instruction { 2312 public: 2313 ir_end_primitive(ir_rvalue *stream) 2314 : ir_instruction(ir_type_end_primitive), 2315 stream(stream) 2316 { 2317 assert(stream); 2318 } 2319 2320 virtual void accept(ir_visitor *v) 2321 { 2322 v->visit(this); 2323 } 2324 2325 virtual ir_end_primitive *clone(void *mem_ctx, struct hash_table *ht) const 2326 { 2327 return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht)); 2328 } 2329 2330 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2331 2332 int stream_id() const 2333 { 2334 return stream->as_constant()->value.i[0]; 2335 } 2336 2337 ir_rvalue *stream; 2338 }; 2339 2340 /** 2341 * IR instruction for tessellation control and compute shader barrier. 2342 */ 2343 class ir_barrier : public ir_instruction { 2344 public: 2345 ir_barrier() 2346 : ir_instruction(ir_type_barrier) 2347 { 2348 } 2349 2350 virtual void accept(ir_visitor *v) 2351 { 2352 v->visit(this); 2353 } 2354 2355 virtual ir_barrier *clone(void *mem_ctx, struct hash_table *) const 2356 { 2357 return new(mem_ctx) ir_barrier(); 2358 } 2359 2360 virtual ir_visitor_status accept(ir_hierarchical_visitor *); 2361 }; 2362 2363 /*@}*/ 2364 2365 /** 2366 * Apply a visitor to each IR node in a list 2367 */ 2368 void 2369 visit_exec_list(exec_list *list, ir_visitor *visitor); 2370 2371 /** 2372 * Validate invariants on each IR node in a list 2373 */ 2374 void validate_ir_tree(exec_list *instructions); 2375 2376 struct _mesa_glsl_parse_state; 2377 struct gl_shader_program; 2378 2379 /** 2380 * Detect whether an unlinked shader contains static recursion 2381 * 2382 * If the list of instructions is determined to contain static recursion, 2383 * \c _mesa_glsl_error will be called to emit error messages for each function 2384 * that is in the recursion cycle. 2385 */ 2386 void 2387 detect_recursion_unlinked(struct _mesa_glsl_parse_state *state, 2388 exec_list *instructions); 2389 2390 /** 2391 * Detect whether a linked shader contains static recursion 2392 * 2393 * If the list of instructions is determined to contain static recursion, 2394 * \c link_error_printf will be called to emit error messages for each function 2395 * that is in the recursion cycle. In addition, 2396 * \c gl_shader_program::LinkStatus will be set to false. 2397 */ 2398 void 2399 detect_recursion_linked(struct gl_shader_program *prog, 2400 exec_list *instructions); 2401 2402 /** 2403 * Make a clone of each IR instruction in a list 2404 * 2405 * \param in List of IR instructions that are to be cloned 2406 * \param out List to hold the cloned instructions 2407 */ 2408 void 2409 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in); 2410 2411 extern void 2412 _mesa_glsl_initialize_variables(exec_list *instructions, 2413 struct _mesa_glsl_parse_state *state); 2414 2415 extern void 2416 reparent_ir(exec_list *list, void *mem_ctx); 2417 2418 extern void 2419 do_set_program_inouts(exec_list *instructions, struct gl_program *prog, 2420 gl_shader_stage shader_stage); 2421 2422 extern char * 2423 prototype_string(const glsl_type *return_type, const char *name, 2424 exec_list *parameters); 2425 2426 const char * 2427 mode_string(const ir_variable *var); 2428 2429 /** 2430 * Built-in / reserved GL variables names start with "gl_" 2431 */ 2432 static inline bool 2433 is_gl_identifier(const char *s) 2434 { 2435 return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_'; 2436 } 2437 2438 extern "C" { 2439 #endif /* __cplusplus */ 2440 2441 extern void _mesa_print_ir(FILE *f, struct exec_list *instructions, 2442 struct _mesa_glsl_parse_state *state); 2443 2444 extern void 2445 fprint_ir(FILE *f, const void *instruction); 2446 2447 extern const struct gl_builtin_uniform_desc * 2448 _mesa_glsl_get_builtin_uniform_desc(const char *name); 2449 2450 #ifdef __cplusplus 2451 } /* extern "C" */ 2452 #endif 2453 2454 unsigned 2455 vertices_per_prim(GLenum prim); 2456 2457 #endif /* IR_H */ 2458