"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/ir.h" (16 Sep 2020, 73981 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "ir.h" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 20.1.5_vs_20.2.0-rc1.

    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     */
  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 
  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 
  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 
  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:
  205    ir_instruction(enum ir_node_type t)
  206       : ir_type(t)
  207    {
  208    }
  209 
  210 private:
  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 
  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     */
  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     */
  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     */
  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 
  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     */
  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     */
  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     */
  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     */
  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     */
  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     */
  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     */
  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 
  548    const glsl_type *get_interface_type() const
  549    {
  550       return this->interface_type;
  551    }
  552 
  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     */
  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 
  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 
  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 
  583    inline ir_state_slot *get_state_slots()
  584    {
  585       return this->is_interface_instance() ? NULL : this->u.state_slots;
  586    }
  587 
  588    inline const ir_state_slot *get_state_slots() const
  589    {
  590       return this->is_interface_instance() ? NULL : this->u.state_slots;
  591    }
  592 
  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 
  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 
  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 this variable a generic output or input that has not yet been matched
  763        * up to a variable in another stage of the pipeline?
  764        *
  765        * This is used by the linker as scratch storage while assigning locations
  766        * to generic inputs and outputs.
  767        */
  768       unsigned is_unmatched_generic_inout:1;
  769 
  770       /**
  771        * Is this varying used by transform feedback?
  772        *
  773        * This is used by the linker to decide if it's safe to pack the varying.
  774        */
  775       unsigned is_xfb:1;
  776 
  777       /**
  778        * Is this varying used only by transform feedback?
  779        *
  780        * This is used by the linker to decide if its safe to pack the varying.
  781        */
  782       unsigned is_xfb_only:1;
  783 
  784       /**
  785        * Was a transform feedback buffer set in the shader?
  786        */
  787       unsigned explicit_xfb_buffer:1;
  788 
  789       /**
  790        * Was a transform feedback offset set in the shader?
  791        */
  792       unsigned explicit_xfb_offset:1;
  793 
  794       /**
  795        * Was a transform feedback stride set in the shader?
  796        */
  797       unsigned explicit_xfb_stride:1;
  798 
  799       /**
  800        * If non-zero, then this variable may be packed along with other variables
  801        * into a single varying slot, so this offset should be applied when
  802        * accessing components.  For example, an offset of 1 means that the x
  803        * component of this variable is actually stored in component y of the
  804        * location specified by \c location.
  805        */
  806       unsigned location_frac:2;
  807 
  808       /**
  809        * Layout of the matrix.  Uses glsl_matrix_layout values.
  810        */
  811       unsigned matrix_layout:2;
  812 
  813       /**
  814        * Non-zero if this variable was created by lowering a named interface
  815        * block.
  816        */
  817       unsigned from_named_ifc_block:1;
  818 
  819       /**
  820        * Non-zero if the variable must be a shader input. This is useful for
  821        * constraints on function parameters.
  822        */
  823       unsigned must_be_shader_input:1;
  824 
  825       /**
  826        * Output index for dual source blending.
  827        *
  828        * \note
  829        * The GLSL spec only allows the values 0 or 1 for the index in \b dual
  830        * source blending.
  831        */
  832       unsigned index:1;
  833 
  834       /**
  835        * Precision qualifier.
  836        *
  837        * In desktop GLSL we do not care about precision qualifiers at all, in
  838        * fact, the spec says that precision qualifiers are ignored.
  839        *
  840        * To make things easy, we make it so that this field is always
  841        * GLSL_PRECISION_NONE on desktop shaders. This way all the variables
  842        * have the same precision value and the checks we add in the compiler
  843        * for this field will never break a desktop shader compile.
  844        */
  845       unsigned precision:2;
  846 
  847       /**
  848        * \brief Layout qualifier for gl_FragDepth.
  849        *
  850        * This is not equal to \c ir_depth_layout_none if and only if this
  851        * variable is \c gl_FragDepth and a layout qualifier is specified.
  852        */
  853       ir_depth_layout depth_layout:3;
  854 
  855       /**
  856        * Memory qualifiers.
  857        */
  858       unsigned memory_read_only:1; /**< "readonly" qualifier. */
  859       unsigned memory_write_only:1; /**< "writeonly" qualifier. */
  860       unsigned memory_coherent:1;
  861       unsigned memory_volatile:1;
  862       unsigned memory_restrict:1;
  863 
  864       /**
  865        * ARB_shader_storage_buffer_object
  866        */
  867       unsigned from_ssbo_unsized_array:1; /**< unsized array buffer variable. */
  868 
  869       unsigned implicit_sized_array:1;
  870 
  871       /**
  872        * Whether this is a fragment shader output implicitly initialized with
  873        * the previous contents of the specified render target at the
  874        * framebuffer location corresponding to this shader invocation.
  875        */
  876       unsigned fb_fetch_output:1;
  877 
  878       /**
  879        * Non-zero if this variable is considered bindless as defined by
  880        * ARB_bindless_texture.
  881        */
  882       unsigned bindless:1;
  883 
  884       /**
  885        * Non-zero if this variable is considered bound as defined by
  886        * ARB_bindless_texture.
  887        */
  888       unsigned bound:1;
  889 
  890       /**
  891        * Emit a warning if this variable is accessed.
  892        */
  893    private:
  894       uint8_t warn_extension_index;
  895 
  896    public:
  897       /**
  898        * Image internal format if specified explicitly, otherwise
  899        * PIPE_FORMAT_NONE.
  900        */
  901       enum pipe_format image_format;
  902 
  903    private:
  904       /**
  905        * Number of state slots used
  906        *
  907        * \note
  908        * This could be stored in as few as 7-bits, if necessary.  If it is made
  909        * smaller, add an assertion to \c ir_variable::allocate_state_slots to
  910        * be safe.
  911        */
  912       uint16_t _num_state_slots;
  913 
  914    public:
  915       /**
  916        * Initial binding point for a sampler, atomic, or UBO.
  917        *
  918        * For array types, this represents the binding point for the first element.
  919        */
  920       uint16_t binding;
  921 
  922       /**
  923        * Storage location of the base of this variable
  924        *
  925        * The precise meaning of this field depends on the nature of the variable.
  926        *
  927        *   - Vertex shader input: one of the values from \c gl_vert_attrib.
  928        *   - Vertex shader output: one of the values from \c gl_varying_slot.
  929        *   - Geometry shader input: one of the values from \c gl_varying_slot.
  930        *   - Geometry shader output: one of the values from \c gl_varying_slot.
  931        *   - Fragment shader input: one of the values from \c gl_varying_slot.
  932        *   - Fragment shader output: one of the values from \c gl_frag_result.
  933        *   - Uniforms: Per-stage uniform slot number for default uniform block.
  934        *   - Uniforms: Index within the uniform block definition for UBO members.
  935        *   - Non-UBO Uniforms: explicit location until linking then reused to
  936        *     store uniform slot number.
  937        *   - Other: This field is not currently used.
  938        *
  939        * If the variable is a uniform, shader input, or shader output, and the
  940        * slot has not been assigned, the value will be -1.
  941        */
  942       int location;
  943 
  944       /**
  945        * for glsl->tgsi/mesa IR we need to store the index into the
  946        * parameters for uniforms, initially the code overloaded location
  947        * but this causes problems with indirect samplers and AoA.
  948        * This is assigned in _mesa_generate_parameters_list_for_uniforms.
  949        */
  950       int param_index;
  951 
  952       /**
  953        * Vertex stream output identifier.
  954        *
  955        * For packed outputs, bit 31 is set and bits [2*i+1,2*i] indicate the
  956        * stream of the i-th component.
  957        */
  958       unsigned stream;
  959 
  960       /**
  961        * Atomic, transform feedback or block member offset.
  962        */
  963       unsigned offset;
  964 
  965       /**
  966        * Highest element accessed with a constant expression array index
  967        *
  968        * Not used for non-array variables. -1 is never accessed.
  969        */
  970       int max_array_access;
  971 
  972       /**
  973        * Transform feedback buffer.
  974        */
  975       unsigned xfb_buffer;
  976 
  977       /**
  978        * Transform feedback stride.
  979        */
  980       unsigned xfb_stride;
  981 
  982       /**
  983        * Allow (only) ir_variable direct access private members.
  984        */
  985       friend class ir_variable;
  986    } data;
  987 
  988    /**
  989     * Value assigned in the initializer of a variable declared "const"
  990     */
  991    ir_constant *constant_value;
  992 
  993    /**
  994     * Constant expression assigned in the initializer of the variable
  995     *
  996     * \warning
  997     * This field and \c ::constant_value are distinct.  Even if the two fields
  998     * refer to constants with the same value, they must point to separate
  999     * objects.
 1000     */
 1001    ir_constant *constant_initializer;
 1002 
 1003 private:
 1004    static const char *const warn_extension_table[];
 1005 
 1006    union {
 1007       /**
 1008        * For variables which satisfy the is_interface_instance() predicate,
 1009        * this points to an array of integers such that if the ith member of
 1010        * the interface block is an array, max_ifc_array_access[i] is the
 1011        * maximum array element of that member that has been accessed.  If the
 1012        * ith member of the interface block is not an array,
 1013        * max_ifc_array_access[i] is unused.
 1014        *
 1015        * For variables whose type is not an interface block, this pointer is
 1016        * NULL.
 1017        */
 1018       int *max_ifc_array_access;
 1019 
 1020       /**
 1021        * Built-in state that backs this uniform
 1022        *
 1023        * Once set at variable creation, \c state_slots must remain invariant.
 1024        *
 1025        * If the variable is not a uniform, \c _num_state_slots will be zero
 1026        * and \c state_slots will be \c NULL.
 1027        */
 1028       ir_state_slot *state_slots;
 1029    } u;
 1030 
 1031    /**
 1032     * For variables that are in an interface block or are an instance of an
 1033     * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block.
 1034     *
 1035     * \sa ir_variable::location
 1036     */
 1037    const glsl_type *interface_type;
 1038 
 1039    /**
 1040     * Name used for anonymous compiler temporaries
 1041     */
 1042    static const char tmp_name[];
 1043 
 1044 public:
 1045    /**
 1046     * Should the construct keep names for ir_var_temporary variables?
 1047     *
 1048     * When this global is false, names passed to the constructor for
 1049     * \c ir_var_temporary variables will be dropped.  Instead, the variable will
 1050     * be named "compiler_temp".  This name will be in static storage.
 1051     *
 1052     * \warning
 1053     * \b NEVER change the mode of an \c ir_var_temporary.
 1054     *
 1055     * \warning
 1056     * This variable is \b not thread-safe.  It is global, \b not
 1057     * per-context. It begins life false.  A context can, at some point, make
 1058     * it true.  From that point on, it will be true forever.  This should be
 1059     * okay since it will only be set true while debugging.
 1060     */
 1061    static bool temporaries_allocate_names;
 1062 };
 1063 
 1064 /**
 1065  * A function that returns whether a built-in function is available in the
 1066  * current shading language (based on version, ES or desktop, and extensions).
 1067  */
 1068 typedef bool (*builtin_available_predicate)(const _mesa_glsl_parse_state *);
 1069 
 1070 #define MAKE_INTRINSIC_FOR_TYPE(op, t) \
 1071    ir_intrinsic_generic_ ## op - ir_intrinsic_generic_load + ir_intrinsic_ ## t ## _ ## load
 1072 
 1073 #define MAP_INTRINSIC_TO_TYPE(i, t) \
 1074    ir_intrinsic_id(int(i) - int(ir_intrinsic_generic_load) + int(ir_intrinsic_ ## t ## _ ## load))
 1075 
 1076 enum ir_intrinsic_id {
 1077    ir_intrinsic_invalid = 0,
 1078 
 1079    /**
 1080     * \name Generic intrinsics
 1081     *
 1082     * Each of these intrinsics has a specific version for shared variables and
 1083     * SSBOs.
 1084     */
 1085    /*@{*/
 1086    ir_intrinsic_generic_load,
 1087    ir_intrinsic_generic_store,
 1088    ir_intrinsic_generic_atomic_add,
 1089    ir_intrinsic_generic_atomic_and,
 1090    ir_intrinsic_generic_atomic_or,
 1091    ir_intrinsic_generic_atomic_xor,
 1092    ir_intrinsic_generic_atomic_min,
 1093    ir_intrinsic_generic_atomic_max,
 1094    ir_intrinsic_generic_atomic_exchange,
 1095    ir_intrinsic_generic_atomic_comp_swap,
 1096    /*@}*/
 1097 
 1098    ir_intrinsic_atomic_counter_read,
 1099    ir_intrinsic_atomic_counter_increment,
 1100    ir_intrinsic_atomic_counter_predecrement,
 1101    ir_intrinsic_atomic_counter_add,
 1102    ir_intrinsic_atomic_counter_and,
 1103    ir_intrinsic_atomic_counter_or,
 1104    ir_intrinsic_atomic_counter_xor,
 1105    ir_intrinsic_atomic_counter_min,
 1106    ir_intrinsic_atomic_counter_max,
 1107    ir_intrinsic_atomic_counter_exchange,
 1108    ir_intrinsic_atomic_counter_comp_swap,
 1109 
 1110    ir_intrinsic_image_load,
 1111    ir_intrinsic_image_store,
 1112    ir_intrinsic_image_atomic_add,
 1113    ir_intrinsic_image_atomic_and,
 1114    ir_intrinsic_image_atomic_or,
 1115    ir_intrinsic_image_atomic_xor,
 1116    ir_intrinsic_image_atomic_min,
 1117    ir_intrinsic_image_atomic_max,
 1118    ir_intrinsic_image_atomic_exchange,
 1119    ir_intrinsic_image_atomic_comp_swap,
 1120    ir_intrinsic_image_size,
 1121    ir_intrinsic_image_samples,
 1122    ir_intrinsic_image_atomic_inc_wrap,
 1123    ir_intrinsic_image_atomic_dec_wrap,
 1124 
 1125    ir_intrinsic_ssbo_load,
 1126    ir_intrinsic_ssbo_store = MAKE_INTRINSIC_FOR_TYPE(store, ssbo),
 1127    ir_intrinsic_ssbo_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, ssbo),
 1128    ir_intrinsic_ssbo_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, ssbo),
 1129    ir_intrinsic_ssbo_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, ssbo),
 1130    ir_intrinsic_ssbo_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, ssbo),
 1131    ir_intrinsic_ssbo_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, ssbo),
 1132    ir_intrinsic_ssbo_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, ssbo),
 1133    ir_intrinsic_ssbo_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, ssbo),
 1134    ir_intrinsic_ssbo_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, ssbo),
 1135 
 1136    ir_intrinsic_memory_barrier,
 1137    ir_intrinsic_shader_clock,
 1138    ir_intrinsic_group_memory_barrier,
 1139    ir_intrinsic_memory_barrier_atomic_counter,
 1140    ir_intrinsic_memory_barrier_buffer,
 1141    ir_intrinsic_memory_barrier_image,
 1142    ir_intrinsic_memory_barrier_shared,
 1143    ir_intrinsic_begin_invocation_interlock,
 1144    ir_intrinsic_end_invocation_interlock,
 1145 
 1146    ir_intrinsic_vote_all,
 1147    ir_intrinsic_vote_any,
 1148    ir_intrinsic_vote_eq,
 1149    ir_intrinsic_ballot,
 1150    ir_intrinsic_read_invocation,
 1151    ir_intrinsic_read_first_invocation,
 1152 
 1153    ir_intrinsic_helper_invocation,
 1154 
 1155    ir_intrinsic_shared_load,
 1156    ir_intrinsic_shared_store = MAKE_INTRINSIC_FOR_TYPE(store, shared),
 1157    ir_intrinsic_shared_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, shared),
 1158    ir_intrinsic_shared_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, shared),
 1159    ir_intrinsic_shared_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, shared),
 1160    ir_intrinsic_shared_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, shared),
 1161    ir_intrinsic_shared_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, shared),
 1162    ir_intrinsic_shared_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, shared),
 1163    ir_intrinsic_shared_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, shared),
 1164    ir_intrinsic_shared_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, shared),
 1165 };
 1166 
 1167 /*@{*/
 1168 /**
 1169  * The representation of a function instance; may be the full definition or
 1170  * simply a prototype.
 1171  */
 1172 class ir_function_signature : public ir_instruction {
 1173    /* An ir_function_signature will be part of the list of signatures in
 1174     * an ir_function.
 1175     */
 1176 public:
 1177    ir_function_signature(const glsl_type *return_type,
 1178                          builtin_available_predicate builtin_avail = NULL);
 1179 
 1180    virtual ir_function_signature *clone(void *mem_ctx,
 1181                     struct hash_table *ht) const;
 1182    ir_function_signature *clone_prototype(void *mem_ctx,
 1183                       struct hash_table *ht) const;
 1184 
 1185    virtual void accept(ir_visitor *v)
 1186    {
 1187       v->visit(this);
 1188    }
 1189 
 1190    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1191 
 1192    /**
 1193     * Attempt to evaluate this function as a constant expression,
 1194     * given a list of the actual parameters and the variable context.
 1195     * Returns NULL for non-built-ins.
 1196     */
 1197    ir_constant *constant_expression_value(void *mem_ctx,
 1198                                           exec_list *actual_parameters,
 1199                                           struct hash_table *variable_context);
 1200 
 1201    /**
 1202     * Get the name of the function for which this is a signature
 1203     */
 1204    const char *function_name() const;
 1205 
 1206    /**
 1207     * Get a handle to the function for which this is a signature
 1208     *
 1209     * There is no setter function, this function returns a \c const pointer,
 1210     * and \c ir_function_signature::_function is private for a reason.  The
 1211     * only way to make a connection between a function and function signature
 1212     * is via \c ir_function::add_signature.  This helps ensure that certain
 1213     * invariants (i.e., a function signature is in the list of signatures for
 1214     * its \c _function) are met.
 1215     *
 1216     * \sa ir_function::add_signature
 1217     */
 1218    inline const class ir_function *function() const
 1219    {
 1220       return this->_function;
 1221    }
 1222 
 1223    /**
 1224     * Check whether the qualifiers match between this signature's parameters
 1225     * and the supplied parameter list.  If not, returns the name of the first
 1226     * parameter with mismatched qualifiers (for use in error messages).
 1227     */
 1228    const char *qualifiers_match(exec_list *params);
 1229 
 1230    /**
 1231     * Replace the current parameter list with the given one.  This is useful
 1232     * if the current information came from a prototype, and either has invalid
 1233     * or missing parameter names.
 1234     */
 1235    void replace_parameters(exec_list *new_params);
 1236 
 1237    /**
 1238     * Function return type.
 1239     *
 1240     * \note The precision qualifier is stored separately in return_precision.
 1241     */
 1242    const struct glsl_type *return_type;
 1243 
 1244    /**
 1245     * List of ir_variable of function parameters.
 1246     *
 1247     * This represents the storage.  The paramaters passed in a particular
 1248     * call will be in ir_call::actual_paramaters.
 1249     */
 1250    struct exec_list parameters;
 1251 
 1252    /** Whether or not this function has a body (which may be empty). */
 1253    unsigned is_defined:1;
 1254 
 1255    /*
 1256     * Precision qualifier for the return type.
 1257     *
 1258     * See the comment for ir_variable_data::precision for more details.
 1259     */
 1260    unsigned return_precision:2;
 1261 
 1262    /** Whether or not this function signature is a built-in. */
 1263    bool is_builtin() const;
 1264 
 1265    /**
 1266     * Whether or not this function is an intrinsic to be implemented
 1267     * by the driver.
 1268     */
 1269    inline bool is_intrinsic() const
 1270    {
 1271       return intrinsic_id != ir_intrinsic_invalid;
 1272    }
 1273 
 1274    /** Indentifier for this intrinsic. */
 1275    enum ir_intrinsic_id intrinsic_id;
 1276 
 1277    /** Whether or not a built-in is available for this shader. */
 1278    bool is_builtin_available(const _mesa_glsl_parse_state *state) const;
 1279 
 1280    /** Body of instructions in the function. */
 1281    struct exec_list body;
 1282 
 1283 private:
 1284    /**
 1285     * A function pointer to a predicate that answers whether a built-in
 1286     * function is available in the current shader.  NULL if not a built-in.
 1287     */
 1288    builtin_available_predicate builtin_avail;
 1289 
 1290    /** Function of which this signature is one overload. */
 1291    class ir_function *_function;
 1292 
 1293    /** Function signature of which this one is a prototype clone */
 1294    const ir_function_signature *origin;
 1295 
 1296    friend class ir_function;
 1297 
 1298    /**
 1299     * Helper function to run a list of instructions for constant
 1300     * expression evaluation.
 1301     *
 1302     * The hash table represents the values of the visible variables.
 1303     * There are no scoping issues because the table is indexed on
 1304     * ir_variable pointers, not variable names.
 1305     *
 1306     * Returns false if the expression is not constant, true otherwise,
 1307     * and the value in *result if result is non-NULL.
 1308     */
 1309    bool constant_expression_evaluate_expression_list(void *mem_ctx,
 1310                                                      const struct exec_list &body,
 1311                              struct hash_table *variable_context,
 1312                              ir_constant **result);
 1313 };
 1314 
 1315 
 1316 /**
 1317  * Header for tracking multiple overloaded functions with the same name.
 1318  * Contains a list of ir_function_signatures representing each of the
 1319  * actual functions.
 1320  */
 1321 class ir_function : public ir_instruction {
 1322 public:
 1323    ir_function(const char *name);
 1324 
 1325    virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
 1326 
 1327    virtual void accept(ir_visitor *v)
 1328    {
 1329       v->visit(this);
 1330    }
 1331 
 1332    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1333 
 1334    void add_signature(ir_function_signature *sig)
 1335    {
 1336       sig->_function = this;
 1337       this->signatures.push_tail(sig);
 1338    }
 1339 
 1340    /**
 1341     * Find a signature that matches a set of actual parameters, taking implicit
 1342     * conversions into account.  Also flags whether the match was exact.
 1343     */
 1344    ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
 1345                                              const exec_list *actual_param,
 1346                                              bool allow_builtins,
 1347                          bool *match_is_exact);
 1348 
 1349    /**
 1350     * Find a signature that matches a set of actual parameters, taking implicit
 1351     * conversions into account.
 1352     */
 1353    ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
 1354                                              const exec_list *actual_param,
 1355                                              bool allow_builtins);
 1356 
 1357    /**
 1358     * Find a signature that exactly matches a set of actual parameters without
 1359     * any implicit type conversions.
 1360     */
 1361    ir_function_signature *exact_matching_signature(_mesa_glsl_parse_state *state,
 1362                                                    const exec_list *actual_ps);
 1363 
 1364    /**
 1365     * Name of the function.
 1366     */
 1367    const char *name;
 1368 
 1369    /** Whether or not this function has a signature that isn't a built-in. */
 1370    bool has_user_signature();
 1371 
 1372    /**
 1373     * List of ir_function_signature for each overloaded function with this name.
 1374     */
 1375    struct exec_list signatures;
 1376 
 1377    /**
 1378     * is this function a subroutine type declaration
 1379     * e.g. subroutine void type1(float arg1);
 1380     */
 1381    bool is_subroutine;
 1382 
 1383    /**
 1384     * is this function associated to a subroutine type
 1385     * e.g. subroutine (type1, type2) function_name { function_body };
 1386     * would have num_subroutine_types 2,
 1387     * and pointers to the type1 and type2 types.
 1388     */
 1389    int num_subroutine_types;
 1390    const struct glsl_type **subroutine_types;
 1391 
 1392    int subroutine_index;
 1393 };
 1394 
 1395 inline const char *ir_function_signature::function_name() const
 1396 {
 1397    return this->_function->name;
 1398 }
 1399 /*@}*/
 1400 
 1401 
 1402 /**
 1403  * IR instruction representing high-level if-statements
 1404  */
 1405 class ir_if : public ir_instruction {
 1406 public:
 1407    ir_if(ir_rvalue *condition)
 1408       : ir_instruction(ir_type_if), condition(condition)
 1409    {
 1410    }
 1411 
 1412    virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
 1413 
 1414    virtual void accept(ir_visitor *v)
 1415    {
 1416       v->visit(this);
 1417    }
 1418 
 1419    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1420 
 1421    ir_rvalue *condition;
 1422    /** List of ir_instruction for the body of the then branch */
 1423    exec_list  then_instructions;
 1424    /** List of ir_instruction for the body of the else branch */
 1425    exec_list  else_instructions;
 1426 };
 1427 
 1428 
 1429 /**
 1430  * IR instruction representing a high-level loop structure.
 1431  */
 1432 class ir_loop : public ir_instruction {
 1433 public:
 1434    ir_loop();
 1435 
 1436    virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
 1437 
 1438    virtual void accept(ir_visitor *v)
 1439    {
 1440       v->visit(this);
 1441    }
 1442 
 1443    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1444 
 1445    /** List of ir_instruction that make up the body of the loop. */
 1446    exec_list body_instructions;
 1447 };
 1448 
 1449 
 1450 class ir_assignment : public ir_instruction {
 1451 public:
 1452    ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL);
 1453 
 1454    /**
 1455     * Construct an assignment with an explicit write mask
 1456     *
 1457     * \note
 1458     * Since a write mask is supplied, the LHS must already be a bare
 1459     * \c ir_dereference.  The cannot be any swizzles in the LHS.
 1460     */
 1461    ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,
 1462          unsigned write_mask);
 1463 
 1464    virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
 1465 
 1466    virtual ir_constant *constant_expression_value(void *mem_ctx,
 1467                                                   struct hash_table *variable_context = NULL);
 1468 
 1469    virtual void accept(ir_visitor *v)
 1470    {
 1471       v->visit(this);
 1472    }
 1473 
 1474    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1475 
 1476    /**
 1477     * Get a whole variable written by an assignment
 1478     *
 1479     * If the LHS of the assignment writes a whole variable, the variable is
 1480     * returned.  Otherwise \c NULL is returned.  Examples of whole-variable
 1481     * assignment are:
 1482     *
 1483     *  - Assigning to a scalar
 1484     *  - Assigning to all components of a vector
 1485     *  - Whole array (or matrix) assignment
 1486     *  - Whole structure assignment
 1487     */
 1488    ir_variable *whole_variable_written();
 1489 
 1490    /**
 1491     * Set the LHS of an assignment
 1492     */
 1493    void set_lhs(ir_rvalue *lhs);
 1494 
 1495    /**
 1496     * Left-hand side of the assignment.
 1497     *
 1498     * This should be treated as read only.  If you need to set the LHS of an
 1499     * assignment, use \c ir_assignment::set_lhs.
 1500     */
 1501    ir_dereference *lhs;
 1502 
 1503    /**
 1504     * Value being assigned
 1505     */
 1506    ir_rvalue *rhs;
 1507 
 1508    /**
 1509     * Optional condition for the assignment.
 1510     */
 1511    ir_rvalue *condition;
 1512 
 1513 
 1514    /**
 1515     * Component mask written
 1516     *
 1517     * For non-vector types in the LHS, this field will be zero.  For vector
 1518     * types, a bit will be set for each component that is written.  Note that
 1519     * for \c vec2 and \c vec3 types only the lower bits will ever be set.
 1520     *
 1521     * A partially-set write mask means that each enabled channel gets
 1522     * the value from a consecutive channel of the rhs.  For example,
 1523     * to write just .xyw of gl_FrontColor with color:
 1524     *
 1525     * (assign (constant bool (1)) (xyw)
 1526     *     (var_ref gl_FragColor)
 1527     *     (swiz xyw (var_ref color)))
 1528     */
 1529    unsigned write_mask:4;
 1530 };
 1531 
 1532 #include "ir_expression_operation.h"
 1533 
 1534 extern const char *const ir_expression_operation_strings[ir_last_opcode + 1];
 1535 extern const char *const ir_expression_operation_enum_strings[ir_last_opcode + 1];
 1536 
 1537 class ir_expression : public ir_rvalue {
 1538 public:
 1539    ir_expression(int op, const struct glsl_type *type,
 1540                  ir_rvalue *op0, ir_rvalue *op1 = NULL,
 1541                  ir_rvalue *op2 = NULL, ir_rvalue *op3 = NULL);
 1542 
 1543    /**
 1544     * Constructor for unary operation expressions
 1545     */
 1546    ir_expression(int op, ir_rvalue *);
 1547 
 1548    /**
 1549     * Constructor for binary operation expressions
 1550     */
 1551    ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1);
 1552 
 1553    /**
 1554     * Constructor for ternary operation expressions
 1555     */
 1556    ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2);
 1557 
 1558    virtual bool equals(const ir_instruction *ir,
 1559                        enum ir_node_type ignore = ir_type_unset) const;
 1560 
 1561    virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
 1562 
 1563    /**
 1564     * Attempt to constant-fold the expression
 1565     *
 1566     * The "variable_context" hash table links ir_variable * to ir_constant *
 1567     * that represent the variables' values.  \c NULL represents an empty
 1568     * context.
 1569     *
 1570     * If the expression cannot be constant folded, this method will return
 1571     * \c NULL.
 1572     */
 1573    virtual ir_constant *constant_expression_value(void *mem_ctx,
 1574                                                   struct hash_table *variable_context = NULL);
 1575 
 1576    /**
 1577     * This is only here for ir_reader to used for testing purposes please use
 1578     * the precomputed num_operands field if you need the number of operands.
 1579     */
 1580    static unsigned get_num_operands(ir_expression_operation);
 1581 
 1582    /**
 1583     * Return whether the expression operates on vectors horizontally.
 1584     */
 1585    bool is_horizontal() const
 1586    {
 1587       return operation == ir_binop_all_equal ||
 1588              operation == ir_binop_any_nequal ||
 1589              operation == ir_binop_dot ||
 1590              operation == ir_binop_vector_extract ||
 1591              operation == ir_triop_vector_insert ||
 1592              operation == ir_binop_ubo_load ||
 1593              operation == ir_quadop_vector;
 1594    }
 1595 
 1596    /**
 1597     * Do a reverse-lookup to translate the given string into an operator.
 1598     */
 1599    static ir_expression_operation get_operator(const char *);
 1600 
 1601    virtual void accept(ir_visitor *v)
 1602    {
 1603       v->visit(this);
 1604    }
 1605 
 1606    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1607 
 1608    virtual ir_variable *variable_referenced() const;
 1609 
 1610    /**
 1611     * Determine the number of operands used by an expression
 1612     */
 1613    void init_num_operands()
 1614    {
 1615       if (operation == ir_quadop_vector) {
 1616          num_operands = this->type->vector_elements;
 1617       } else {
 1618          num_operands = get_num_operands(operation);
 1619       }
 1620    }
 1621 
 1622    ir_expression_operation operation;
 1623    ir_rvalue *operands[4];
 1624    uint8_t num_operands;
 1625 };
 1626 
 1627 
 1628 /**
 1629  * HIR instruction representing a high-level function call, containing a list
 1630  * of parameters and returning a value in the supplied temporary.
 1631  */
 1632 class ir_call : public ir_instruction {
 1633 public:
 1634    ir_call(ir_function_signature *callee,
 1635        ir_dereference_variable *return_deref,
 1636        exec_list *actual_parameters)
 1637       : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(NULL), array_idx(NULL)
 1638    {
 1639       assert(callee->return_type != NULL);
 1640       actual_parameters->move_nodes_to(& this->actual_parameters);
 1641    }
 1642 
 1643    ir_call(ir_function_signature *callee,
 1644        ir_dereference_variable *return_deref,
 1645        exec_list *actual_parameters,
 1646        ir_variable *var, ir_rvalue *array_idx)
 1647       : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(var), array_idx(array_idx)
 1648    {
 1649       assert(callee->return_type != NULL);
 1650       actual_parameters->move_nodes_to(& this->actual_parameters);
 1651    }
 1652 
 1653    virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
 1654 
 1655    virtual ir_constant *constant_expression_value(void *mem_ctx,
 1656                                                   struct hash_table *variable_context = NULL);
 1657 
 1658    virtual void accept(ir_visitor *v)
 1659    {
 1660       v->visit(this);
 1661    }
 1662 
 1663    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1664 
 1665    /**
 1666     * Get the name of the function being called.
 1667     */
 1668    const char *callee_name() const
 1669    {
 1670       return callee->function_name();
 1671    }
 1672 
 1673    /**
 1674     * Generates an inline version of the function before @ir,
 1675     * storing the return value in return_deref.
 1676     */
 1677    void generate_inline(ir_instruction *ir);
 1678 
 1679    /**
 1680     * Storage for the function's return value.
 1681     * This must be NULL if the return type is void.
 1682     */
 1683    ir_dereference_variable *return_deref;
 1684 
 1685    /**
 1686     * The specific function signature being called.
 1687     */
 1688    ir_function_signature *callee;
 1689 
 1690    /* List of ir_rvalue of paramaters passed in this call. */
 1691    exec_list actual_parameters;
 1692 
 1693    /*
 1694     * ARB_shader_subroutine support -
 1695     * the subroutine uniform variable and array index
 1696     * rvalue to be used in the lowering pass later.
 1697     */
 1698    ir_variable *sub_var;
 1699    ir_rvalue *array_idx;
 1700 };
 1701 
 1702 
 1703 /**
 1704  * \name Jump-like IR instructions.
 1705  *
 1706  * These include \c break, \c continue, \c return, and \c discard.
 1707  */
 1708 /*@{*/
 1709 class ir_jump : public ir_instruction {
 1710 protected:
 1711    ir_jump(enum ir_node_type t)
 1712       : ir_instruction(t)
 1713    {
 1714    }
 1715 };
 1716 
 1717 class ir_return : public ir_jump {
 1718 public:
 1719    ir_return()
 1720       : ir_jump(ir_type_return), value(NULL)
 1721    {
 1722    }
 1723 
 1724    ir_return(ir_rvalue *value)
 1725       : ir_jump(ir_type_return), value(value)
 1726    {
 1727    }
 1728 
 1729    virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
 1730 
 1731    ir_rvalue *get_value() const
 1732    {
 1733       return value;
 1734    }
 1735 
 1736    virtual void accept(ir_visitor *v)
 1737    {
 1738       v->visit(this);
 1739    }
 1740 
 1741    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1742 
 1743    ir_rvalue *value;
 1744 };
 1745 
 1746 
 1747 /**
 1748  * Jump instructions used inside loops
 1749  *
 1750  * These include \c break and \c continue.  The \c break within a loop is
 1751  * different from the \c break within a switch-statement.
 1752  *
 1753  * \sa ir_switch_jump
 1754  */
 1755 class ir_loop_jump : public ir_jump {
 1756 public:
 1757    enum jump_mode {
 1758       jump_break,
 1759       jump_continue
 1760    };
 1761 
 1762    ir_loop_jump(jump_mode mode)
 1763       : ir_jump(ir_type_loop_jump)
 1764    {
 1765       this->mode = mode;
 1766    }
 1767 
 1768    virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
 1769 
 1770    virtual void accept(ir_visitor *v)
 1771    {
 1772       v->visit(this);
 1773    }
 1774 
 1775    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1776 
 1777    bool is_break() const
 1778    {
 1779       return mode == jump_break;
 1780    }
 1781 
 1782    bool is_continue() const
 1783    {
 1784       return mode == jump_continue;
 1785    }
 1786 
 1787    /** Mode selector for the jump instruction. */
 1788    enum jump_mode mode;
 1789 };
 1790 
 1791 /**
 1792  * IR instruction representing discard statements.
 1793  */
 1794 class ir_discard : public ir_jump {
 1795 public:
 1796    ir_discard()
 1797       : ir_jump(ir_type_discard)
 1798    {
 1799       this->condition = NULL;
 1800    }
 1801 
 1802    ir_discard(ir_rvalue *cond)
 1803       : ir_jump(ir_type_discard)
 1804    {
 1805       this->condition = cond;
 1806    }
 1807 
 1808    virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
 1809 
 1810    virtual void accept(ir_visitor *v)
 1811    {
 1812       v->visit(this);
 1813    }
 1814 
 1815    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1816 
 1817    ir_rvalue *condition;
 1818 };
 1819 /*@}*/
 1820 
 1821 
 1822 /**
 1823  * IR instruction representing demote statements from
 1824  * GL_EXT_demote_to_helper_invocation.
 1825  */
 1826 class ir_demote : public ir_instruction {
 1827 public:
 1828    ir_demote()
 1829       : ir_instruction(ir_type_demote)
 1830    {
 1831    }
 1832 
 1833    virtual ir_demote *clone(void *mem_ctx, struct hash_table *ht) const;
 1834 
 1835    virtual void accept(ir_visitor *v)
 1836    {
 1837       v->visit(this);
 1838    }
 1839 
 1840    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1841 };
 1842 
 1843 
 1844 /**
 1845  * Texture sampling opcodes used in ir_texture
 1846  */
 1847 enum ir_texture_opcode {
 1848    ir_tex,      /**< Regular texture look-up */
 1849    ir_txb,      /**< Texture look-up with LOD bias */
 1850    ir_txl,      /**< Texture look-up with explicit LOD */
 1851    ir_txd,      /**< Texture look-up with partial derivatvies */
 1852    ir_txf,      /**< Texel fetch with explicit LOD */
 1853    ir_txf_ms,           /**< Multisample texture fetch */
 1854    ir_txs,      /**< Texture size */
 1855    ir_lod,      /**< Texture lod query */
 1856    ir_tg4,      /**< Texture gather */
 1857    ir_query_levels,     /**< Texture levels query */
 1858    ir_texture_samples,  /**< Texture samples query */
 1859    ir_samples_identical, /**< Query whether all samples are definitely identical. */
 1860 };
 1861 
 1862 
 1863 /**
 1864  * IR instruction to sample a texture
 1865  *
 1866  * The specific form of the IR instruction depends on the \c mode value
 1867  * selected from \c ir_texture_opcodes.  In the printed IR, these will
 1868  * appear as:
 1869  *
 1870  *                                    Texel offset (0 or an expression)
 1871  *                                    | Projection divisor
 1872  *                                    | |  Shadow comparator
 1873  *                                    | |  |
 1874  *                                    v v  v
 1875  * (tex <type> <sampler> <coordinate> 0 1 ( ))
 1876  * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>)
 1877  * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>)
 1878  * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy))
 1879  * (txf <type> <sampler> <coordinate> 0       <lod>)
 1880  * (txf_ms
 1881  *      <type> <sampler> <coordinate>         <sample_index>)
 1882  * (txs <type> <sampler> <lod>)
 1883  * (lod <type> <sampler> <coordinate>)
 1884  * (tg4 <type> <sampler> <coordinate> <offset> <component>)
 1885  * (query_levels <type> <sampler>)
 1886  * (samples_identical <sampler> <coordinate>)
 1887  */
 1888 class ir_texture : public ir_rvalue {
 1889 public:
 1890    ir_texture(enum ir_texture_opcode op)
 1891       : ir_rvalue(ir_type_texture),
 1892         op(op), sampler(NULL), coordinate(NULL), projector(NULL),
 1893         shadow_comparator(NULL), offset(NULL)
 1894    {
 1895       memset(&lod_info, 0, sizeof(lod_info));
 1896    }
 1897 
 1898    virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
 1899 
 1900    virtual ir_constant *constant_expression_value(void *mem_ctx,
 1901                                                   struct hash_table *variable_context = NULL);
 1902 
 1903    virtual void accept(ir_visitor *v)
 1904    {
 1905       v->visit(this);
 1906    }
 1907 
 1908    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 1909 
 1910    virtual bool equals(const ir_instruction *ir,
 1911                        enum ir_node_type ignore = ir_type_unset) const;
 1912 
 1913    /**
 1914     * Return a string representing the ir_texture_opcode.
 1915     */
 1916    const char *opcode_string();
 1917 
 1918    /** Set the sampler and type. */
 1919    void set_sampler(ir_dereference *sampler, const glsl_type *type);
 1920 
 1921    /**
 1922     * Do a reverse-lookup to translate a string into an ir_texture_opcode.
 1923     */
 1924    static ir_texture_opcode get_opcode(const char *);
 1925 
 1926    enum ir_texture_opcode op;
 1927 
 1928    /** Sampler to use for the texture access. */
 1929    ir_dereference *sampler;
 1930 
 1931    /** Texture coordinate to sample */
 1932    ir_rvalue *coordinate;
 1933 
 1934    /**
 1935     * Value used for projective divide.
 1936     *
 1937     * If there is no projective divide (the common case), this will be
 1938     * \c NULL.  Optimization passes should check for this to point to a constant
 1939     * of 1.0 and replace that with \c NULL.
 1940     */
 1941    ir_rvalue *projector;
 1942 
 1943    /**
 1944     * Coordinate used for comparison on shadow look-ups.
 1945     *
 1946     * If there is no shadow comparison, this will be \c NULL.  For the
 1947     * \c ir_txf opcode, this *must* be \c NULL.
 1948     */
 1949    ir_rvalue *shadow_comparator;
 1950 
 1951    /** Texel offset. */
 1952    ir_rvalue *offset;
 1953 
 1954    union {
 1955       ir_rvalue *lod;       /**< Floating point LOD */
 1956       ir_rvalue *bias;      /**< Floating point LOD bias */
 1957       ir_rvalue *sample_index;  /**< MSAA sample index */
 1958       ir_rvalue *component;     /**< Gather component selector */
 1959       struct {
 1960      ir_rvalue *dPdx;   /**< Partial derivative of coordinate wrt X */
 1961      ir_rvalue *dPdy;   /**< Partial derivative of coordinate wrt Y */
 1962       } grad;
 1963    } lod_info;
 1964 };
 1965 
 1966 
 1967 struct ir_swizzle_mask {
 1968    unsigned x:2;
 1969    unsigned y:2;
 1970    unsigned z:2;
 1971    unsigned w:2;
 1972 
 1973    /**
 1974     * Number of components in the swizzle.
 1975     */
 1976    unsigned num_components:3;
 1977 
 1978    /**
 1979     * Does the swizzle contain duplicate components?
 1980     *
 1981     * L-value swizzles cannot contain duplicate components.
 1982     */
 1983    unsigned has_duplicates:1;
 1984 };
 1985 
 1986 
 1987 class ir_swizzle : public ir_rvalue {
 1988 public:
 1989    ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
 1990               unsigned count);
 1991 
 1992    ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);
 1993 
 1994    ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
 1995 
 1996    virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
 1997 
 1998    virtual ir_constant *constant_expression_value(void *mem_ctx,
 1999                                                   struct hash_table *variable_context = NULL);
 2000 
 2001    /**
 2002     * Construct an ir_swizzle from the textual representation.  Can fail.
 2003     */
 2004    static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
 2005 
 2006    virtual void accept(ir_visitor *v)
 2007    {
 2008       v->visit(this);
 2009    }
 2010 
 2011    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2012 
 2013    virtual bool equals(const ir_instruction *ir,
 2014                        enum ir_node_type ignore = ir_type_unset) const;
 2015 
 2016    bool is_lvalue(const struct _mesa_glsl_parse_state *state) const
 2017    {
 2018       return val->is_lvalue(state) && !mask.has_duplicates;
 2019    }
 2020 
 2021    /**
 2022     * Get the variable that is ultimately referenced by an r-value
 2023     */
 2024    virtual ir_variable *variable_referenced() const;
 2025 
 2026    ir_rvalue *val;
 2027    ir_swizzle_mask mask;
 2028 
 2029 private:
 2030    /**
 2031     * Initialize the mask component of a swizzle
 2032     *
 2033     * This is used by the \c ir_swizzle constructors.
 2034     */
 2035    void init_mask(const unsigned *components, unsigned count);
 2036 };
 2037 
 2038 
 2039 class ir_dereference : public ir_rvalue {
 2040 public:
 2041    virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
 2042 
 2043    bool is_lvalue(const struct _mesa_glsl_parse_state *state) const;
 2044 
 2045    /**
 2046     * Get the variable that is ultimately referenced by an r-value
 2047     */
 2048    virtual ir_variable *variable_referenced() const = 0;
 2049 
 2050    /**
 2051     * Get the precision. This can either come from the eventual variable that
 2052     * is dereferenced, or from a record member.
 2053     */
 2054    virtual int precision() const = 0;
 2055 
 2056 protected:
 2057    ir_dereference(enum ir_node_type t)
 2058       : ir_rvalue(t)
 2059    {
 2060    }
 2061 };
 2062 
 2063 
 2064 class ir_dereference_variable : public ir_dereference {
 2065 public:
 2066    ir_dereference_variable(ir_variable *var);
 2067 
 2068    virtual ir_dereference_variable *clone(void *mem_ctx,
 2069                       struct hash_table *) const;
 2070 
 2071    virtual ir_constant *constant_expression_value(void *mem_ctx,
 2072                                                   struct hash_table *variable_context = NULL);
 2073 
 2074    virtual bool equals(const ir_instruction *ir,
 2075                        enum ir_node_type ignore = ir_type_unset) const;
 2076 
 2077    /**
 2078     * Get the variable that is ultimately referenced by an r-value
 2079     */
 2080    virtual ir_variable *variable_referenced() const
 2081    {
 2082       return this->var;
 2083    }
 2084 
 2085    virtual int precision() const
 2086    {
 2087       return this->var->data.precision;
 2088    }
 2089 
 2090    virtual ir_variable *whole_variable_referenced()
 2091    {
 2092       /* ir_dereference_variable objects always dereference the entire
 2093        * variable.  However, if this dereference is dereferenced by anything
 2094        * else, the complete deferefernce chain is not a whole-variable
 2095        * dereference.  This method should only be called on the top most
 2096        * ir_rvalue in a dereference chain.
 2097        */
 2098       return this->var;
 2099    }
 2100 
 2101    virtual void accept(ir_visitor *v)
 2102    {
 2103       v->visit(this);
 2104    }
 2105 
 2106    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2107 
 2108    /**
 2109     * Object being dereferenced.
 2110     */
 2111    ir_variable *var;
 2112 };
 2113 
 2114 
 2115 class ir_dereference_array : public ir_dereference {
 2116 public:
 2117    ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);
 2118 
 2119    ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
 2120 
 2121    virtual ir_dereference_array *clone(void *mem_ctx,
 2122                        struct hash_table *) const;
 2123 
 2124    virtual ir_constant *constant_expression_value(void *mem_ctx,
 2125                                                   struct hash_table *variable_context = NULL);
 2126 
 2127    virtual bool equals(const ir_instruction *ir,
 2128                        enum ir_node_type ignore = ir_type_unset) const;
 2129 
 2130    /**
 2131     * Get the variable that is ultimately referenced by an r-value
 2132     */
 2133    virtual ir_variable *variable_referenced() const
 2134    {
 2135       return this->array->variable_referenced();
 2136    }
 2137 
 2138    virtual int precision() const
 2139    {
 2140       ir_dereference *deref = this->array->as_dereference();
 2141 
 2142       if (deref == NULL)
 2143          return GLSL_PRECISION_NONE;
 2144       else
 2145          return deref->precision();
 2146    }
 2147 
 2148    virtual void accept(ir_visitor *v)
 2149    {
 2150       v->visit(this);
 2151    }
 2152 
 2153    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2154 
 2155    ir_rvalue *array;
 2156    ir_rvalue *array_index;
 2157 
 2158 private:
 2159    void set_array(ir_rvalue *value);
 2160 };
 2161 
 2162 
 2163 class ir_dereference_record : public ir_dereference {
 2164 public:
 2165    ir_dereference_record(ir_rvalue *value, const char *field);
 2166 
 2167    ir_dereference_record(ir_variable *var, const char *field);
 2168 
 2169    virtual ir_dereference_record *clone(void *mem_ctx,
 2170                     struct hash_table *) const;
 2171 
 2172    virtual ir_constant *constant_expression_value(void *mem_ctx,
 2173                                                   struct hash_table *variable_context = NULL);
 2174 
 2175    /**
 2176     * Get the variable that is ultimately referenced by an r-value
 2177     */
 2178    virtual ir_variable *variable_referenced() const
 2179    {
 2180       return this->record->variable_referenced();
 2181    }
 2182 
 2183    virtual int precision() const
 2184    {
 2185       glsl_struct_field *field = record->type->fields.structure + field_idx;
 2186 
 2187       return field->precision;
 2188    }
 2189 
 2190    virtual void accept(ir_visitor *v)
 2191    {
 2192       v->visit(this);
 2193    }
 2194 
 2195    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2196 
 2197    ir_rvalue *record;
 2198    int field_idx;
 2199 };
 2200 
 2201 
 2202 /**
 2203  * Data stored in an ir_constant
 2204  */
 2205 union ir_constant_data {
 2206       unsigned u[16];
 2207       int i[16];
 2208       float f[16];
 2209       bool b[16];
 2210       double d[16];
 2211       uint16_t f16[16];
 2212       uint64_t u64[16];
 2213       int64_t i64[16];
 2214 };
 2215 
 2216 
 2217 class ir_constant : public ir_rvalue {
 2218 public:
 2219    ir_constant(const struct glsl_type *type, const ir_constant_data *data);
 2220    ir_constant(bool b, unsigned vector_elements=1);
 2221    ir_constant(unsigned int u, unsigned vector_elements=1);
 2222    ir_constant(int i, unsigned vector_elements=1);
 2223    ir_constant(float16_t f16, unsigned vector_elements=1);
 2224    ir_constant(float f, unsigned vector_elements=1);
 2225    ir_constant(double d, unsigned vector_elements=1);
 2226    ir_constant(uint64_t u64, unsigned vector_elements=1);
 2227    ir_constant(int64_t i64, unsigned vector_elements=1);
 2228 
 2229    /**
 2230     * Construct an ir_constant from a list of ir_constant values
 2231     */
 2232    ir_constant(const struct glsl_type *type, exec_list *values);
 2233 
 2234    /**
 2235     * Construct an ir_constant from a scalar component of another ir_constant
 2236     *
 2237     * The new \c ir_constant inherits the type of the component from the
 2238     * source constant.
 2239     *
 2240     * \note
 2241     * In the case of a matrix constant, the new constant is a scalar, \b not
 2242     * a vector.
 2243     */
 2244    ir_constant(const ir_constant *c, unsigned i);
 2245 
 2246    /**
 2247     * Return a new ir_constant of the specified type containing all zeros.
 2248     */
 2249    static ir_constant *zero(void *mem_ctx, const glsl_type *type);
 2250 
 2251    virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
 2252 
 2253    virtual ir_constant *constant_expression_value(void *mem_ctx,
 2254                                                   struct hash_table *variable_context = NULL);
 2255 
 2256    virtual void accept(ir_visitor *v)
 2257    {
 2258       v->visit(this);
 2259    }
 2260 
 2261    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2262 
 2263    virtual bool equals(const ir_instruction *ir,
 2264                        enum ir_node_type ignore = ir_type_unset) const;
 2265 
 2266    /**
 2267     * Get a particular component of a constant as a specific type
 2268     *
 2269     * This is useful, for example, to get a value from an integer constant
 2270     * as a float or bool.  This appears frequently when constructors are
 2271     * called with all constant parameters.
 2272     */
 2273    /*@{*/
 2274    bool get_bool_component(unsigned i) const;
 2275    float get_float_component(unsigned i) const;
 2276    uint16_t get_float16_component(unsigned i) const;
 2277    double get_double_component(unsigned i) const;
 2278    int get_int_component(unsigned i) const;
 2279    unsigned get_uint_component(unsigned i) const;
 2280    int64_t get_int64_component(unsigned i) const;
 2281    uint64_t get_uint64_component(unsigned i) const;
 2282    /*@}*/
 2283 
 2284    ir_constant *get_array_element(unsigned i) const;
 2285 
 2286    ir_constant *get_record_field(int idx);
 2287 
 2288    /**
 2289     * Copy the values on another constant at a given offset.
 2290     *
 2291     * The offset is ignored for array or struct copies, it's only for
 2292     * scalars or vectors into vectors or matrices.
 2293     *
 2294     * With identical types on both sides and zero offset it's clone()
 2295     * without creating a new object.
 2296     */
 2297 
 2298    void copy_offset(ir_constant *src, int offset);
 2299 
 2300    /**
 2301     * Copy the values on another constant at a given offset and
 2302     * following an assign-like mask.
 2303     *
 2304     * The mask is ignored for scalars.
 2305     *
 2306     * Note that this function only handles what assign can handle,
 2307     * i.e. at most a vector as source and a column of a matrix as
 2308     * destination.
 2309     */
 2310 
 2311    void copy_masked_offset(ir_constant *src, int offset, unsigned int mask);
 2312 
 2313    /**
 2314     * Determine whether a constant has the same value as another constant
 2315     *
 2316     * \sa ir_constant::is_zero, ir_constant::is_one,
 2317     * ir_constant::is_negative_one
 2318     */
 2319    bool has_value(const ir_constant *) const;
 2320 
 2321    /**
 2322     * Return true if this ir_constant represents the given value.
 2323     *
 2324     * For vectors, this checks that each component is the given value.
 2325     */
 2326    virtual bool is_value(float f, int i) const;
 2327    virtual bool is_zero() const;
 2328    virtual bool is_one() const;
 2329    virtual bool is_negative_one() const;
 2330 
 2331    /**
 2332     * Return true for constants that could be stored as 16-bit unsigned values.
 2333     *
 2334     * Note that this will return true even for signed integer ir_constants, as
 2335     * long as the value is non-negative and fits in 16-bits.
 2336     */
 2337    virtual bool is_uint16_constant() const;
 2338 
 2339    /**
 2340     * Value of the constant.
 2341     *
 2342     * The field used to back the values supplied by the constant is determined
 2343     * by the type associated with the \c ir_instruction.  Constants may be
 2344     * scalars, vectors, or matrices.
 2345     */
 2346    union ir_constant_data value;
 2347 
 2348    /* Array elements and structure fields */
 2349    ir_constant **const_elements;
 2350 
 2351 private:
 2352    /**
 2353     * Parameterless constructor only used by the clone method
 2354     */
 2355    ir_constant(void);
 2356 };
 2357 
 2358 /**
 2359  * IR instruction to emit a vertex in a geometry shader.
 2360  */
 2361 class ir_emit_vertex : public ir_instruction {
 2362 public:
 2363    ir_emit_vertex(ir_rvalue *stream)
 2364       : ir_instruction(ir_type_emit_vertex),
 2365         stream(stream)
 2366    {
 2367       assert(stream);
 2368    }
 2369 
 2370    virtual void accept(ir_visitor *v)
 2371    {
 2372       v->visit(this);
 2373    }
 2374 
 2375    virtual ir_emit_vertex *clone(void *mem_ctx, struct hash_table *ht) const
 2376    {
 2377       return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht));
 2378    }
 2379 
 2380    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2381 
 2382    int stream_id() const
 2383    {
 2384       return stream->as_constant()->value.i[0];
 2385    }
 2386 
 2387    ir_rvalue *stream;
 2388 };
 2389 
 2390 /**
 2391  * IR instruction to complete the current primitive and start a new one in a
 2392  * geometry shader.
 2393  */
 2394 class ir_end_primitive : public ir_instruction {
 2395 public:
 2396    ir_end_primitive(ir_rvalue *stream)
 2397       : ir_instruction(ir_type_end_primitive),
 2398         stream(stream)
 2399    {
 2400       assert(stream);
 2401    }
 2402 
 2403    virtual void accept(ir_visitor *v)
 2404    {
 2405       v->visit(this);
 2406    }
 2407 
 2408    virtual ir_end_primitive *clone(void *mem_ctx, struct hash_table *ht) const
 2409    {
 2410       return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht));
 2411    }
 2412 
 2413    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2414 
 2415    int stream_id() const
 2416    {
 2417       return stream->as_constant()->value.i[0];
 2418    }
 2419 
 2420    ir_rvalue *stream;
 2421 };
 2422 
 2423 /**
 2424  * IR instruction for tessellation control and compute shader barrier.
 2425  */
 2426 class ir_barrier : public ir_instruction {
 2427 public:
 2428    ir_barrier()
 2429       : ir_instruction(ir_type_barrier)
 2430    {
 2431    }
 2432 
 2433    virtual void accept(ir_visitor *v)
 2434    {
 2435       v->visit(this);
 2436    }
 2437 
 2438    virtual ir_barrier *clone(void *mem_ctx, struct hash_table *) const
 2439    {
 2440       return new(mem_ctx) ir_barrier();
 2441    }
 2442 
 2443    virtual ir_visitor_status accept(ir_hierarchical_visitor *);
 2444 };
 2445 
 2446 /*@}*/
 2447 
 2448 /**
 2449  * Apply a visitor to each IR node in a list
 2450  */
 2451 void
 2452 visit_exec_list(exec_list *list, ir_visitor *visitor);
 2453 
 2454 /**
 2455  * Validate invariants on each IR node in a list
 2456  */
 2457 void validate_ir_tree(exec_list *instructions);
 2458 
 2459 struct _mesa_glsl_parse_state;
 2460 struct gl_shader_program;
 2461 
 2462 /**
 2463  * Detect whether an unlinked shader contains static recursion
 2464  *
 2465  * If the list of instructions is determined to contain static recursion,
 2466  * \c _mesa_glsl_error will be called to emit error messages for each function
 2467  * that is in the recursion cycle.
 2468  */
 2469 void
 2470 detect_recursion_unlinked(struct _mesa_glsl_parse_state *state,
 2471               exec_list *instructions);
 2472 
 2473 /**
 2474  * Detect whether a linked shader contains static recursion
 2475  *
 2476  * If the list of instructions is determined to contain static recursion,
 2477  * \c link_error_printf will be called to emit error messages for each function
 2478  * that is in the recursion cycle.  In addition,
 2479  * \c gl_shader_program::LinkStatus will be set to false.
 2480  */
 2481 void
 2482 detect_recursion_linked(struct gl_shader_program *prog,
 2483             exec_list *instructions);
 2484 
 2485 /**
 2486  * Make a clone of each IR instruction in a list
 2487  *
 2488  * \param in   List of IR instructions that are to be cloned
 2489  * \param out  List to hold the cloned instructions
 2490  */
 2491 void
 2492 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
 2493 
 2494 extern void
 2495 _mesa_glsl_initialize_variables(exec_list *instructions,
 2496                 struct _mesa_glsl_parse_state *state);
 2497 
 2498 extern void
 2499 reparent_ir(exec_list *list, void *mem_ctx);
 2500 
 2501 extern void
 2502 do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
 2503                       gl_shader_stage shader_stage);
 2504 
 2505 extern char *
 2506 prototype_string(const glsl_type *return_type, const char *name,
 2507          exec_list *parameters);
 2508 
 2509 const char *
 2510 mode_string(const ir_variable *var);
 2511 
 2512 /**
 2513  * Built-in / reserved GL variables names start with "gl_"
 2514  */
 2515 static inline bool
 2516 is_gl_identifier(const char *s)
 2517 {
 2518    return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_';
 2519 }
 2520 
 2521 extern "C" {
 2522 #endif /* __cplusplus */
 2523 
 2524 extern void _mesa_print_ir(FILE *f, struct exec_list *instructions,
 2525                            struct _mesa_glsl_parse_state *state);
 2526 
 2527 extern void
 2528 fprint_ir(FILE *f, const void *instruction);
 2529 
 2530 extern const struct gl_builtin_uniform_desc *
 2531 _mesa_glsl_get_builtin_uniform_desc(const char *name);
 2532 
 2533 #ifdef __cplusplus
 2534 } /* extern "C" */
 2535 #endif
 2536 
 2537 unsigned
 2538 vertices_per_prim(GLenum prim);
 2539 
 2540 #endif /* IR_H */