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