1/* -*- c++ -*- */ 2/* 3 * Copyright © 2009 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 AST_H 26#define AST_H 27 28#include "list.h" 29#include "glsl_parser_extras.h" 30#include "compiler/glsl_types.h" 31#include "util/bitset.h" 32 33struct _mesa_glsl_parse_state; 34 35struct YYLTYPE; 36 37/** 38 * \defgroup AST Abstract syntax tree node definitions 39 * 40 * An abstract syntax tree is generated by the parser. This is a fairly 41 * direct representation of the gramma derivation for the source program. 42 * No symantic checking is done during the generation of the AST. Only 43 * syntactic checking is done. Symantic checking is performed by a later 44 * stage that converts the AST to a more generic intermediate representation. 45 * 46 *@{ 47 */ 48/** 49 * Base class of all abstract syntax tree nodes 50 */ 51class ast_node { 52public: 53 DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(ast_node); 54 55 /** 56 * Print an AST node in something approximating the original GLSL code 57 */ 58 virtual void print(void) const; 59 60 /** 61 * Convert the AST node to the high-level intermediate representation 62 */ 63 virtual ir_rvalue *hir(exec_list *instructions, 64 struct _mesa_glsl_parse_state *state); 65 66 virtual bool has_sequence_subexpression() const; 67 68 /** 69 * Retrieve the source location of an AST node 70 * 71 * This function is primarily used to get the source position of an AST node 72 * into a form that can be passed to \c _mesa_glsl_error. 73 * 74 * \sa _mesa_glsl_error, ast_node::set_location 75 */ 76 struct YYLTYPE get_location(void) const 77 { 78 struct YYLTYPE locp; 79 80 locp.path = this->location.path; 81 locp.source = this->location.source; 82 locp.first_line = this->location.first_line; 83 locp.first_column = this->location.first_column; 84 locp.last_line = this->location.last_line; 85 locp.last_column = this->location.last_column; 86 87 return locp; 88 } 89 90 /** 91 * Set the source location of an AST node from a parser location 92 * 93 * \sa ast_node::get_location 94 */ 95 void set_location(const struct YYLTYPE &locp) 96 { 97 this->location.path = locp.path; 98 this->location.source = locp.source; 99 this->location.first_line = locp.first_line; 100 this->location.first_column = locp.first_column; 101 this->location.last_line = locp.last_line; 102 this->location.last_column = locp.last_column; 103 } 104 105 /** 106 * Set the source location range of an AST node using two location nodes 107 * 108 * \sa ast_node::set_location 109 */ 110 void set_location_range(const struct YYLTYPE &begin, const struct YYLTYPE &end) 111 { 112 this->location.path = begin.path; 113 this->location.source = begin.source; 114 this->location.first_line = begin.first_line; 115 this->location.last_line = end.last_line; 116 this->location.first_column = begin.first_column; 117 this->location.last_column = end.last_column; 118 } 119 120 /** 121 * Source location of the AST node. 122 */ 123 struct { 124 char *path; /**< GLSL shader include path. */ 125 unsigned source; /**< GLSL source number. */ 126 unsigned first_line; /**< First line number within the source string. */ 127 unsigned first_column; /**< First column in the first line. */ 128 unsigned last_line; /**< Last line number within the source string. */ 129 unsigned last_column; /**< Last column in the last line. */ 130 } location; 131 132 exec_node link; 133 134 virtual void set_is_lhs(bool); 135 136protected: 137 /** 138 * The only constructor is protected so that only derived class objects can 139 * be created. 140 */ 141 ast_node(void); 142}; 143 144 145/** 146 * Operators for AST expression nodes. 147 */ 148enum ast_operators { 149 ast_assign, 150 ast_plus, /**< Unary + operator. */ 151 ast_neg, 152 ast_add, 153 ast_sub, 154 ast_mul, 155 ast_div, 156 ast_mod, 157 ast_lshift, 158 ast_rshift, 159 ast_less, 160 ast_greater, 161 ast_lequal, 162 ast_gequal, 163 ast_equal, 164 ast_nequal, 165 ast_bit_and, 166 ast_bit_xor, 167 ast_bit_or, 168 ast_bit_not, 169 ast_logic_and, 170 ast_logic_xor, 171 ast_logic_or, 172 ast_logic_not, 173 174 ast_mul_assign, 175 ast_div_assign, 176 ast_mod_assign, 177 ast_add_assign, 178 ast_sub_assign, 179 ast_ls_assign, 180 ast_rs_assign, 181 ast_and_assign, 182 ast_xor_assign, 183 ast_or_assign, 184 185 ast_conditional, 186 187 ast_pre_inc, 188 ast_pre_dec, 189 ast_post_inc, 190 ast_post_dec, 191 ast_field_selection, 192 ast_array_index, 193 ast_unsized_array_dim, 194 195 ast_function_call, 196 197 ast_identifier, 198 ast_int_constant, 199 ast_uint_constant, 200 ast_float_constant, 201 ast_bool_constant, 202 ast_double_constant, 203 ast_int64_constant, 204 ast_uint64_constant, 205 206 ast_sequence, 207 ast_aggregate 208 209 /** 210 * Number of possible operators for an ast_expression 211 * 212 * This is done as a define instead of as an additional value in the enum so 213 * that the compiler won't generate spurious messages like "warning: 214 * enumeration value ‘ast_num_operators’ not handled in switch" 215 */ 216 #define AST_NUM_OPERATORS (ast_aggregate + 1) 217}; 218 219/** 220 * Representation of any sort of expression. 221 */ 222class ast_expression : public ast_node { 223public: 224 ast_expression(int oper, ast_expression *, 225 ast_expression *, ast_expression *); 226 227 ast_expression(const char *identifier) : 228 oper(ast_identifier) 229 { 230 subexpressions[0] = NULL; 231 subexpressions[1] = NULL; 232 subexpressions[2] = NULL; 233 primary_expression.identifier = identifier; 234 this->non_lvalue_description = NULL; 235 this->is_lhs = false; 236 } 237 238 static const char *operator_string(enum ast_operators op); 239 240 virtual ir_rvalue *hir(exec_list *instructions, 241 struct _mesa_glsl_parse_state *state); 242 243 virtual void hir_no_rvalue(exec_list *instructions, 244 struct _mesa_glsl_parse_state *state); 245 246 virtual bool has_sequence_subexpression() const; 247 248 ir_rvalue *do_hir(exec_list *instructions, 249 struct _mesa_glsl_parse_state *state, 250 bool needs_rvalue); 251 252 virtual void print(void) const; 253 254 enum ast_operators oper; 255 256 ast_expression *subexpressions[3]; 257 258 union { 259 const char *identifier; 260 int int_constant; 261 float float_constant; 262 unsigned uint_constant; 263 int bool_constant; 264 double double_constant; 265 uint64_t uint64_constant; 266 int64_t int64_constant; 267 } primary_expression; 268 269 270 /** 271 * List of expressions for an \c ast_sequence or parameters for an 272 * \c ast_function_call 273 */ 274 exec_list expressions; 275 276 /** 277 * For things that can't be l-values, this describes what it is. 278 * 279 * This text is used by the code that generates IR for assignments to 280 * detect and emit useful messages for assignments to some things that 281 * can't be l-values. For example, pre- or post-incerement expressions. 282 * 283 * \note 284 * This pointer may be \c NULL. 285 */ 286 const char *non_lvalue_description; 287 288 void set_is_lhs(bool new_value); 289 290private: 291 bool is_lhs; 292}; 293 294class ast_expression_bin : public ast_expression { 295public: 296 ast_expression_bin(int oper, ast_expression *, ast_expression *); 297 298 virtual void print(void) const; 299}; 300 301/** 302 * Subclass of expressions for function calls 303 */ 304class ast_function_expression : public ast_expression { 305public: 306 ast_function_expression(ast_expression *callee) 307 : ast_expression(ast_function_call, callee, 308 NULL, NULL), 309 cons(false) 310 { 311 /* empty */ 312 } 313 314 ast_function_expression(class ast_type_specifier *type) 315 : ast_expression(ast_function_call, (ast_expression *) type, 316 NULL, NULL), 317 cons(true) 318 { 319 /* empty */ 320 } 321 322 bool is_constructor() const 323 { 324 return cons; 325 } 326 327 virtual ir_rvalue *hir(exec_list *instructions, 328 struct _mesa_glsl_parse_state *state); 329 330 virtual void hir_no_rvalue(exec_list *instructions, 331 struct _mesa_glsl_parse_state *state); 332 333 virtual bool has_sequence_subexpression() const; 334 335private: 336 /** 337 * Is this function call actually a constructor? 338 */ 339 bool cons; 340 ir_rvalue * 341 handle_method(exec_list *instructions, 342 struct _mesa_glsl_parse_state *state); 343}; 344 345class ast_subroutine_list : public ast_node 346{ 347public: 348 virtual void print(void) const; 349 exec_list declarations; 350}; 351 352class ast_array_specifier : public ast_node { 353public: 354 ast_array_specifier(const struct YYLTYPE &locp, ast_expression *dim) 355 { 356 set_location(locp); 357 array_dimensions.push_tail(&dim->link); 358 } 359 360 void add_dimension(ast_expression *dim) 361 { 362 array_dimensions.push_tail(&dim->link); 363 } 364 365 bool is_single_dimension() const 366 { 367 return this->array_dimensions.get_tail_raw()->prev != NULL && 368 this->array_dimensions.get_tail_raw()->prev->is_head_sentinel(); 369 } 370 371 virtual void print(void) const; 372 373 /* This list contains objects of type ast_node containing the 374 * array dimensions in outermost-to-innermost order. 375 */ 376 exec_list array_dimensions; 377}; 378 379class ast_layout_expression : public ast_node { 380public: 381 ast_layout_expression(const struct YYLTYPE &locp, ast_expression *expr) 382 { 383 set_location(locp); 384 layout_const_expressions.push_tail(&expr->link); 385 } 386 387 bool process_qualifier_constant(struct _mesa_glsl_parse_state *state, 388 const char *qual_indentifier, 389 unsigned *value, bool can_be_zero); 390 391 void merge_qualifier(ast_layout_expression *l_expr) 392 { 393 layout_const_expressions.append_list(&l_expr->layout_const_expressions); 394 } 395 396 exec_list layout_const_expressions; 397}; 398 399/** 400 * C-style aggregate initialization class 401 * 402 * Represents C-style initializers of vectors, matrices, arrays, and 403 * structures. E.g., vec3 pos = {1.0, 0.0, -1.0} is equivalent to 404 * vec3 pos = vec3(1.0, 0.0, -1.0). 405 * 406 * Specified in GLSL 4.20 and GL_ARB_shading_language_420pack. 407 * 408 * \sa _mesa_ast_set_aggregate_type 409 */ 410class ast_aggregate_initializer : public ast_expression { 411public: 412 ast_aggregate_initializer() 413 : ast_expression(ast_aggregate, NULL, NULL, NULL), 414 constructor_type(NULL) 415 { 416 /* empty */ 417 } 418 419 /** 420 * glsl_type of the aggregate, which is inferred from the LHS of whatever 421 * the aggregate is being used to initialize. This can't be inferred at 422 * parse time (since the parser deals with ast_type_specifiers, not 423 * glsl_types), so the parser leaves it NULL. However, the ast-to-hir 424 * conversion code makes sure to fill it in with the appropriate type 425 * before hir() is called. 426 */ 427 const glsl_type *constructor_type; 428 429 virtual ir_rvalue *hir(exec_list *instructions, 430 struct _mesa_glsl_parse_state *state); 431 432 virtual void hir_no_rvalue(exec_list *instructions, 433 struct _mesa_glsl_parse_state *state); 434}; 435 436 437class ast_compound_statement : public ast_node { 438public: 439 ast_compound_statement(int new_scope, ast_node *statements); 440 virtual void print(void) const; 441 442 virtual ir_rvalue *hir(exec_list *instructions, 443 struct _mesa_glsl_parse_state *state); 444 445 int new_scope; 446 exec_list statements; 447}; 448 449class ast_declaration : public ast_node { 450public: 451 ast_declaration(const char *identifier, 452 ast_array_specifier *array_specifier, 453 ast_expression *initializer); 454 virtual void print(void) const; 455 456 const char *identifier; 457 458 ast_array_specifier *array_specifier; 459 460 ast_expression *initializer; 461}; 462 463 464enum { 465 ast_precision_none = 0, /**< Absence of precision qualifier. */ 466 ast_precision_high, 467 ast_precision_medium, 468 ast_precision_low 469}; 470 471enum { 472 ast_depth_none = 0, /**< Absence of depth qualifier. */ 473 ast_depth_any, 474 ast_depth_greater, 475 ast_depth_less, 476 ast_depth_unchanged 477}; 478 479struct ast_type_qualifier { 480 DECLARE_RALLOC_CXX_OPERATORS(ast_type_qualifier); 481 /* Note: this bitset needs to have at least as many bits as the 'q' 482 * struct has flags, below. Previously, the size was 128 instead of 96. 483 * But an apparent bug in GCC 5.4.0 causes bad SSE code generation 484 * elsewhere, leading to a crash. 96 bits works around the issue. 485 * See https://bugs.freedesktop.org/show_bug.cgi?id=105497 486 */ 487 DECLARE_BITSET_T(bitset_t, 96); 488 489 union flags { 490 struct { 491 unsigned invariant:1; 492 unsigned precise:1; 493 unsigned constant:1; 494 unsigned attribute:1; 495 unsigned varying:1; 496 unsigned in:1; 497 unsigned out:1; 498 unsigned centroid:1; 499 unsigned sample:1; 500 unsigned patch:1; 501 unsigned uniform:1; 502 unsigned buffer:1; 503 unsigned shared_storage:1; 504 unsigned smooth:1; 505 unsigned flat:1; 506 unsigned noperspective:1; 507 508 /** \name Layout qualifiers for GL_ARB_fragment_coord_conventions */ 509 /*@{*/ 510 unsigned origin_upper_left:1; 511 unsigned pixel_center_integer:1; 512 /*@}*/ 513 514 /** 515 * Flag set if GL_ARB_enhanced_layouts "align" layout qualifier is 516 * used. 517 */ 518 unsigned explicit_align:1; 519 520 /** 521 * Flag set if GL_ARB_explicit_attrib_location "location" layout 522 * qualifier is used. 523 */ 524 unsigned explicit_location:1; 525 /** 526 * Flag set if GL_ARB_explicit_attrib_location "index" layout 527 * qualifier is used. 528 */ 529 unsigned explicit_index:1; 530 531 /** 532 * Flag set if GL_ARB_enhanced_layouts "component" layout 533 * qualifier is used. 534 */ 535 unsigned explicit_component:1; 536 537 /** 538 * Flag set if GL_ARB_shading_language_420pack "binding" layout 539 * qualifier is used. 540 */ 541 unsigned explicit_binding:1; 542 543 /** 544 * Flag set if GL_ARB_shader_atomic counter "offset" layout 545 * qualifier is used. 546 */ 547 unsigned explicit_offset:1; 548 549 /** \name Layout qualifiers for GL_AMD_conservative_depth */ 550 /** \{ */ 551 unsigned depth_type:1; 552 /** \} */ 553 554 /** \name Layout qualifiers for GL_ARB_uniform_buffer_object */ 555 /** \{ */ 556 unsigned std140:1; 557 unsigned std430:1; 558 unsigned shared:1; 559 unsigned packed:1; 560 unsigned column_major:1; 561 unsigned row_major:1; 562 /** \} */ 563 564 /** \name Layout qualifiers for GLSL 1.50 geometry shaders */ 565 /** \{ */ 566 unsigned prim_type:1; 567 unsigned max_vertices:1; 568 /** \} */ 569 570 /** 571 * local_size_{x,y,z} flags for compute shaders. Bit 0 represents 572 * local_size_x, and so on. 573 */ 574 unsigned local_size:3; 575 576 /** \name Layout qualifiers for ARB_compute_variable_group_size. */ 577 /** \{ */ 578 unsigned local_size_variable:1; 579 /** \} */ 580 581 /** \name Layout and memory qualifiers for ARB_shader_image_load_store. */ 582 /** \{ */ 583 unsigned early_fragment_tests:1; 584 unsigned explicit_image_format:1; 585 unsigned coherent:1; 586 unsigned _volatile:1; 587 unsigned restrict_flag:1; 588 unsigned read_only:1; /**< "readonly" qualifier. */ 589 unsigned write_only:1; /**< "writeonly" qualifier. */ 590 /** \} */ 591 592 /** \name Layout qualifiers for GL_ARB_gpu_shader5 */ 593 /** \{ */ 594 unsigned invocations:1; 595 unsigned stream:1; /**< Has stream value assigned */ 596 unsigned explicit_stream:1; /**< stream value assigned explicitly by shader code */ 597 /** \} */ 598 599 /** \name Layout qualifiers for GL_ARB_enhanced_layouts */ 600 /** \{ */ 601 unsigned explicit_xfb_offset:1; /**< xfb_offset value assigned explicitly by shader code */ 602 unsigned xfb_buffer:1; /**< Has xfb_buffer value assigned */ 603 unsigned explicit_xfb_buffer:1; /**< xfb_buffer value assigned explicitly by shader code */ 604 unsigned xfb_stride:1; /**< Is xfb_stride value yet to be merged with global values */ 605 unsigned explicit_xfb_stride:1; /**< xfb_stride value assigned explicitly by shader code */ 606 /** \} */ 607 608 /** \name Layout qualifiers for GL_ARB_tessellation_shader */ 609 /** \{ */ 610 /* tess eval input layout */ 611 /* gs prim_type reused for primitive mode */ 612 unsigned vertex_spacing:1; 613 unsigned ordering:1; 614 unsigned point_mode:1; 615 /* tess control output layout */ 616 unsigned vertices:1; 617 /** \} */ 618 619 /** \name Qualifiers for GL_ARB_shader_subroutine */ 620 /** \{ */ 621 unsigned subroutine:1; /**< Is this marked 'subroutine' */ 622 /** \} */ 623 624 /** \name Qualifiers for GL_KHR_blend_equation_advanced */ 625 /** \{ */ 626 unsigned blend_support:1; /**< Are there any blend_support_ qualifiers */ 627 /** \} */ 628 629 /** 630 * Flag set if GL_ARB_post_depth_coverage layout qualifier is used. 631 */ 632 unsigned post_depth_coverage:1; 633 634 /** 635 * Flags for the layout qualifers added by ARB_fragment_shader_interlock 636 */ 637 638 unsigned pixel_interlock_ordered:1; 639 unsigned pixel_interlock_unordered:1; 640 unsigned sample_interlock_ordered:1; 641 unsigned sample_interlock_unordered:1; 642 643 /** 644 * Flag set if GL_INTEL_conservartive_rasterization layout qualifier 645 * is used. 646 */ 647 unsigned inner_coverage:1; 648 649 /** \name Layout qualifiers for GL_ARB_bindless_texture */ 650 /** \{ */ 651 unsigned bindless_sampler:1; 652 unsigned bindless_image:1; 653 unsigned bound_sampler:1; 654 unsigned bound_image:1; 655 /** \} */ 656 657 /** \name Layout qualifiers for GL_EXT_shader_framebuffer_fetch_non_coherent */ 658 /** \{ */ 659 unsigned non_coherent:1; 660 /** \} */ 661 662 /** \name Layout qualifiers for NV_compute_shader_derivatives */ 663 /** \{ */ 664 unsigned derivative_group:1; 665 /** \} */ 666 667 /** 668 * Flag set if GL_NV_viewport_array2 viewport_relative layout 669 * qualifier is used. 670 */ 671 unsigned viewport_relative:1; 672 } 673 /** \brief Set of flags, accessed by name. */ 674 q; 675 676 /** \brief Set of flags, accessed as a bitmask. */ 677 bitset_t i; 678 } flags; 679 680 /** Precision of the type (highp/medium/lowp). */ 681 unsigned precision:2; 682 683 /** Type of layout qualifiers for GL_AMD_conservative_depth. */ 684 unsigned depth_type:3; 685 686 /** 687 * Alignment specified via GL_ARB_enhanced_layouts "align" layout qualifier 688 */ 689 ast_expression *align; 690 691 /** Geometry shader invocations for GL_ARB_gpu_shader5. */ 692 ast_layout_expression *invocations; 693 694 /** 695 * Location specified via GL_ARB_explicit_attrib_location layout 696 * 697 * \note 698 * This field is only valid if \c explicit_location is set. 699 */ 700 ast_expression *location; 701 /** 702 * Index specified via GL_ARB_explicit_attrib_location layout 703 * 704 * \note 705 * This field is only valid if \c explicit_index is set. 706 */ 707 ast_expression *index; 708 709 /** 710 * Component specified via GL_ARB_enhaced_layouts 711 * 712 * \note 713 * This field is only valid if \c explicit_component is set. 714 */ 715 ast_expression *component; 716 717 /** Maximum output vertices in GLSL 1.50 geometry shaders. */ 718 ast_layout_expression *max_vertices; 719 720 /** Stream in GLSL 1.50 geometry shaders. */ 721 ast_expression *stream; 722 723 /** xfb_buffer specified via the GL_ARB_enhanced_layouts keyword. */ 724 ast_expression *xfb_buffer; 725 726 /** xfb_stride specified via the GL_ARB_enhanced_layouts keyword. */ 727 ast_expression *xfb_stride; 728 729 /** global xfb_stride values for each buffer */ 730 ast_layout_expression *out_xfb_stride[MAX_FEEDBACK_BUFFERS]; 731 732 /** 733 * Input or output primitive type in GLSL 1.50 geometry shaders 734 * and tessellation shaders. 735 */ 736 GLenum prim_type; 737 738 /** 739 * Binding specified via GL_ARB_shading_language_420pack's "binding" keyword. 740 * 741 * \note 742 * This field is only valid if \c explicit_binding is set. 743 */ 744 ast_expression *binding; 745 746 /** 747 * Offset specified via GL_ARB_shader_atomic_counter's or 748 * GL_ARB_enhanced_layouts "offset" keyword, or by GL_ARB_enhanced_layouts 749 * "xfb_offset" keyword. 750 * 751 * \note 752 * This field is only valid if \c explicit_offset is set. 753 */ 754 ast_expression *offset; 755 756 /** 757 * Local size specified via GL_ARB_compute_shader's "local_size_{x,y,z}" 758 * layout qualifier. Element i of this array is only valid if 759 * flags.q.local_size & (1 << i) is set. 760 */ 761 ast_layout_expression *local_size[3]; 762 763 /** Tessellation evaluation shader: vertex spacing (equal, fractional even/odd) */ 764 enum gl_tess_spacing vertex_spacing; 765 766 /** Tessellation evaluation shader: vertex ordering (CW or CCW) */ 767 GLenum ordering; 768 769 /** Tessellation evaluation shader: point mode */ 770 bool point_mode; 771 772 /** Tessellation control shader: number of output vertices */ 773 ast_layout_expression *vertices; 774 775 /** 776 * Image format specified with an ARB_shader_image_load_store 777 * layout qualifier. 778 * 779 * \note 780 * This field is only valid if \c explicit_image_format is set. 781 */ 782 enum pipe_format image_format; 783 784 /** 785 * Arrangement of invocations used to calculate derivatives in a compute 786 * shader. From NV_compute_shader_derivatives. 787 */ 788 enum gl_derivative_group derivative_group; 789 790 /** 791 * Base type of the data read from or written to this image. Only 792 * the following enumerants are allowed: GLSL_TYPE_UINT, 793 * GLSL_TYPE_INT, GLSL_TYPE_FLOAT. 794 * 795 * \note 796 * This field is only valid if \c explicit_image_format is set. 797 */ 798 glsl_base_type image_base_type; 799 800 /** 801 * Return true if and only if an interpolation qualifier is present. 802 */ 803 bool has_interpolation() const; 804 805 /** 806 * Return whether a layout qualifier is present. 807 */ 808 bool has_layout() const; 809 810 /** 811 * Return whether a storage qualifier is present. 812 */ 813 bool has_storage() const; 814 815 /** 816 * Return whether an auxiliary storage qualifier is present. 817 */ 818 bool has_auxiliary_storage() const; 819 820 /** 821 * Return true if and only if a memory qualifier is present. 822 */ 823 bool has_memory() const; 824 825 /** 826 * Return true if the qualifier is a subroutine declaration. 827 */ 828 bool is_subroutine_decl() const; 829 830 bool merge_qualifier(YYLTYPE *loc, 831 _mesa_glsl_parse_state *state, 832 const ast_type_qualifier &q, 833 bool is_single_layout_merge, 834 bool is_multiple_layouts_merge = false); 835 836 /** 837 * Validate current qualifier against the global out one. 838 */ 839 bool validate_out_qualifier(YYLTYPE *loc, 840 _mesa_glsl_parse_state *state); 841 842 /** 843 * Merge current qualifier into the global out one. 844 */ 845 bool merge_into_out_qualifier(YYLTYPE *loc, 846 _mesa_glsl_parse_state *state, 847 ast_node* &node); 848 849 /** 850 * Validate current qualifier against the global in one. 851 */ 852 bool validate_in_qualifier(YYLTYPE *loc, 853 _mesa_glsl_parse_state *state); 854 855 /** 856 * Merge current qualifier into the global in one. 857 */ 858 bool merge_into_in_qualifier(YYLTYPE *loc, 859 _mesa_glsl_parse_state *state, 860 ast_node* &node); 861 862 /** 863 * Push pending layout qualifiers to the global values. 864 */ 865 bool push_to_global(YYLTYPE *loc, 866 _mesa_glsl_parse_state *state); 867 868 bool validate_flags(YYLTYPE *loc, 869 _mesa_glsl_parse_state *state, 870 const ast_type_qualifier &allowed_flags, 871 const char *message, const char *name); 872 873 ast_subroutine_list *subroutine_list; 874}; 875 876class ast_declarator_list; 877 878class ast_struct_specifier : public ast_node { 879public: 880 ast_struct_specifier(const char *identifier, 881 ast_declarator_list *declarator_list); 882 virtual void print(void) const; 883 884 virtual ir_rvalue *hir(exec_list *instructions, 885 struct _mesa_glsl_parse_state *state); 886 887 const char *name; 888 ast_type_qualifier *layout; 889 /* List of ast_declarator_list * */ 890 exec_list declarations; 891 bool is_declaration; 892 const glsl_type *type; 893}; 894 895 896 897class ast_type_specifier : public ast_node { 898public: 899 /** Construct a type specifier from a type name */ 900 ast_type_specifier(const char *name) 901 : type(NULL), type_name(name), structure(NULL), array_specifier(NULL), 902 default_precision(ast_precision_none) 903 { 904 /* empty */ 905 } 906 907 /** Construct a type specifier from a structure definition */ 908 ast_type_specifier(ast_struct_specifier *s) 909 : type(NULL), type_name(s->name), structure(s), array_specifier(NULL), 910 default_precision(ast_precision_none) 911 { 912 /* empty */ 913 } 914 915 ast_type_specifier(const glsl_type *t) 916 : type(t), type_name(t->name), structure(NULL), array_specifier(NULL), 917 default_precision(ast_precision_none) 918 { 919 /* empty */ 920 } 921 922 const struct glsl_type *glsl_type(const char **name, 923 struct _mesa_glsl_parse_state *state) 924 const; 925 926 virtual void print(void) const; 927 928 ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *); 929 930 const struct glsl_type *type; 931 const char *type_name; 932 ast_struct_specifier *structure; 933 934 ast_array_specifier *array_specifier; 935 936 /** For precision statements, this is the given precision; otherwise none. */ 937 unsigned default_precision:2; 938}; 939 940 941class ast_fully_specified_type : public ast_node { 942public: 943 virtual void print(void) const; 944 bool has_qualifiers(_mesa_glsl_parse_state *state) const; 945 946 ast_fully_specified_type() : qualifier(), specifier(NULL) 947 { 948 } 949 950 const struct glsl_type *glsl_type(const char **name, 951 struct _mesa_glsl_parse_state *state) 952 const; 953 954 ast_type_qualifier qualifier; 955 ast_type_specifier *specifier; 956}; 957 958 959class ast_declarator_list : public ast_node { 960public: 961 ast_declarator_list(ast_fully_specified_type *); 962 virtual void print(void) const; 963 964 virtual ir_rvalue *hir(exec_list *instructions, 965 struct _mesa_glsl_parse_state *state); 966 967 ast_fully_specified_type *type; 968 /** List of 'ast_declaration *' */ 969 exec_list declarations; 970 971 /** 972 * Flags for redeclarations. In these cases, no type is specified, to 973 * `type` is allowed to be NULL. In all other cases, this would be an error. 974 */ 975 int invariant; /** < `invariant` redeclaration */ 976 int precise; /** < `precise` redeclaration */ 977}; 978 979 980class ast_parameter_declarator : public ast_node { 981public: 982 ast_parameter_declarator() : 983 type(NULL), 984 identifier(NULL), 985 array_specifier(NULL), 986 formal_parameter(false), 987 is_void(false) 988 { 989 /* empty */ 990 } 991 992 virtual void print(void) const; 993 994 virtual ir_rvalue *hir(exec_list *instructions, 995 struct _mesa_glsl_parse_state *state); 996 997 ast_fully_specified_type *type; 998 const char *identifier; 999 ast_array_specifier *array_specifier; 1000 1001 static void parameters_to_hir(exec_list *ast_parameters, 1002 bool formal, exec_list *ir_parameters, 1003 struct _mesa_glsl_parse_state *state); 1004 1005private: 1006 /** Is this parameter declaration part of a formal parameter list? */ 1007 bool formal_parameter; 1008 1009 /** 1010 * Is this parameter 'void' type? 1011 * 1012 * This field is set by \c ::hir. 1013 */ 1014 bool is_void; 1015}; 1016 1017 1018class ast_function : public ast_node { 1019public: 1020 ast_function(void); 1021 1022 virtual void print(void) const; 1023 1024 virtual ir_rvalue *hir(exec_list *instructions, 1025 struct _mesa_glsl_parse_state *state); 1026 1027 ast_fully_specified_type *return_type; 1028 const char *identifier; 1029 1030 exec_list parameters; 1031 1032private: 1033 /** 1034 * Is this prototype part of the function definition? 1035 * 1036 * Used by ast_function_definition::hir to process the parameters, etc. 1037 * of the function. 1038 * 1039 * \sa ::hir 1040 */ 1041 bool is_definition; 1042 1043 /** 1044 * Function signature corresponding to this function prototype instance 1045 * 1046 * Used by ast_function_definition::hir to process the parameters, etc. 1047 * of the function. 1048 * 1049 * \sa ::hir 1050 */ 1051 class ir_function_signature *signature; 1052 1053 friend class ast_function_definition; 1054}; 1055 1056 1057class ast_expression_statement : public ast_node { 1058public: 1059 ast_expression_statement(ast_expression *); 1060 virtual void print(void) const; 1061 1062 virtual ir_rvalue *hir(exec_list *instructions, 1063 struct _mesa_glsl_parse_state *state); 1064 1065 ast_expression *expression; 1066}; 1067 1068 1069class ast_case_label : public ast_node { 1070public: 1071 ast_case_label(ast_expression *test_value); 1072 virtual void print(void) const; 1073 1074 virtual ir_rvalue *hir(exec_list *instructions, 1075 struct _mesa_glsl_parse_state *state); 1076 1077 /** 1078 * An test value of NULL means 'default'. 1079 */ 1080 ast_expression *test_value; 1081}; 1082 1083 1084class ast_case_label_list : public ast_node { 1085public: 1086 ast_case_label_list(void); 1087 virtual void print(void) const; 1088 1089 virtual ir_rvalue *hir(exec_list *instructions, 1090 struct _mesa_glsl_parse_state *state); 1091 1092 /** 1093 * A list of case labels. 1094 */ 1095 exec_list labels; 1096}; 1097 1098 1099class ast_case_statement : public ast_node { 1100public: 1101 ast_case_statement(ast_case_label_list *labels); 1102 virtual void print(void) const; 1103 1104 virtual ir_rvalue *hir(exec_list *instructions, 1105 struct _mesa_glsl_parse_state *state); 1106 1107 ast_case_label_list *labels; 1108 1109 /** 1110 * A list of statements. 1111 */ 1112 exec_list stmts; 1113}; 1114 1115 1116class ast_case_statement_list : public ast_node { 1117public: 1118 ast_case_statement_list(void); 1119 virtual void print(void) const; 1120 1121 virtual ir_rvalue *hir(exec_list *instructions, 1122 struct _mesa_glsl_parse_state *state); 1123 1124 /** 1125 * A list of cases. 1126 */ 1127 exec_list cases; 1128}; 1129 1130 1131class ast_switch_body : public ast_node { 1132public: 1133 ast_switch_body(ast_case_statement_list *stmts); 1134 virtual void print(void) const; 1135 1136 virtual ir_rvalue *hir(exec_list *instructions, 1137 struct _mesa_glsl_parse_state *state); 1138 1139 ast_case_statement_list *stmts; 1140}; 1141 1142 1143class ast_selection_statement : public ast_node { 1144public: 1145 ast_selection_statement(ast_expression *condition, 1146 ast_node *then_statement, 1147 ast_node *else_statement); 1148 virtual void print(void) const; 1149 1150 virtual ir_rvalue *hir(exec_list *instructions, 1151 struct _mesa_glsl_parse_state *state); 1152 1153 ast_expression *condition; 1154 ast_node *then_statement; 1155 ast_node *else_statement; 1156}; 1157 1158 1159class ast_switch_statement : public ast_node { 1160public: 1161 ast_switch_statement(ast_expression *test_expression, 1162 ast_node *body); 1163 virtual void print(void) const; 1164 1165 virtual ir_rvalue *hir(exec_list *instructions, 1166 struct _mesa_glsl_parse_state *state); 1167 1168 ast_expression *test_expression; 1169 ast_node *body; 1170 1171protected: 1172 void test_to_hir(exec_list *, struct _mesa_glsl_parse_state *); 1173 void eval_test_expression(exec_list *instructions, 1174 struct _mesa_glsl_parse_state *state); 1175 ir_rvalue *test_val; 1176}; 1177 1178class ast_iteration_statement : public ast_node { 1179public: 1180 ast_iteration_statement(int mode, ast_node *init, ast_node *condition, 1181 ast_expression *rest_expression, ast_node *body); 1182 1183 virtual void print(void) const; 1184 1185 virtual ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *); 1186 1187 enum ast_iteration_modes { 1188 ast_for, 1189 ast_while, 1190 ast_do_while 1191 } mode; 1192 1193 1194 ast_node *init_statement; 1195 ast_node *condition; 1196 ast_expression *rest_expression; 1197 1198 exec_list rest_instructions; 1199 1200 ast_node *body; 1201 1202 /** 1203 * Generate IR from the condition of a loop 1204 * 1205 * This is factored out of ::hir because some loops have the condition 1206 * test at the top (for and while), and others have it at the end (do-while). 1207 */ 1208 void condition_to_hir(exec_list *, struct _mesa_glsl_parse_state *); 1209}; 1210 1211 1212class ast_jump_statement : public ast_node { 1213public: 1214 ast_jump_statement(int mode, ast_expression *return_value); 1215 virtual void print(void) const; 1216 1217 virtual ir_rvalue *hir(exec_list *instructions, 1218 struct _mesa_glsl_parse_state *state); 1219 1220 enum ast_jump_modes { 1221 ast_continue, 1222 ast_break, 1223 ast_return, 1224 ast_discard 1225 } mode; 1226 1227 ast_expression *opt_return_value; 1228}; 1229 1230 1231class ast_demote_statement : public ast_node { 1232public: 1233 ast_demote_statement(void) {} 1234 virtual void print(void) const; 1235 1236 virtual ir_rvalue *hir(exec_list *instructions, 1237 struct _mesa_glsl_parse_state *state); 1238}; 1239 1240 1241class ast_function_definition : public ast_node { 1242public: 1243 ast_function_definition() : prototype(NULL), body(NULL) 1244 { 1245 } 1246 1247 virtual void print(void) const; 1248 1249 virtual ir_rvalue *hir(exec_list *instructions, 1250 struct _mesa_glsl_parse_state *state); 1251 1252 ast_function *prototype; 1253 ast_compound_statement *body; 1254}; 1255 1256class ast_interface_block : public ast_node { 1257public: 1258 ast_interface_block(const char *instance_name, 1259 ast_array_specifier *array_specifier) 1260 : block_name(NULL), instance_name(instance_name), 1261 array_specifier(array_specifier) 1262 { 1263 } 1264 1265 virtual ir_rvalue *hir(exec_list *instructions, 1266 struct _mesa_glsl_parse_state *state); 1267 1268 ast_type_qualifier default_layout; 1269 ast_type_qualifier layout; 1270 const char *block_name; 1271 1272 /** 1273 * Declared name of the block instance, if specified. 1274 * 1275 * If the block does not have an instance name, this field will be 1276 * \c NULL. 1277 */ 1278 const char *instance_name; 1279 1280 /** List of ast_declarator_list * */ 1281 exec_list declarations; 1282 1283 /** 1284 * Declared array size of the block instance 1285 * 1286 * If the block is not declared as an array or if the block instance array 1287 * is unsized, this field will be \c NULL. 1288 */ 1289 ast_array_specifier *array_specifier; 1290}; 1291 1292 1293/** 1294 * AST node representing a declaration of the output layout for tessellation 1295 * control shaders. 1296 */ 1297class ast_tcs_output_layout : public ast_node 1298{ 1299public: 1300 ast_tcs_output_layout(const struct YYLTYPE &locp) 1301 { 1302 set_location(locp); 1303 } 1304 1305 virtual ir_rvalue *hir(exec_list *instructions, 1306 struct _mesa_glsl_parse_state *state); 1307}; 1308 1309 1310/** 1311 * AST node representing a declaration of the input layout for geometry 1312 * shaders. 1313 */ 1314class ast_gs_input_layout : public ast_node 1315{ 1316public: 1317 ast_gs_input_layout(const struct YYLTYPE &locp, GLenum prim_type) 1318 : prim_type(prim_type) 1319 { 1320 set_location(locp); 1321 } 1322 1323 virtual ir_rvalue *hir(exec_list *instructions, 1324 struct _mesa_glsl_parse_state *state); 1325 1326private: 1327 const GLenum prim_type; 1328}; 1329 1330 1331/** 1332 * AST node representing a decalaration of the input layout for compute 1333 * shaders. 1334 */ 1335class ast_cs_input_layout : public ast_node 1336{ 1337public: 1338 ast_cs_input_layout(const struct YYLTYPE &locp, 1339 ast_layout_expression *const *local_size) 1340 { 1341 for (int i = 0; i < 3; i++) { 1342 this->local_size[i] = local_size[i]; 1343 } 1344 set_location(locp); 1345 } 1346 1347 virtual ir_rvalue *hir(exec_list *instructions, 1348 struct _mesa_glsl_parse_state *state); 1349 1350private: 1351 ast_layout_expression *local_size[3]; 1352}; 1353 1354class ast_warnings_toggle : public ast_node { 1355public: 1356 ast_warnings_toggle(bool _enable) 1357 : enable(_enable) 1358 { 1359 /* empty */ 1360 } 1361 1362 virtual ir_rvalue *hir(exec_list *instructions, 1363 struct _mesa_glsl_parse_state *state); 1364 1365private: 1366 bool enable; 1367}; 1368/*@}*/ 1369 1370extern void 1371_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state); 1372 1373extern ir_rvalue * 1374_mesa_ast_field_selection_to_hir(const ast_expression *expr, 1375 exec_list *instructions, 1376 struct _mesa_glsl_parse_state *state); 1377 1378extern ir_rvalue * 1379_mesa_ast_array_index_to_hir(void *mem_ctx, 1380 struct _mesa_glsl_parse_state *state, 1381 ir_rvalue *array, ir_rvalue *idx, 1382 YYLTYPE &loc, YYLTYPE &idx_loc); 1383 1384extern void 1385_mesa_ast_set_aggregate_type(const glsl_type *type, 1386 ast_expression *expr); 1387 1388void 1389emit_function(_mesa_glsl_parse_state *state, ir_function *f); 1390 1391extern void 1392check_builtin_array_max_size(const char *name, unsigned size, 1393 YYLTYPE loc, struct _mesa_glsl_parse_state *state); 1394 1395extern void _mesa_ast_process_interface_block(YYLTYPE *locp, 1396 _mesa_glsl_parse_state *state, 1397 ast_interface_block *const block, 1398 const struct ast_type_qualifier &q); 1399 1400extern bool 1401process_qualifier_constant(struct _mesa_glsl_parse_state *state, 1402 YYLTYPE *loc, 1403 const char *qual_indentifier, 1404 ast_expression *const_expression, 1405 unsigned *value); 1406#endif /* AST_H */ 1407