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