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