• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     /* Callers of this ralloc-based new need not call delete. It's
53      * easier to just ralloc_free 'ctx' (or any of its ancestors). */
new(size_t size,void * ctx)54     static void* operator new(size_t size, void *ctx)
55     {
56        void *node;
57  
58        node = rzalloc_size(ctx, size);
59        assert(node != NULL);
60  
61        return node;
62     }
63  
64     /* If the user *does* call delete, that's OK, we will just
65      * ralloc_free in that case. */
delete(void * table)66     static void operator delete(void *table)
67     {
68        ralloc_free(table);
69     }
70  
71     /**
72      * Print an AST node in something approximating the original GLSL code
73      */
74     virtual void print(void) const;
75  
76     /**
77      * Convert the AST node to the high-level intermediate representation
78      */
79     virtual ir_rvalue *hir(exec_list *instructions,
80  			  struct _mesa_glsl_parse_state *state);
81  
82     /**
83      * Retrieve the source location of an AST node
84      *
85      * This function is primarily used to get the source position of an AST node
86      * into a form that can be passed to \c _mesa_glsl_error.
87      *
88      * \sa _mesa_glsl_error, ast_node::set_location
89      */
get_location(void)90     struct YYLTYPE get_location(void) const
91     {
92        struct YYLTYPE locp;
93  
94        locp.source = this->location.source;
95        locp.first_line = this->location.line;
96        locp.first_column = this->location.column;
97        locp.last_line = locp.first_line;
98        locp.last_column = locp.first_column;
99  
100        return locp;
101     }
102  
103     /**
104      * Set the source location of an AST node from a parser location
105      *
106      * \sa ast_node::get_location
107      */
set_location(const struct YYLTYPE & locp)108     void set_location(const struct YYLTYPE &locp)
109     {
110        this->location.source = locp.source;
111        this->location.line = locp.first_line;
112        this->location.column = locp.first_column;
113     }
114  
115     /**
116      * Source location of the AST node.
117      */
118     struct {
119        unsigned source;    /**< GLSL source number. */
120        unsigned line;      /**< Line number within the source string. */
121        unsigned column;    /**< Column in the line. */
122     } location;
123  
124     exec_node link;
125  
126  protected:
127     /**
128      * The only constructor is protected so that only derived class objects can
129      * be created.
130      */
131     ast_node(void);
132  };
133  
134  
135  /**
136   * Operators for AST expression nodes.
137   */
138  enum ast_operators {
139     ast_assign,
140     ast_plus,        /**< Unary + operator. */
141     ast_neg,
142     ast_add,
143     ast_sub,
144     ast_mul,
145     ast_div,
146     ast_mod,
147     ast_lshift,
148     ast_rshift,
149     ast_less,
150     ast_greater,
151     ast_lequal,
152     ast_gequal,
153     ast_equal,
154     ast_nequal,
155     ast_bit_and,
156     ast_bit_xor,
157     ast_bit_or,
158     ast_bit_not,
159     ast_logic_and,
160     ast_logic_xor,
161     ast_logic_or,
162     ast_logic_not,
163  
164     ast_mul_assign,
165     ast_div_assign,
166     ast_mod_assign,
167     ast_add_assign,
168     ast_sub_assign,
169     ast_ls_assign,
170     ast_rs_assign,
171     ast_and_assign,
172     ast_xor_assign,
173     ast_or_assign,
174  
175     ast_conditional,
176  
177     ast_pre_inc,
178     ast_pre_dec,
179     ast_post_inc,
180     ast_post_dec,
181     ast_field_selection,
182     ast_array_index,
183  
184     ast_function_call,
185  
186     ast_identifier,
187     ast_int_constant,
188     ast_uint_constant,
189     ast_float_constant,
190     ast_bool_constant,
191  
192     ast_sequence
193  };
194  
195  /**
196   * Representation of any sort of expression.
197   */
198  class ast_expression : public ast_node {
199  public:
200     ast_expression(int oper, ast_expression *,
201  		  ast_expression *, ast_expression *);
202  
ast_expression(const char * identifier)203     ast_expression(const char *identifier) :
204        oper(ast_identifier)
205     {
206        subexpressions[0] = NULL;
207        subexpressions[1] = NULL;
208        subexpressions[2] = NULL;
209        primary_expression.identifier = identifier;
210        this->non_lvalue_description = NULL;
211     }
212  
213     static const char *operator_string(enum ast_operators op);
214  
215     virtual ir_rvalue *hir(exec_list *instructions,
216  			  struct _mesa_glsl_parse_state *state);
217  
218     virtual void print(void) const;
219  
220     enum ast_operators oper;
221  
222     ast_expression *subexpressions[3];
223  
224     union {
225        const char *identifier;
226        int int_constant;
227        float float_constant;
228        unsigned uint_constant;
229        int bool_constant;
230     } primary_expression;
231  
232  
233     /**
234      * List of expressions for an \c ast_sequence or parameters for an
235      * \c ast_function_call
236      */
237     exec_list expressions;
238  
239     /**
240      * For things that can't be l-values, this describes what it is.
241      *
242      * This text is used by the code that generates IR for assignments to
243      * detect and emit useful messages for assignments to some things that
244      * can't be l-values.  For example, pre- or post-incerement expressions.
245      *
246      * \note
247      * This pointer may be \c NULL.
248      */
249     const char *non_lvalue_description;
250  };
251  
252  class ast_expression_bin : public ast_expression {
253  public:
254     ast_expression_bin(int oper, ast_expression *, ast_expression *);
255  
256     virtual void print(void) const;
257  };
258  
259  /**
260   * Subclass of expressions for function calls
261   */
262  class ast_function_expression : public ast_expression {
263  public:
ast_function_expression(ast_expression * callee)264     ast_function_expression(ast_expression *callee)
265        : ast_expression(ast_function_call, callee,
266  		       NULL, NULL),
267  	cons(false)
268     {
269        /* empty */
270     }
271  
ast_function_expression(class ast_type_specifier * type)272     ast_function_expression(class ast_type_specifier *type)
273        : ast_expression(ast_function_call, (ast_expression *) type,
274  		       NULL, NULL),
275  	cons(true)
276     {
277        /* empty */
278     }
279  
is_constructor()280     bool is_constructor() const
281     {
282        return cons;
283     }
284  
285     virtual ir_rvalue *hir(exec_list *instructions,
286  			  struct _mesa_glsl_parse_state *state);
287  
288  private:
289     /**
290      * Is this function call actually a constructor?
291      */
292     bool cons;
293  };
294  
295  
296  /**
297   * Number of possible operators for an ast_expression
298   *
299   * This is done as a define instead of as an additional value in the enum so
300   * that the compiler won't generate spurious messages like "warning:
301   * enumeration value ‘ast_num_operators’ not handled in switch"
302   */
303  #define AST_NUM_OPERATORS (ast_sequence + 1)
304  
305  
306  class ast_compound_statement : public ast_node {
307  public:
308     ast_compound_statement(int new_scope, ast_node *statements);
309     virtual void print(void) const;
310  
311     virtual ir_rvalue *hir(exec_list *instructions,
312  			  struct _mesa_glsl_parse_state *state);
313  
314     int new_scope;
315     exec_list statements;
316  };
317  
318  class ast_declaration : public ast_node {
319  public:
320     ast_declaration(const char *identifier, int is_array, ast_expression *array_size,
321  		   ast_expression *initializer);
322     virtual void print(void) const;
323  
324     const char *identifier;
325  
326     int is_array;
327     ast_expression *array_size;
328  
329     ast_expression *initializer;
330  };
331  
332  
333  enum {
334     ast_precision_none = 0, /**< Absence of precision qualifier. */
335     ast_precision_high,
336     ast_precision_medium,
337     ast_precision_low
338  };
339  
340  struct ast_type_qualifier {
341     /* Callers of this ralloc-based new need not call delete. It's
342      * easier to just ralloc_free 'ctx' (or any of its ancestors). */
newast_type_qualifier343     static void* operator new(size_t size, void *ctx)
344     {
345        void *node;
346  
347        node = rzalloc_size(ctx, size);
348        assert(node != NULL);
349  
350        return node;
351     }
352  
353     /* If the user *does* call delete, that's OK, we will just
354      * ralloc_free in that case. */
deleteast_type_qualifier355     static void operator delete(void *table)
356     {
357        ralloc_free(table);
358     }
359  
360     union {
361        struct {
362  	 unsigned invariant:1;
363  	 unsigned constant:1;
364  	 unsigned attribute:1;
365  	 unsigned varying:1;
366  	 unsigned in:1;
367  	 unsigned out:1;
368  	 unsigned centroid:1;
369  	 unsigned uniform:1;
370  	 unsigned smooth:1;
371  	 unsigned flat:1;
372  	 unsigned noperspective:1;
373  
374  	 /** \name Layout qualifiers for GL_ARB_fragment_coord_conventions */
375  	 /*@{*/
376  	 unsigned origin_upper_left:1;
377  	 unsigned pixel_center_integer:1;
378  	 /*@}*/
379  
380  	 /**
381  	  * Flag set if GL_ARB_explicit_attrib_location "location" layout
382  	  * qualifier is used.
383  	  */
384  	 unsigned explicit_location:1;
385  	 /**
386  	  * Flag set if GL_ARB_explicit_attrib_location "index" layout
387  	  * qualifier is used.
388  	  */
389  	 unsigned explicit_index:1;
390  
391           /** \name Layout qualifiers for GL_AMD_conservative_depth */
392           /** \{ */
393           unsigned depth_any:1;
394           unsigned depth_greater:1;
395           unsigned depth_less:1;
396           unsigned depth_unchanged:1;
397           /** \} */
398  
399  	 /** \name Layout qualifiers for GL_ARB_uniform_buffer_object */
400  	 /** \{ */
401           unsigned std140:1;
402           unsigned shared:1;
403           unsigned packed:1;
404           unsigned column_major:1;
405           unsigned row_major:1;
406  	 /** \} */
407        }
408        /** \brief Set of flags, accessed by name. */
409        q;
410  
411        /** \brief Set of flags, accessed as a bitmask. */
412        unsigned i;
413     } flags;
414  
415     /**
416      * Location specified via GL_ARB_explicit_attrib_location layout
417      *
418      * \note
419      * This field is only valid if \c explicit_location is set.
420      */
421     int location;
422     /**
423      * Index specified via GL_ARB_explicit_attrib_location layout
424      *
425      * \note
426      * This field is only valid if \c explicit_index is set.
427      */
428     int index;
429  
430     /**
431      * Return true if and only if an interpolation qualifier is present.
432      */
433     bool has_interpolation() const;
434  
435     /**
436      * \brief Return string representation of interpolation qualifier.
437      *
438      * If an interpolation qualifier is present, then return that qualifier's
439      * string representation. Otherwise, return null. For example, if the
440      * noperspective bit is set, then this returns "noperspective".
441      *
442      * If multiple interpolation qualifiers are somehow present, then the
443      * returned string is undefined but not null.
444      */
445     const char *interpolation_string() const;
446  
447     bool merge_qualifier(YYLTYPE *loc,
448  			_mesa_glsl_parse_state *state,
449  			ast_type_qualifier q);
450  };
451  
452  class ast_declarator_list;
453  
454  class ast_struct_specifier : public ast_node {
455  public:
456     ast_struct_specifier(const char *identifier,
457  			ast_declarator_list *declarator_list);
458     virtual void print(void) const;
459  
460     virtual ir_rvalue *hir(exec_list *instructions,
461  			  struct _mesa_glsl_parse_state *state);
462  
463     const char *name;
464     /* List of ast_declarator_list * */
465     exec_list declarations;
466  };
467  
468  
469  
470  class ast_type_specifier : public ast_node {
471  public:
472     /** Construct a type specifier from a type name */
ast_type_specifier(const char * name)473     ast_type_specifier(const char *name)
474        : type_name(name), structure(NULL),
475  	is_array(false), array_size(NULL), precision(ast_precision_none),
476  	is_precision_statement(false)
477     {
478        /* empty */
479     }
480  
481     /** Construct a type specifier from a structure definition */
ast_type_specifier(ast_struct_specifier * s)482     ast_type_specifier(ast_struct_specifier *s)
483        : type_name(s->name), structure(s),
484  	is_array(false), array_size(NULL), precision(ast_precision_none),
485  	is_precision_statement(false)
486     {
487        /* empty */
488     }
489  
490     const struct glsl_type *glsl_type(const char **name,
491  				     struct _mesa_glsl_parse_state *state)
492        const;
493  
494     virtual void print(void) const;
495  
496     ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *);
497  
498     const char *type_name;
499     ast_struct_specifier *structure;
500  
501     int is_array;
502     ast_expression *array_size;
503  
504     unsigned precision:2;
505  
506     bool is_precision_statement;
507  };
508  
509  
510  class ast_fully_specified_type : public ast_node {
511  public:
512     virtual void print(void) const;
513     bool has_qualifiers() const;
514  
515     ast_type_qualifier qualifier;
516     ast_type_specifier *specifier;
517  };
518  
519  
520  class ast_declarator_list : public ast_node {
521  public:
522     ast_declarator_list(ast_fully_specified_type *);
523     virtual void print(void) const;
524  
525     virtual ir_rvalue *hir(exec_list *instructions,
526  			  struct _mesa_glsl_parse_state *state);
527  
528     ast_fully_specified_type *type;
529     exec_list declarations;
530  
531     /**
532      * Special flag for vertex shader "invariant" declarations.
533      *
534      * Vertex shaders can contain "invariant" variable redeclarations that do
535      * not include a type.  For example, "invariant gl_Position;".  This flag
536      * is used to note these cases when no type is specified.
537      */
538     int invariant;
539  
540     /**
541      * Flag indicating that these declarators are in a uniform block,
542      * allowing UBO type qualifiers.
543      */
544     bool ubo_qualifiers_valid;
545  };
546  
547  
548  class ast_parameter_declarator : public ast_node {
549  public:
ast_parameter_declarator()550     ast_parameter_declarator()
551     {
552        this->identifier = NULL;
553        this->is_array = false;
554        this->array_size = 0;
555     }
556  
557     virtual void print(void) const;
558  
559     virtual ir_rvalue *hir(exec_list *instructions,
560  			  struct _mesa_glsl_parse_state *state);
561  
562     ast_fully_specified_type *type;
563     const char *identifier;
564     int is_array;
565     ast_expression *array_size;
566  
567     static void parameters_to_hir(exec_list *ast_parameters,
568  				 bool formal, exec_list *ir_parameters,
569  				 struct _mesa_glsl_parse_state *state);
570  
571  private:
572     /** Is this parameter declaration part of a formal parameter list? */
573     bool formal_parameter;
574  
575     /**
576      * Is this parameter 'void' type?
577      *
578      * This field is set by \c ::hir.
579      */
580     bool is_void;
581  };
582  
583  
584  class ast_function : public ast_node {
585  public:
586     ast_function(void);
587  
588     virtual void print(void) const;
589  
590     virtual ir_rvalue *hir(exec_list *instructions,
591  			  struct _mesa_glsl_parse_state *state);
592  
593     ast_fully_specified_type *return_type;
594     const char *identifier;
595  
596     exec_list parameters;
597  
598  private:
599     /**
600      * Is this prototype part of the function definition?
601      *
602      * Used by ast_function_definition::hir to process the parameters, etc.
603      * of the function.
604      *
605      * \sa ::hir
606      */
607     bool is_definition;
608  
609     /**
610      * Function signature corresponding to this function prototype instance
611      *
612      * Used by ast_function_definition::hir to process the parameters, etc.
613      * of the function.
614      *
615      * \sa ::hir
616      */
617     class ir_function_signature *signature;
618  
619     friend class ast_function_definition;
620  };
621  
622  
623  class ast_expression_statement : public ast_node {
624  public:
625     ast_expression_statement(ast_expression *);
626     virtual void print(void) const;
627  
628     virtual ir_rvalue *hir(exec_list *instructions,
629  			  struct _mesa_glsl_parse_state *state);
630  
631     ast_expression *expression;
632  };
633  
634  
635  class ast_case_label : public ast_node {
636  public:
637     ast_case_label(ast_expression *test_value);
638     virtual void print(void) const;
639  
640     virtual ir_rvalue *hir(exec_list *instructions,
641  			  struct _mesa_glsl_parse_state *state);
642  
643     /**
644      * An test value of NULL means 'default'.
645      */
646     ast_expression *test_value;
647  };
648  
649  
650  class ast_case_label_list : public ast_node {
651  public:
652     ast_case_label_list(void);
653     virtual void print(void) const;
654  
655     virtual ir_rvalue *hir(exec_list *instructions,
656  			  struct _mesa_glsl_parse_state *state);
657  
658     /**
659      * A list of case labels.
660      */
661     exec_list labels;
662  };
663  
664  
665  class ast_case_statement : public ast_node {
666  public:
667     ast_case_statement(ast_case_label_list *labels);
668     virtual void print(void) const;
669  
670     virtual ir_rvalue *hir(exec_list *instructions,
671  			  struct _mesa_glsl_parse_state *state);
672  
673     ast_case_label_list *labels;
674  
675     /**
676      * A list of statements.
677      */
678     exec_list stmts;
679  };
680  
681  
682  class ast_case_statement_list : public ast_node {
683  public:
684     ast_case_statement_list(void);
685     virtual void print(void) const;
686  
687     virtual ir_rvalue *hir(exec_list *instructions,
688  			  struct _mesa_glsl_parse_state *state);
689  
690     /**
691      * A list of cases.
692      */
693     exec_list cases;
694  };
695  
696  
697  class ast_switch_body : public ast_node {
698  public:
699     ast_switch_body(ast_case_statement_list *stmts);
700     virtual void print(void) const;
701  
702     virtual ir_rvalue *hir(exec_list *instructions,
703  			  struct _mesa_glsl_parse_state *state);
704  
705     ast_case_statement_list *stmts;
706  };
707  
708  
709  class ast_selection_statement : public ast_node {
710  public:
711     ast_selection_statement(ast_expression *condition,
712  			   ast_node *then_statement,
713  			   ast_node *else_statement);
714     virtual void print(void) const;
715  
716     virtual ir_rvalue *hir(exec_list *instructions,
717  			  struct _mesa_glsl_parse_state *state);
718  
719     ast_expression *condition;
720     ast_node *then_statement;
721     ast_node *else_statement;
722  };
723  
724  
725  class ast_switch_statement : public ast_node {
726  public:
727     ast_switch_statement(ast_expression *test_expression,
728  			ast_node *body);
729     virtual void print(void) const;
730  
731     virtual ir_rvalue *hir(exec_list *instructions,
732  			  struct _mesa_glsl_parse_state *state);
733  
734     ast_expression *test_expression;
735     ast_node *body;
736  
737  protected:
738     void test_to_hir(exec_list *, struct _mesa_glsl_parse_state *);
739  };
740  
741  class ast_iteration_statement : public ast_node {
742  public:
743     ast_iteration_statement(int mode, ast_node *init, ast_node *condition,
744  			   ast_expression *rest_expression, ast_node *body);
745  
746     virtual void print(void) const;
747  
748     virtual ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *);
749  
750     enum ast_iteration_modes {
751        ast_for,
752        ast_while,
753        ast_do_while
754     } mode;
755  
756  
757     ast_node *init_statement;
758     ast_node *condition;
759     ast_expression *rest_expression;
760  
761     ast_node *body;
762  
763  private:
764     /**
765      * Generate IR from the condition of a loop
766      *
767      * This is factored out of ::hir because some loops have the condition
768      * test at the top (for and while), and others have it at the end (do-while).
769      */
770     void condition_to_hir(class ir_loop *, struct _mesa_glsl_parse_state *);
771  };
772  
773  
774  class ast_jump_statement : public ast_node {
775  public:
776     ast_jump_statement(int mode, ast_expression *return_value);
777     virtual void print(void) const;
778  
779     virtual ir_rvalue *hir(exec_list *instructions,
780  			  struct _mesa_glsl_parse_state *state);
781  
782     enum ast_jump_modes {
783        ast_continue,
784        ast_break,
785        ast_return,
786        ast_discard
787     } mode;
788  
789     ast_expression *opt_return_value;
790  };
791  
792  
793  class ast_function_definition : public ast_node {
794  public:
795     virtual void print(void) const;
796  
797     virtual ir_rvalue *hir(exec_list *instructions,
798  			  struct _mesa_glsl_parse_state *state);
799  
800     ast_function *prototype;
801     ast_compound_statement *body;
802  };
803  
804  class ast_uniform_block : public ast_node {
805  public:
ast_uniform_block(ast_type_qualifier layout,const char * block_name,ast_declarator_list * member_list)806     ast_uniform_block(ast_type_qualifier layout,
807  		     const char *block_name,
808  		     ast_declarator_list *member_list)
809     : layout(layout), block_name(block_name)
810     {
811        declarations.push_degenerate_list_at_head(&member_list->link);
812     }
813  
814     virtual ir_rvalue *hir(exec_list *instructions,
815  			  struct _mesa_glsl_parse_state *state);
816  
817     ast_type_qualifier layout;
818     const char *block_name;
819     /** List of ast_declarator_list * */
820     exec_list declarations;
821  };
822  /*@}*/
823  
824  extern void
825  _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state);
826  
827  extern ir_rvalue *
828  _mesa_ast_field_selection_to_hir(const ast_expression *expr,
829  				 exec_list *instructions,
830  				 struct _mesa_glsl_parse_state *state);
831  
832  void
833  emit_function(_mesa_glsl_parse_state *state, ir_function *f);
834  
835  #endif /* AST_H */
836