OSDN Git Service

glsl: Remove some stale comments about ir_call
[android-x86/external-mesa.git] / src / 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    /* Callers of this ralloc-based new need not call delete. It's
53     * easier to just ralloc_free 'ctx' (or any of its ancestors). */
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. */
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     */
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     */
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
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:
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
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
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). */
343    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. */
355    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 */
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 */
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:
550    ast_parameter_declarator() :
551       type(NULL),
552       identifier(NULL),
553       is_array(false),
554       array_size(NULL),
555       formal_parameter(false),
556       is_void(false)
557    {
558       /* empty */
559    }
560
561    virtual void print(void) const;
562
563    virtual ir_rvalue *hir(exec_list *instructions,
564                           struct _mesa_glsl_parse_state *state);
565
566    ast_fully_specified_type *type;
567    const char *identifier;
568    int is_array;
569    ast_expression *array_size;
570
571    static void parameters_to_hir(exec_list *ast_parameters,
572                                  bool formal, exec_list *ir_parameters,
573                                  struct _mesa_glsl_parse_state *state);
574
575 private:
576    /** Is this parameter declaration part of a formal parameter list? */
577    bool formal_parameter;
578
579    /**
580     * Is this parameter 'void' type?
581     *
582     * This field is set by \c ::hir.
583     */
584    bool is_void;
585 };
586
587
588 class ast_function : public ast_node {
589 public:
590    ast_function(void);
591
592    virtual void print(void) const;
593
594    virtual ir_rvalue *hir(exec_list *instructions,
595                           struct _mesa_glsl_parse_state *state);
596
597    ast_fully_specified_type *return_type;
598    const char *identifier;
599
600    exec_list parameters;
601
602 private:
603    /**
604     * Is this prototype part of the function definition?
605     *
606     * Used by ast_function_definition::hir to process the parameters, etc.
607     * of the function.
608     *
609     * \sa ::hir
610     */
611    bool is_definition;
612
613    /**
614     * Function signature corresponding to this function prototype instance
615     *
616     * Used by ast_function_definition::hir to process the parameters, etc.
617     * of the function.
618     *
619     * \sa ::hir
620     */
621    class ir_function_signature *signature;
622
623    friend class ast_function_definition;
624 };
625
626
627 class ast_expression_statement : public ast_node {
628 public:
629    ast_expression_statement(ast_expression *);
630    virtual void print(void) const;
631
632    virtual ir_rvalue *hir(exec_list *instructions,
633                           struct _mesa_glsl_parse_state *state);
634
635    ast_expression *expression;
636 };
637
638
639 class ast_case_label : public ast_node {
640 public:
641    ast_case_label(ast_expression *test_value);
642    virtual void print(void) const;
643
644    virtual ir_rvalue *hir(exec_list *instructions,
645                           struct _mesa_glsl_parse_state *state);
646
647    /**
648     * An test value of NULL means 'default'.
649     */
650    ast_expression *test_value;
651 };
652
653
654 class ast_case_label_list : public ast_node {
655 public:
656    ast_case_label_list(void);
657    virtual void print(void) const;
658
659    virtual ir_rvalue *hir(exec_list *instructions,
660                           struct _mesa_glsl_parse_state *state);
661
662    /**
663     * A list of case labels.
664     */
665    exec_list labels;
666 };
667
668
669 class ast_case_statement : public ast_node {
670 public:
671    ast_case_statement(ast_case_label_list *labels);
672    virtual void print(void) const;
673
674    virtual ir_rvalue *hir(exec_list *instructions,
675                           struct _mesa_glsl_parse_state *state);
676
677    ast_case_label_list *labels;
678
679    /**
680     * A list of statements.
681     */
682    exec_list stmts;
683 };
684
685
686 class ast_case_statement_list : public ast_node {
687 public:
688    ast_case_statement_list(void);
689    virtual void print(void) const;
690
691    virtual ir_rvalue *hir(exec_list *instructions,
692                           struct _mesa_glsl_parse_state *state);
693
694    /**
695     * A list of cases.
696     */
697    exec_list cases;
698 };
699
700
701 class ast_switch_body : public ast_node {
702 public:
703    ast_switch_body(ast_case_statement_list *stmts);
704    virtual void print(void) const;
705
706    virtual ir_rvalue *hir(exec_list *instructions,
707                           struct _mesa_glsl_parse_state *state);
708
709    ast_case_statement_list *stmts;
710 };
711
712
713 class ast_selection_statement : public ast_node {
714 public:
715    ast_selection_statement(ast_expression *condition,
716                            ast_node *then_statement,
717                            ast_node *else_statement);
718    virtual void print(void) const;
719
720    virtual ir_rvalue *hir(exec_list *instructions,
721                           struct _mesa_glsl_parse_state *state);
722
723    ast_expression *condition;
724    ast_node *then_statement;
725    ast_node *else_statement;
726 };
727
728
729 class ast_switch_statement : public ast_node {
730 public:
731    ast_switch_statement(ast_expression *test_expression,
732                         ast_node *body);
733    virtual void print(void) const;
734
735    virtual ir_rvalue *hir(exec_list *instructions,
736                           struct _mesa_glsl_parse_state *state);
737
738    ast_expression *test_expression;
739    ast_node *body;
740
741 protected:
742    void test_to_hir(exec_list *, struct _mesa_glsl_parse_state *);
743 };
744
745 class ast_iteration_statement : public ast_node {
746 public:
747    ast_iteration_statement(int mode, ast_node *init, ast_node *condition,
748                            ast_expression *rest_expression, ast_node *body);
749
750    virtual void print(void) const;
751
752    virtual ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *);
753
754    enum ast_iteration_modes {
755       ast_for,
756       ast_while,
757       ast_do_while
758    } mode;
759    
760
761    ast_node *init_statement;
762    ast_node *condition;
763    ast_expression *rest_expression;
764
765    ast_node *body;
766
767 private:
768    /**
769     * Generate IR from the condition of a loop
770     *
771     * This is factored out of ::hir because some loops have the condition
772     * test at the top (for and while), and others have it at the end (do-while).
773     */
774    void condition_to_hir(class ir_loop *, struct _mesa_glsl_parse_state *);
775 };
776
777
778 class ast_jump_statement : public ast_node {
779 public:
780    ast_jump_statement(int mode, ast_expression *return_value);
781    virtual void print(void) const;
782
783    virtual ir_rvalue *hir(exec_list *instructions,
784                           struct _mesa_glsl_parse_state *state);
785
786    enum ast_jump_modes {
787       ast_continue,
788       ast_break,
789       ast_return,
790       ast_discard
791    } mode;
792
793    ast_expression *opt_return_value;
794 };
795
796
797 class ast_function_definition : public ast_node {
798 public:
799    virtual void print(void) const;
800
801    virtual ir_rvalue *hir(exec_list *instructions,
802                           struct _mesa_glsl_parse_state *state);
803
804    ast_function *prototype;
805    ast_compound_statement *body;
806 };
807
808 class ast_uniform_block : public ast_node {
809 public:
810    ast_uniform_block(ast_type_qualifier layout,
811                      const char *instance_name,
812                      ast_expression *array_size)
813    : layout(layout), block_name(NULL), instance_name(instance_name),
814      array_size(array_size)
815    {
816       /* empty */
817    }
818
819    virtual ir_rvalue *hir(exec_list *instructions,
820                           struct _mesa_glsl_parse_state *state);
821
822    ast_type_qualifier layout;
823    const char *block_name;
824
825    /**
826     * Declared name of the block instance, if specified.
827     *
828     * If the block does not have an instance name, this field will be
829     * \c NULL.
830     */
831    const char *instance_name;
832
833    /** List of ast_declarator_list * */
834    exec_list declarations;
835
836    /**
837     * Declared array size of the block instance
838     *
839     * If the block is not declared as an array, this field will be \c NULL.
840     *
841     * \note
842     * A block can only be an array if it also has an instance name.  If this
843     * field is not \c NULL, ::instance_name must also not be \c NULL.
844     */
845    ast_expression *array_size;
846 };
847 /*@}*/
848
849 extern void
850 _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state);
851
852 extern ir_rvalue *
853 _mesa_ast_field_selection_to_hir(const ast_expression *expr,
854                                  exec_list *instructions,
855                                  struct _mesa_glsl_parse_state *state);
856
857 extern ir_rvalue *
858 _mesa_ast_array_index_to_hir(void *mem_ctx,
859                              struct _mesa_glsl_parse_state *state,
860                              ir_rvalue *array, ir_rvalue *idx,
861                              YYLTYPE &loc, YYLTYPE &idx_loc);
862
863 void
864 emit_function(_mesa_glsl_parse_state *state, ir_function *f);
865
866 extern void
867 check_builtin_array_max_size(const char *name, unsigned size,
868                              YYLTYPE loc, struct _mesa_glsl_parse_state *state);
869
870 #endif /* AST_H */