"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/ast_to_hir.cpp" (16 Sep 2020, 347745 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 "ast_to_hir.cpp" 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 /*
    2  * Copyright © 2010 Intel Corporation
    3  *
    4  * Permission is hereby granted, free of charge, to any person obtaining a
    5  * copy of this software and associated documentation files (the "Software"),
    6  * to deal in the Software without restriction, including without limitation
    7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    8  * and/or sell copies of the Software, and to permit persons to whom the
    9  * Software is furnished to do so, subject to the following conditions:
   10  *
   11  * The above copyright notice and this permission notice (including the next
   12  * paragraph) shall be included in all copies or substantial portions of the
   13  * Software.
   14  *
   15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   21  * DEALINGS IN THE SOFTWARE.
   22  */
   23 
   24 /**
   25  * \file ast_to_hir.c
   26  * Convert abstract syntax to to high-level intermediate reprensentation (HIR).
   27  *
   28  * During the conversion to HIR, the majority of the symantic checking is
   29  * preformed on the program.  This includes:
   30  *
   31  *    * Symbol table management
   32  *    * Type checking
   33  *    * Function binding
   34  *
   35  * The majority of this work could be done during parsing, and the parser could
   36  * probably generate HIR directly.  However, this results in frequent changes
   37  * to the parser code.  Since we do not assume that every system this complier
   38  * is built on will have Flex and Bison installed, we have to store the code
   39  * generated by these tools in our version control system.  In other parts of
   40  * the system we've seen problems where a parser was changed but the generated
   41  * code was not committed, merge conflicts where created because two developers
   42  * had slightly different versions of Bison installed, etc.
   43  *
   44  * I have also noticed that running Bison generated parsers in GDB is very
   45  * irritating.  When you get a segfault on '$$ = $1->foo', you can't very
   46  * well 'print $1' in GDB.
   47  *
   48  * As a result, my preference is to put as little C code as possible in the
   49  * parser (and lexer) sources.
   50  */
   51 
   52 #include "glsl_symbol_table.h"
   53 #include "glsl_parser_extras.h"
   54 #include "ast.h"
   55 #include "compiler/glsl_types.h"
   56 #include "util/hash_table.h"
   57 #include "main/mtypes.h"
   58 #include "main/macros.h"
   59 #include "main/shaderobj.h"
   60 #include "ir.h"
   61 #include "ir_builder.h"
   62 #include "builtin_functions.h"
   63 
   64 using namespace ir_builder;
   65 
   66 static void
   67 detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
   68                                exec_list *instructions);
   69 static void
   70 verify_subroutine_associated_funcs(struct _mesa_glsl_parse_state *state);
   71 
   72 static void
   73 remove_per_vertex_blocks(exec_list *instructions,
   74                          _mesa_glsl_parse_state *state, ir_variable_mode mode);
   75 
   76 /**
   77  * Visitor class that finds the first instance of any write-only variable that
   78  * is ever read, if any
   79  */
   80 class read_from_write_only_variable_visitor : public ir_hierarchical_visitor
   81 {
   82 public:
   83    read_from_write_only_variable_visitor() : found(NULL)
   84    {
   85    }
   86 
   87    virtual ir_visitor_status visit(ir_dereference_variable *ir)
   88    {
   89       if (this->in_assignee)
   90          return visit_continue;
   91 
   92       ir_variable *var = ir->variable_referenced();
   93       /* We can have memory_write_only set on both images and buffer variables,
   94        * but in the former there is a distinction between reads from
   95        * the variable itself (write_only) and from the memory they point to
   96        * (memory_write_only), while in the case of buffer variables there is
   97        * no such distinction, that is why this check here is limited to
   98        * buffer variables alone.
   99        */
  100       if (!var || var->data.mode != ir_var_shader_storage)
  101          return visit_continue;
  102 
  103       if (var->data.memory_write_only) {
  104          found = var;
  105          return visit_stop;
  106       }
  107 
  108       return visit_continue;
  109    }
  110 
  111    ir_variable *get_variable() {
  112       return found;
  113    }
  114 
  115    virtual ir_visitor_status visit_enter(ir_expression *ir)
  116    {
  117       /* .length() doesn't actually read anything */
  118       if (ir->operation == ir_unop_ssbo_unsized_array_length)
  119          return visit_continue_with_parent;
  120 
  121       return visit_continue;
  122    }
  123 
  124 private:
  125    ir_variable *found;
  126 };
  127 
  128 void
  129 _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
  130 {
  131    _mesa_glsl_initialize_variables(instructions, state);
  132 
  133    state->symbols->separate_function_namespace = state->language_version == 110;
  134 
  135    state->current_function = NULL;
  136 
  137    state->toplevel_ir = instructions;
  138 
  139    state->gs_input_prim_type_specified = false;
  140    state->tcs_output_vertices_specified = false;
  141    state->cs_input_local_size_specified = false;
  142 
  143    /* Section 4.2 of the GLSL 1.20 specification states:
  144     * "The built-in functions are scoped in a scope outside the global scope
  145     *  users declare global variables in.  That is, a shader's global scope,
  146     *  available for user-defined functions and global variables, is nested
  147     *  inside the scope containing the built-in functions."
  148     *
  149     * Since built-in functions like ftransform() access built-in variables,
  150     * it follows that those must be in the outer scope as well.
  151     *
  152     * We push scope here to create this nesting effect...but don't pop.
  153     * This way, a shader's globals are still in the symbol table for use
  154     * by the linker.
  155     */
  156    state->symbols->push_scope();
  157 
  158    foreach_list_typed (ast_node, ast, link, & state->translation_unit)
  159       ast->hir(instructions, state);
  160 
  161    verify_subroutine_associated_funcs(state);
  162    detect_recursion_unlinked(state, instructions);
  163    detect_conflicting_assignments(state, instructions);
  164 
  165    state->toplevel_ir = NULL;
  166 
  167    /* Move all of the variable declarations to the front of the IR list, and
  168     * reverse the order.  This has the (intended!) side effect that vertex
  169     * shader inputs and fragment shader outputs will appear in the IR in the
  170     * same order that they appeared in the shader code.  This results in the
  171     * locations being assigned in the declared order.  Many (arguably buggy)
  172     * applications depend on this behavior, and it matches what nearly all
  173     * other drivers do.
  174     */
  175    foreach_in_list_safe(ir_instruction, node, instructions) {
  176       ir_variable *const var = node->as_variable();
  177 
  178       if (var == NULL)
  179          continue;
  180 
  181       var->remove();
  182       instructions->push_head(var);
  183    }
  184 
  185    /* Figure out if gl_FragCoord is actually used in fragment shader */
  186    ir_variable *const var = state->symbols->get_variable("gl_FragCoord");
  187    if (var != NULL)
  188       state->fs_uses_gl_fragcoord = var->data.used;
  189 
  190    /* From section 7.1 (Built-In Language Variables) of the GLSL 4.10 spec:
  191     *
  192     *     If multiple shaders using members of a built-in block belonging to
  193     *     the same interface are linked together in the same program, they
  194     *     must all redeclare the built-in block in the same way, as described
  195     *     in section 4.3.7 "Interface Blocks" for interface block matching, or
  196     *     a link error will result.
  197     *
  198     * The phrase "using members of a built-in block" implies that if two
  199     * shaders are linked together and one of them *does not use* any members
  200     * of the built-in block, then that shader does not need to have a matching
  201     * redeclaration of the built-in block.
  202     *
  203     * This appears to be a clarification to the behaviour established for
  204     * gl_PerVertex by GLSL 1.50, therefore implement it regardless of GLSL
  205     * version.
  206     *
  207     * The definition of "interface" in section 4.3.7 that applies here is as
  208     * follows:
  209     *
  210     *     The boundary between adjacent programmable pipeline stages: This
  211     *     spans all the outputs in all compilation units of the first stage
  212     *     and all the inputs in all compilation units of the second stage.
  213     *
  214     * Therefore this rule applies to both inter- and intra-stage linking.
  215     *
  216     * The easiest way to implement this is to check whether the shader uses
  217     * gl_PerVertex right after ast-to-ir conversion, and if it doesn't, simply
  218     * remove all the relevant variable declaration from the IR, so that the
  219     * linker won't see them and complain about mismatches.
  220     */
  221    remove_per_vertex_blocks(instructions, state, ir_var_shader_in);
  222    remove_per_vertex_blocks(instructions, state, ir_var_shader_out);
  223 
  224    /* Check that we don't have reads from write-only variables */
  225    read_from_write_only_variable_visitor v;
  226    v.run(instructions);
  227    ir_variable *error_var = v.get_variable();
  228    if (error_var) {
  229       /* It would be nice to have proper location information, but for that
  230        * we would need to check this as we process each kind of AST node
  231        */
  232       YYLTYPE loc;
  233       memset(&loc, 0, sizeof(loc));
  234       _mesa_glsl_error(&loc, state, "Read from write-only variable `%s'",
  235                        error_var->name);
  236    }
  237 }
  238 
  239 
  240 static ir_expression_operation
  241 get_implicit_conversion_operation(const glsl_type *to, const glsl_type *from,
  242                                   struct _mesa_glsl_parse_state *state)
  243 {
  244    switch (to->base_type) {
  245    case GLSL_TYPE_FLOAT:
  246       switch (from->base_type) {
  247       case GLSL_TYPE_INT: return ir_unop_i2f;
  248       case GLSL_TYPE_UINT: return ir_unop_u2f;
  249       default: return (ir_expression_operation)0;
  250       }
  251 
  252    case GLSL_TYPE_UINT:
  253       if (!state->has_implicit_uint_to_int_conversion())
  254          return (ir_expression_operation)0;
  255       switch (from->base_type) {
  256          case GLSL_TYPE_INT: return ir_unop_i2u;
  257          default: return (ir_expression_operation)0;
  258       }
  259 
  260    case GLSL_TYPE_DOUBLE:
  261       if (!state->has_double())
  262          return (ir_expression_operation)0;
  263       switch (from->base_type) {
  264       case GLSL_TYPE_INT: return ir_unop_i2d;
  265       case GLSL_TYPE_UINT: return ir_unop_u2d;
  266       case GLSL_TYPE_FLOAT: return ir_unop_f2d;
  267       case GLSL_TYPE_INT64: return ir_unop_i642d;
  268       case GLSL_TYPE_UINT64: return ir_unop_u642d;
  269       default: return (ir_expression_operation)0;
  270       }
  271 
  272    case GLSL_TYPE_UINT64:
  273       if (!state->has_int64())
  274          return (ir_expression_operation)0;
  275       switch (from->base_type) {
  276       case GLSL_TYPE_INT: return ir_unop_i2u64;
  277       case GLSL_TYPE_UINT: return ir_unop_u2u64;
  278       case GLSL_TYPE_INT64: return ir_unop_i642u64;
  279       default: return (ir_expression_operation)0;
  280       }
  281 
  282    case GLSL_TYPE_INT64:
  283       if (!state->has_int64())
  284          return (ir_expression_operation)0;
  285       switch (from->base_type) {
  286       case GLSL_TYPE_INT: return ir_unop_i2i64;
  287       default: return (ir_expression_operation)0;
  288       }
  289 
  290    default: return (ir_expression_operation)0;
  291    }
  292 }
  293 
  294 
  295 /**
  296  * If a conversion is available, convert one operand to a different type
  297  *
  298  * The \c from \c ir_rvalue is converted "in place".
  299  *
  300  * \param to     Type that the operand it to be converted to
  301  * \param from   Operand that is being converted
  302  * \param state  GLSL compiler state
  303  *
  304  * \return
  305  * If a conversion is possible (or unnecessary), \c true is returned.
  306  * Otherwise \c false is returned.
  307  */
  308 static bool
  309 apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
  310                           struct _mesa_glsl_parse_state *state)
  311 {
  312    void *ctx = state;
  313    if (to->base_type == from->type->base_type)
  314       return true;
  315 
  316    /* Prior to GLSL 1.20, there are no implicit conversions */
  317    if (!state->has_implicit_conversions())
  318       return false;
  319 
  320    /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
  321     *
  322     *    "There are no implicit array or structure conversions. For
  323     *    example, an array of int cannot be implicitly converted to an
  324     *    array of float.
  325     */
  326    if (!to->is_numeric() || !from->type->is_numeric())
  327       return false;
  328 
  329    /* We don't actually want the specific type `to`, we want a type
  330     * with the same base type as `to`, but the same vector width as
  331     * `from`.
  332     */
  333    to = glsl_type::get_instance(to->base_type, from->type->vector_elements,
  334                                 from->type->matrix_columns);
  335 
  336    ir_expression_operation op = get_implicit_conversion_operation(to, from->type, state);
  337    if (op) {
  338       from = new(ctx) ir_expression(op, to, from, NULL);
  339       return true;
  340    } else {
  341       return false;
  342    }
  343 }
  344 
  345 
  346 static const struct glsl_type *
  347 arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  348                        bool multiply,
  349                        struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  350 {
  351    const glsl_type *type_a = value_a->type;
  352    const glsl_type *type_b = value_b->type;
  353 
  354    /* From GLSL 1.50 spec, page 56:
  355     *
  356     *    "The arithmetic binary operators add (+), subtract (-),
  357     *    multiply (*), and divide (/) operate on integer and
  358     *    floating-point scalars, vectors, and matrices."
  359     */
  360    if (!type_a->is_numeric() || !type_b->is_numeric()) {
  361       _mesa_glsl_error(loc, state,
  362                        "operands to arithmetic operators must be numeric");
  363       return glsl_type::error_type;
  364    }
  365 
  366 
  367    /*    "If one operand is floating-point based and the other is
  368     *    not, then the conversions from Section 4.1.10 "Implicit
  369     *    Conversions" are applied to the non-floating-point-based operand."
  370     */
  371    if (!apply_implicit_conversion(type_a, value_b, state)
  372        && !apply_implicit_conversion(type_b, value_a, state)) {
  373       _mesa_glsl_error(loc, state,
  374                        "could not implicitly convert operands to "
  375                        "arithmetic operator");
  376       return glsl_type::error_type;
  377    }
  378    type_a = value_a->type;
  379    type_b = value_b->type;
  380 
  381    /*    "If the operands are integer types, they must both be signed or
  382     *    both be unsigned."
  383     *
  384     * From this rule and the preceeding conversion it can be inferred that
  385     * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
  386     * The is_numeric check above already filtered out the case where either
  387     * type is not one of these, so now the base types need only be tested for
  388     * equality.
  389     */
  390    if (type_a->base_type != type_b->base_type) {
  391       _mesa_glsl_error(loc, state,
  392                        "base type mismatch for arithmetic operator");
  393       return glsl_type::error_type;
  394    }
  395 
  396    /*    "All arithmetic binary operators result in the same fundamental type
  397     *    (signed integer, unsigned integer, or floating-point) as the
  398     *    operands they operate on, after operand type conversion. After
  399     *    conversion, the following cases are valid
  400     *
  401     *    * The two operands are scalars. In this case the operation is
  402     *      applied, resulting in a scalar."
  403     */
  404    if (type_a->is_scalar() && type_b->is_scalar())
  405       return type_a;
  406 
  407    /*   "* One operand is a scalar, and the other is a vector or matrix.
  408     *      In this case, the scalar operation is applied independently to each
  409     *      component of the vector or matrix, resulting in the same size
  410     *      vector or matrix."
  411     */
  412    if (type_a->is_scalar()) {
  413       if (!type_b->is_scalar())
  414          return type_b;
  415    } else if (type_b->is_scalar()) {
  416       return type_a;
  417    }
  418 
  419    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  420     * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
  421     * handled.
  422     */
  423    assert(!type_a->is_scalar());
  424    assert(!type_b->is_scalar());
  425 
  426    /*   "* The two operands are vectors of the same size. In this case, the
  427     *      operation is done component-wise resulting in the same size
  428     *      vector."
  429     */
  430    if (type_a->is_vector() && type_b->is_vector()) {
  431       if (type_a == type_b) {
  432          return type_a;
  433       } else {
  434          _mesa_glsl_error(loc, state,
  435                           "vector size mismatch for arithmetic operator");
  436          return glsl_type::error_type;
  437       }
  438    }
  439 
  440    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  441     * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
  442     * <vector, vector> have been handled.  At least one of the operands must
  443     * be matrix.  Further, since there are no integer matrix types, the base
  444     * type of both operands must be float.
  445     */
  446    assert(type_a->is_matrix() || type_b->is_matrix());
  447    assert(type_a->is_float() || type_a->is_double());
  448    assert(type_b->is_float() || type_b->is_double());
  449 
  450    /*   "* The operator is add (+), subtract (-), or divide (/), and the
  451     *      operands are matrices with the same number of rows and the same
  452     *      number of columns. In this case, the operation is done component-
  453     *      wise resulting in the same size matrix."
  454     *    * The operator is multiply (*), where both operands are matrices or
  455     *      one operand is a vector and the other a matrix. A right vector
  456     *      operand is treated as a column vector and a left vector operand as a
  457     *      row vector. In all these cases, it is required that the number of
  458     *      columns of the left operand is equal to the number of rows of the
  459     *      right operand. Then, the multiply (*) operation does a linear
  460     *      algebraic multiply, yielding an object that has the same number of
  461     *      rows as the left operand and the same number of columns as the right
  462     *      operand. Section 5.10 "Vector and Matrix Operations" explains in
  463     *      more detail how vectors and matrices are operated on."
  464     */
  465    if (! multiply) {
  466       if (type_a == type_b)
  467          return type_a;
  468    } else {
  469       const glsl_type *type = glsl_type::get_mul_type(type_a, type_b);
  470 
  471       if (type == glsl_type::error_type) {
  472          _mesa_glsl_error(loc, state,
  473                           "size mismatch for matrix multiplication");
  474       }
  475 
  476       return type;
  477    }
  478 
  479 
  480    /*    "All other cases are illegal."
  481     */
  482    _mesa_glsl_error(loc, state, "type mismatch");
  483    return glsl_type::error_type;
  484 }
  485 
  486 
  487 static const struct glsl_type *
  488 unary_arithmetic_result_type(const struct glsl_type *type,
  489                              struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  490 {
  491    /* From GLSL 1.50 spec, page 57:
  492     *
  493     *    "The arithmetic unary operators negate (-), post- and pre-increment
  494     *     and decrement (-- and ++) operate on integer or floating-point
  495     *     values (including vectors and matrices). All unary operators work
  496     *     component-wise on their operands. These result with the same type
  497     *     they operated on."
  498     */
  499    if (!type->is_numeric()) {
  500       _mesa_glsl_error(loc, state,
  501                        "operands to arithmetic operators must be numeric");
  502       return glsl_type::error_type;
  503    }
  504 
  505    return type;
  506 }
  507 
  508 /**
  509  * \brief Return the result type of a bit-logic operation.
  510  *
  511  * If the given types to the bit-logic operator are invalid, return
  512  * glsl_type::error_type.
  513  *
  514  * \param value_a LHS of bit-logic op
  515  * \param value_b RHS of bit-logic op
  516  */
  517 static const struct glsl_type *
  518 bit_logic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  519                       ast_operators op,
  520                       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  521 {
  522    const glsl_type *type_a = value_a->type;
  523    const glsl_type *type_b = value_b->type;
  524 
  525    if (!state->check_bitwise_operations_allowed(loc)) {
  526       return glsl_type::error_type;
  527    }
  528 
  529    /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:
  530     *
  531     *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or
  532     *     (|). The operands must be of type signed or unsigned integers or
  533     *     integer vectors."
  534     */
  535    if (!type_a->is_integer_32_64()) {
  536       _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",
  537                         ast_expression::operator_string(op));
  538       return glsl_type::error_type;
  539    }
  540    if (!type_b->is_integer_32_64()) {
  541       _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",
  542                        ast_expression::operator_string(op));
  543       return glsl_type::error_type;
  544    }
  545 
  546    /* Prior to GLSL 4.0 / GL_ARB_gpu_shader5, implicit conversions didn't
  547     * make sense for bitwise operations, as they don't operate on floats.
  548     *
  549     * GLSL 4.0 added implicit int -> uint conversions, which are relevant
  550     * here.  It wasn't clear whether or not we should apply them to bitwise
  551     * operations.  However, Khronos has decided that they should in future
  552     * language revisions.  Applications also rely on this behavior.  We opt
  553     * to apply them in general, but issue a portability warning.
  554     *
  555     * See https://www.khronos.org/bugzilla/show_bug.cgi?id=1405
  556     */
  557    if (type_a->base_type != type_b->base_type) {
  558       if (!apply_implicit_conversion(type_a, value_b, state)
  559           && !apply_implicit_conversion(type_b, value_a, state)) {
  560          _mesa_glsl_error(loc, state,
  561                           "could not implicitly convert operands to "
  562                           "`%s` operator",
  563                           ast_expression::operator_string(op));
  564          return glsl_type::error_type;
  565       } else {
  566          _mesa_glsl_warning(loc, state,
  567                             "some implementations may not support implicit "
  568                             "int -> uint conversions for `%s' operators; "
  569                             "consider casting explicitly for portability",
  570                             ast_expression::operator_string(op));
  571       }
  572       type_a = value_a->type;
  573       type_b = value_b->type;
  574    }
  575 
  576    /*     "The fundamental types of the operands (signed or unsigned) must
  577     *     match,"
  578     */
  579    if (type_a->base_type != type_b->base_type) {
  580       _mesa_glsl_error(loc, state, "operands of `%s' must have the same "
  581                        "base type", ast_expression::operator_string(op));
  582       return glsl_type::error_type;
  583    }
  584 
  585    /*     "The operands cannot be vectors of differing size." */
  586    if (type_a->is_vector() &&
  587        type_b->is_vector() &&
  588        type_a->vector_elements != type_b->vector_elements) {
  589       _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "
  590                        "different sizes", ast_expression::operator_string(op));
  591       return glsl_type::error_type;
  592    }
  593 
  594    /*     "If one operand is a scalar and the other a vector, the scalar is
  595     *     applied component-wise to the vector, resulting in the same type as
  596     *     the vector. The fundamental types of the operands [...] will be the
  597     *     resulting fundamental type."
  598     */
  599    if (type_a->is_scalar())
  600        return type_b;
  601    else
  602        return type_a;
  603 }
  604 
  605 static const struct glsl_type *
  606 modulus_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  607                     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  608 {
  609    const glsl_type *type_a = value_a->type;
  610    const glsl_type *type_b = value_b->type;
  611 
  612    if (!state->EXT_gpu_shader4_enable &&
  613        !state->check_version(130, 300, loc, "operator '%%' is reserved")) {
  614       return glsl_type::error_type;
  615    }
  616 
  617    /* Section 5.9 (Expressions) of the GLSL 4.00 specification says:
  618     *
  619     *    "The operator modulus (%) operates on signed or unsigned integers or
  620     *    integer vectors."
  621     */
  622    if (!type_a->is_integer_32_64()) {
  623       _mesa_glsl_error(loc, state, "LHS of operator %% must be an integer");
  624       return glsl_type::error_type;
  625    }
  626    if (!type_b->is_integer_32_64()) {
  627       _mesa_glsl_error(loc, state, "RHS of operator %% must be an integer");
  628       return glsl_type::error_type;
  629    }
  630 
  631    /*    "If the fundamental types in the operands do not match, then the
  632     *    conversions from section 4.1.10 "Implicit Conversions" are applied
  633     *    to create matching types."
  634     *
  635     * Note that GLSL 4.00 (and GL_ARB_gpu_shader5) introduced implicit
  636     * int -> uint conversion rules.  Prior to that, there were no implicit
  637     * conversions.  So it's harmless to apply them universally - no implicit
  638     * conversions will exist.  If the types don't match, we'll receive false,
  639     * and raise an error, satisfying the GLSL 1.50 spec, page 56:
  640     *
  641     *    "The operand types must both be signed or unsigned."
  642     */
  643    if (!apply_implicit_conversion(type_a, value_b, state) &&
  644        !apply_implicit_conversion(type_b, value_a, state)) {
  645       _mesa_glsl_error(loc, state,
  646                        "could not implicitly convert operands to "
  647                        "modulus (%%) operator");
  648       return glsl_type::error_type;
  649    }
  650    type_a = value_a->type;
  651    type_b = value_b->type;
  652 
  653    /*    "The operands cannot be vectors of differing size. If one operand is
  654     *    a scalar and the other vector, then the scalar is applied component-
  655     *    wise to the vector, resulting in the same type as the vector. If both
  656     *    are vectors of the same size, the result is computed component-wise."
  657     */
  658    if (type_a->is_vector()) {
  659       if (!type_b->is_vector()
  660           || (type_a->vector_elements == type_b->vector_elements))
  661       return type_a;
  662    } else
  663       return type_b;
  664 
  665    /*    "The operator modulus (%) is not defined for any other data types
  666     *    (non-integer types)."
  667     */
  668    _mesa_glsl_error(loc, state, "type mismatch");
  669    return glsl_type::error_type;
  670 }
  671 
  672 
  673 static const struct glsl_type *
  674 relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  675                        struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  676 {
  677    const glsl_type *type_a = value_a->type;
  678    const glsl_type *type_b = value_b->type;
  679 
  680    /* From GLSL 1.50 spec, page 56:
  681     *    "The relational operators greater than (>), less than (<), greater
  682     *    than or equal (>=), and less than or equal (<=) operate only on
  683     *    scalar integer and scalar floating-point expressions."
  684     */
  685    if (!type_a->is_numeric()
  686        || !type_b->is_numeric()
  687        || !type_a->is_scalar()
  688        || !type_b->is_scalar()) {
  689       _mesa_glsl_error(loc, state,
  690                        "operands to relational operators must be scalar and "
  691                        "numeric");
  692       return glsl_type::error_type;
  693    }
  694 
  695    /*    "Either the operands' types must match, or the conversions from
  696     *    Section 4.1.10 "Implicit Conversions" will be applied to the integer
  697     *    operand, after which the types must match."
  698     */
  699    if (!apply_implicit_conversion(type_a, value_b, state)
  700        && !apply_implicit_conversion(type_b, value_a, state)) {
  701       _mesa_glsl_error(loc, state,
  702                        "could not implicitly convert operands to "
  703                        "relational operator");
  704       return glsl_type::error_type;
  705    }
  706    type_a = value_a->type;
  707    type_b = value_b->type;
  708 
  709    if (type_a->base_type != type_b->base_type) {
  710       _mesa_glsl_error(loc, state, "base type mismatch");
  711       return glsl_type::error_type;
  712    }
  713 
  714    /*    "The result is scalar Boolean."
  715     */
  716    return glsl_type::bool_type;
  717 }
  718 
  719 /**
  720  * \brief Return the result type of a bit-shift operation.
  721  *
  722  * If the given types to the bit-shift operator are invalid, return
  723  * glsl_type::error_type.
  724  *
  725  * \param type_a Type of LHS of bit-shift op
  726  * \param type_b Type of RHS of bit-shift op
  727  */
  728 static const struct glsl_type *
  729 shift_result_type(const struct glsl_type *type_a,
  730                   const struct glsl_type *type_b,
  731                   ast_operators op,
  732                   struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  733 {
  734    if (!state->check_bitwise_operations_allowed(loc)) {
  735       return glsl_type::error_type;
  736    }
  737 
  738    /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:
  739     *
  740     *     "The shift operators (<<) and (>>). For both operators, the operands
  741     *     must be signed or unsigned integers or integer vectors. One operand
  742     *     can be signed while the other is unsigned."
  743     */
  744    if (!type_a->is_integer_32_64()) {
  745       _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
  746                        "integer vector", ast_expression::operator_string(op));
  747      return glsl_type::error_type;
  748 
  749    }
  750    if (!type_b->is_integer_32()) {
  751       _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
  752                        "integer vector", ast_expression::operator_string(op));
  753      return glsl_type::error_type;
  754    }
  755 
  756    /*     "If the first operand is a scalar, the second operand has to be
  757     *     a scalar as well."
  758     */
  759    if (type_a->is_scalar() && !type_b->is_scalar()) {
  760       _mesa_glsl_error(loc, state, "if the first operand of %s is scalar, the "
  761                        "second must be scalar as well",
  762                        ast_expression::operator_string(op));
  763      return glsl_type::error_type;
  764    }
  765 
  766    /* If both operands are vectors, check that they have same number of
  767     * elements.
  768     */
  769    if (type_a->is_vector() &&
  770       type_b->is_vector() &&
  771       type_a->vector_elements != type_b->vector_elements) {
  772       _mesa_glsl_error(loc, state, "vector operands to operator %s must "
  773                        "have same number of elements",
  774                        ast_expression::operator_string(op));
  775      return glsl_type::error_type;
  776    }
  777 
  778    /*     "In all cases, the resulting type will be the same type as the left
  779     *     operand."
  780     */
  781    return type_a;
  782 }
  783 
  784 /**
  785  * Returns the innermost array index expression in an rvalue tree.
  786  * This is the largest indexing level -- if an array of blocks, then
  787  * it is the block index rather than an indexing expression for an
  788  * array-typed member of an array of blocks.
  789  */
  790 static ir_rvalue *
  791 find_innermost_array_index(ir_rvalue *rv)
  792 {
  793    ir_dereference_array *last = NULL;
  794    while (rv) {
  795       if (rv->as_dereference_array()) {
  796          last = rv->as_dereference_array();
  797          rv = last->array;
  798       } else if (rv->as_dereference_record())
  799          rv = rv->as_dereference_record()->record;
  800       else if (rv->as_swizzle())
  801          rv = rv->as_swizzle()->val;
  802       else
  803          rv = NULL;
  804    }
  805 
  806    if (last)
  807       return last->array_index;
  808 
  809    return NULL;
  810 }
  811 
  812 /**
  813  * Validates that a value can be assigned to a location with a specified type
  814  *
  815  * Validates that \c rhs can be assigned to some location.  If the types are
  816  * not an exact match but an automatic conversion is possible, \c rhs will be
  817  * converted.
  818  *
  819  * \return
  820  * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
  821  * Otherwise the actual RHS to be assigned will be returned.  This may be
  822  * \c rhs, or it may be \c rhs after some type conversion.
  823  *
  824  * \note
  825  * In addition to being used for assignments, this function is used to
  826  * type-check return values.
  827  */
  828 static ir_rvalue *
  829 validate_assignment(struct _mesa_glsl_parse_state *state,
  830                     YYLTYPE loc, ir_rvalue *lhs,
  831                     ir_rvalue *rhs, bool is_initializer)
  832 {
  833    /* If there is already some error in the RHS, just return it.  Anything
  834     * else will lead to an avalanche of error message back to the user.
  835     */
  836    if (rhs->type->is_error())
  837       return rhs;
  838 
  839    /* In the Tessellation Control Shader:
  840     * If a per-vertex output variable is used as an l-value, it is an error
  841     * if the expression indicating the vertex number is not the identifier
  842     * `gl_InvocationID`.
  843     */
  844    if (state->stage == MESA_SHADER_TESS_CTRL && !lhs->type->is_error()) {
  845       ir_variable *var = lhs->variable_referenced();
  846       if (var && var->data.mode == ir_var_shader_out && !var->data.patch) {
  847          ir_rvalue *index = find_innermost_array_index(lhs);
  848          ir_variable *index_var = index ? index->variable_referenced() : NULL;
  849          if (!index_var || strcmp(index_var->name, "gl_InvocationID") != 0) {
  850             _mesa_glsl_error(&loc, state,
  851                              "Tessellation control shader outputs can only "
  852                              "be indexed by gl_InvocationID");
  853             return NULL;
  854          }
  855       }
  856    }
  857 
  858    /* If the types are identical, the assignment can trivially proceed.
  859     */
  860    if (rhs->type == lhs->type)
  861       return rhs;
  862 
  863    /* If the array element types are the same and the LHS is unsized,
  864     * the assignment is okay for initializers embedded in variable
  865     * declarations.
  866     *
  867     * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
  868     * is handled by ir_dereference::is_lvalue.
  869     */
  870    const glsl_type *lhs_t = lhs->type;
  871    const glsl_type *rhs_t = rhs->type;
  872    bool unsized_array = false;
  873    while(lhs_t->is_array()) {
  874       if (rhs_t == lhs_t)
  875          break; /* the rest of the inner arrays match so break out early */
  876       if (!rhs_t->is_array()) {
  877          unsized_array = false;
  878          break; /* number of dimensions mismatch */
  879       }
  880       if (lhs_t->length == rhs_t->length) {
  881          lhs_t = lhs_t->fields.array;
  882          rhs_t = rhs_t->fields.array;
  883          continue;
  884       } else if (lhs_t->is_unsized_array()) {
  885          unsized_array = true;
  886       } else {
  887          unsized_array = false;
  888          break; /* sized array mismatch */
  889       }
  890       lhs_t = lhs_t->fields.array;
  891       rhs_t = rhs_t->fields.array;
  892    }
  893    if (unsized_array) {
  894       if (is_initializer) {
  895          if (rhs->type->get_scalar_type() == lhs->type->get_scalar_type())
  896             return rhs;
  897       } else {
  898          _mesa_glsl_error(&loc, state,
  899                           "implicitly sized arrays cannot be assigned");
  900          return NULL;
  901       }
  902    }
  903 
  904    /* Check for implicit conversion in GLSL 1.20 */
  905    if (apply_implicit_conversion(lhs->type, rhs, state)) {
  906       if (rhs->type == lhs->type)
  907          return rhs;
  908    }
  909 
  910    _mesa_glsl_error(&loc, state,
  911                     "%s of type %s cannot be assigned to "
  912                     "variable of type %s",
  913                     is_initializer ? "initializer" : "value",
  914                     rhs->type->name, lhs->type->name);
  915 
  916    return NULL;
  917 }
  918 
  919 static void
  920 mark_whole_array_access(ir_rvalue *access)
  921 {
  922    ir_dereference_variable *deref = access->as_dereference_variable();
  923 
  924    if (deref && deref->var) {
  925       deref->var->data.max_array_access = deref->type->length - 1;
  926    }
  927 }
  928 
  929 static bool
  930 do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
  931               const char *non_lvalue_description,
  932               ir_rvalue *lhs, ir_rvalue *rhs,
  933               ir_rvalue **out_rvalue, bool needs_rvalue,
  934               bool is_initializer,
  935               YYLTYPE lhs_loc)
  936 {
  937    void *ctx = state;
  938    bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());
  939 
  940    ir_variable *lhs_var = lhs->variable_referenced();
  941    if (lhs_var)
  942       lhs_var->data.assigned = true;
  943 
  944    if (!error_emitted) {
  945       if (non_lvalue_description != NULL) {
  946          _mesa_glsl_error(&lhs_loc, state,
  947                           "assignment to %s",
  948                           non_lvalue_description);
  949          error_emitted = true;
  950       } else if (lhs_var != NULL && (lhs_var->data.read_only ||
  951                  (lhs_var->data.mode == ir_var_shader_storage &&
  952                   lhs_var->data.memory_read_only))) {
  953          /* We can have memory_read_only set on both images and buffer variables,
  954           * but in the former there is a distinction between assignments to
  955           * the variable itself (read_only) and to the memory they point to
  956           * (memory_read_only), while in the case of buffer variables there is
  957           * no such distinction, that is why this check here is limited to
  958           * buffer variables alone.
  959           */
  960          _mesa_glsl_error(&lhs_loc, state,
  961                           "assignment to read-only variable '%s'",
  962                           lhs_var->name);
  963          error_emitted = true;
  964       } else if (lhs->type->is_array() &&
  965                  !state->check_version(120, 300, &lhs_loc,
  966                                        "whole array assignment forbidden")) {
  967          /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
  968           *
  969           *    "Other binary or unary expressions, non-dereferenced
  970           *     arrays, function names, swizzles with repeated fields,
  971           *     and constants cannot be l-values."
  972           *
  973           * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
  974           */
  975          error_emitted = true;
  976       } else if (!lhs->is_lvalue(state)) {
  977          _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
  978          error_emitted = true;
  979       }
  980    }
  981 
  982    ir_rvalue *new_rhs =
  983       validate_assignment(state, lhs_loc, lhs, rhs, is_initializer);
  984    if (new_rhs != NULL) {
  985       rhs = new_rhs;
  986 
  987       /* If the LHS array was not declared with a size, it takes it size from
  988        * the RHS.  If the LHS is an l-value and a whole array, it must be a
  989        * dereference of a variable.  Any other case would require that the LHS
  990        * is either not an l-value or not a whole array.
  991        */
  992       if (lhs->type->is_unsized_array()) {
  993          ir_dereference *const d = lhs->as_dereference();
  994 
  995          assert(d != NULL);
  996 
  997          ir_variable *const var = d->variable_referenced();
  998 
  999          assert(var != NULL);
 1000 
 1001          if (var->data.max_array_access >= rhs->type->array_size()) {
 1002             /* FINISHME: This should actually log the location of the RHS. */
 1003             _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
 1004                              "previous access",
 1005                              var->data.max_array_access);
 1006          }
 1007 
 1008          var->type = glsl_type::get_array_instance(lhs->type->fields.array,
 1009                                                    rhs->type->array_size());
 1010          d->type = var->type;
 1011       }
 1012       if (lhs->type->is_array()) {
 1013          mark_whole_array_access(rhs);
 1014          mark_whole_array_access(lhs);
 1015       }
 1016    } else {
 1017      error_emitted = true;
 1018    }
 1019 
 1020    /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,
 1021     * but not post_inc) need the converted assigned value as an rvalue
 1022     * to handle things like:
 1023     *
 1024     * i = j += 1;
 1025     */
 1026    if (needs_rvalue) {
 1027       ir_rvalue *rvalue;
 1028       if (!error_emitted) {
 1029          ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
 1030                                                  ir_var_temporary);
 1031          instructions->push_tail(var);
 1032          instructions->push_tail(assign(var, rhs));
 1033 
 1034          ir_dereference_variable *deref_var =
 1035             new(ctx) ir_dereference_variable(var);
 1036          instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var));
 1037          rvalue = new(ctx) ir_dereference_variable(var);
 1038       } else {
 1039          rvalue = ir_rvalue::error_value(ctx);
 1040       }
 1041       *out_rvalue = rvalue;
 1042    } else {
 1043       if (!error_emitted)
 1044          instructions->push_tail(new(ctx) ir_assignment(lhs, rhs));
 1045       *out_rvalue = NULL;
 1046    }
 1047 
 1048    return error_emitted;
 1049 }
 1050 
 1051 static ir_rvalue *
 1052 get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
 1053 {
 1054    void *ctx = ralloc_parent(lvalue);
 1055    ir_variable *var;
 1056 
 1057    var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
 1058                               ir_var_temporary);
 1059    instructions->push_tail(var);
 1060 
 1061    instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
 1062                                                   lvalue));
 1063 
 1064    return new(ctx) ir_dereference_variable(var);
 1065 }
 1066 
 1067 
 1068 ir_rvalue *
 1069 ast_node::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
 1070 {
 1071    (void) instructions;
 1072    (void) state;
 1073 
 1074    return NULL;
 1075 }
 1076 
 1077 bool
 1078 ast_node::has_sequence_subexpression() const
 1079 {
 1080    return false;
 1081 }
 1082 
 1083 void
 1084 ast_node::set_is_lhs(bool /* new_value */)
 1085 {
 1086 }
 1087 
 1088 void
 1089 ast_function_expression::hir_no_rvalue(exec_list *instructions,
 1090                                        struct _mesa_glsl_parse_state *state)
 1091 {
 1092    (void)hir(instructions, state);
 1093 }
 1094 
 1095 void
 1096 ast_aggregate_initializer::hir_no_rvalue(exec_list *instructions,
 1097                                          struct _mesa_glsl_parse_state *state)
 1098 {
 1099    (void)hir(instructions, state);
 1100 }
 1101 
 1102 static ir_rvalue *
 1103 do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
 1104 {
 1105    int join_op;
 1106    ir_rvalue *cmp = NULL;
 1107 
 1108    if (operation == ir_binop_all_equal)
 1109       join_op = ir_binop_logic_and;
 1110    else
 1111       join_op = ir_binop_logic_or;
 1112 
 1113    switch (op0->type->base_type) {
 1114    case GLSL_TYPE_FLOAT:
 1115    case GLSL_TYPE_FLOAT16:
 1116    case GLSL_TYPE_UINT:
 1117    case GLSL_TYPE_INT:
 1118    case GLSL_TYPE_BOOL:
 1119    case GLSL_TYPE_DOUBLE:
 1120    case GLSL_TYPE_UINT64:
 1121    case GLSL_TYPE_INT64:
 1122    case GLSL_TYPE_UINT16:
 1123    case GLSL_TYPE_INT16:
 1124    case GLSL_TYPE_UINT8:
 1125    case GLSL_TYPE_INT8:
 1126       return new(mem_ctx) ir_expression(operation, op0, op1);
 1127 
 1128    case GLSL_TYPE_ARRAY: {
 1129       for (unsigned int i = 0; i < op0->type->length; i++) {
 1130          ir_rvalue *e0, *e1, *result;
 1131 
 1132          e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
 1133                                                 new(mem_ctx) ir_constant(i));
 1134          e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
 1135                                                 new(mem_ctx) ir_constant(i));
 1136          result = do_comparison(mem_ctx, operation, e0, e1);
 1137 
 1138          if (cmp) {
 1139             cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
 1140          } else {
 1141             cmp = result;
 1142          }
 1143       }
 1144 
 1145       mark_whole_array_access(op0);
 1146       mark_whole_array_access(op1);
 1147       break;
 1148    }
 1149 
 1150    case GLSL_TYPE_STRUCT: {
 1151       for (unsigned int i = 0; i < op0->type->length; i++) {
 1152          ir_rvalue *e0, *e1, *result;
 1153          const char *field_name = op0->type->fields.structure[i].name;
 1154 
 1155          e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
 1156                                                  field_name);
 1157          e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
 1158                                                  field_name);
 1159          result = do_comparison(mem_ctx, operation, e0, e1);
 1160 
 1161          if (cmp) {
 1162             cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
 1163          } else {
 1164             cmp = result;
 1165          }
 1166       }
 1167       break;
 1168    }
 1169 
 1170    case GLSL_TYPE_ERROR:
 1171    case GLSL_TYPE_VOID:
 1172    case GLSL_TYPE_SAMPLER:
 1173    case GLSL_TYPE_IMAGE:
 1174    case GLSL_TYPE_INTERFACE:
 1175    case GLSL_TYPE_ATOMIC_UINT:
 1176    case GLSL_TYPE_SUBROUTINE:
 1177    case GLSL_TYPE_FUNCTION:
 1178       /* I assume a comparison of a struct containing a sampler just
 1179        * ignores the sampler present in the type.
 1180        */
 1181       break;
 1182    }
 1183 
 1184    if (cmp == NULL)
 1185       cmp = new(mem_ctx) ir_constant(true);
 1186 
 1187    return cmp;
 1188 }
 1189 
 1190 /* For logical operations, we want to ensure that the operands are
 1191  * scalar booleans.  If it isn't, emit an error and return a constant
 1192  * boolean to avoid triggering cascading error messages.
 1193  */
 1194 static ir_rvalue *
 1195 get_scalar_boolean_operand(exec_list *instructions,
 1196                            struct _mesa_glsl_parse_state *state,
 1197                            ast_expression *parent_expr,
 1198                            int operand,
 1199                            const char *operand_name,
 1200                            bool *error_emitted)
 1201 {
 1202    ast_expression *expr = parent_expr->subexpressions[operand];
 1203    void *ctx = state;
 1204    ir_rvalue *val = expr->hir(instructions, state);
 1205 
 1206    if (val->type->is_boolean() && val->type->is_scalar())
 1207       return val;
 1208 
 1209    if (!*error_emitted) {
 1210       YYLTYPE loc = expr->get_location();
 1211       _mesa_glsl_error(&loc, state, "%s of `%s' must be scalar boolean",
 1212                        operand_name,
 1213                        parent_expr->operator_string(parent_expr->oper));
 1214       *error_emitted = true;
 1215    }
 1216 
 1217    return new(ctx) ir_constant(true);
 1218 }
 1219 
 1220 /**
 1221  * If name refers to a builtin array whose maximum allowed size is less than
 1222  * size, report an error and return true.  Otherwise return false.
 1223  */
 1224 void
 1225 check_builtin_array_max_size(const char *name, unsigned size,
 1226                              YYLTYPE loc, struct _mesa_glsl_parse_state *state)
 1227 {
 1228    if ((strcmp("gl_TexCoord", name) == 0)
 1229        && (size > state->Const.MaxTextureCoords)) {
 1230       /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 1231        *
 1232        *     "The size [of gl_TexCoord] can be at most
 1233        *     gl_MaxTextureCoords."
 1234        */
 1235       _mesa_glsl_error(&loc, state, "`gl_TexCoord' array size cannot "
 1236                        "be larger than gl_MaxTextureCoords (%u)",
 1237                        state->Const.MaxTextureCoords);
 1238    } else if (strcmp("gl_ClipDistance", name) == 0) {
 1239       state->clip_dist_size = size;
 1240       if (size + state->cull_dist_size > state->Const.MaxClipPlanes) {
 1241          /* From section 7.1 (Vertex Shader Special Variables) of the
 1242           * GLSL 1.30 spec:
 1243           *
 1244           *   "The gl_ClipDistance array is predeclared as unsized and
 1245           *   must be sized by the shader either redeclaring it with a
 1246           *   size or indexing it only with integral constant
 1247           *   expressions. ... The size can be at most
 1248           *   gl_MaxClipDistances."
 1249           */
 1250          _mesa_glsl_error(&loc, state, "`gl_ClipDistance' array size cannot "
 1251                           "be larger than gl_MaxClipDistances (%u)",
 1252                           state->Const.MaxClipPlanes);
 1253       }
 1254    } else if (strcmp("gl_CullDistance", name) == 0) {
 1255       state->cull_dist_size = size;
 1256       if (size + state->clip_dist_size > state->Const.MaxClipPlanes) {
 1257          /* From the ARB_cull_distance spec:
 1258           *
 1259           *   "The gl_CullDistance array is predeclared as unsized and
 1260           *    must be sized by the shader either redeclaring it with
 1261           *    a size or indexing it only with integral constant
 1262           *    expressions. The size determines the number and set of
 1263           *    enabled cull distances and can be at most
 1264           *    gl_MaxCullDistances."
 1265           */
 1266          _mesa_glsl_error(&loc, state, "`gl_CullDistance' array size cannot "
 1267                           "be larger than gl_MaxCullDistances (%u)",
 1268                           state->Const.MaxClipPlanes);
 1269       }
 1270    }
 1271 }
 1272 
 1273 /**
 1274  * Create the constant 1, of a which is appropriate for incrementing and
 1275  * decrementing values of the given GLSL type.  For example, if type is vec4,
 1276  * this creates a constant value of 1.0 having type float.
 1277  *
 1278  * If the given type is invalid for increment and decrement operators, return
 1279  * a floating point 1--the error will be detected later.
 1280  */
 1281 static ir_rvalue *
 1282 constant_one_for_inc_dec(void *ctx, const glsl_type *type)
 1283 {
 1284    switch (type->base_type) {
 1285    case GLSL_TYPE_UINT:
 1286       return new(ctx) ir_constant((unsigned) 1);
 1287    case GLSL_TYPE_INT:
 1288       return new(ctx) ir_constant(1);
 1289    case GLSL_TYPE_UINT64:
 1290       return new(ctx) ir_constant((uint64_t) 1);
 1291    case GLSL_TYPE_INT64:
 1292       return new(ctx) ir_constant((int64_t) 1);
 1293    default:
 1294    case GLSL_TYPE_FLOAT:
 1295       return new(ctx) ir_constant(1.0f);
 1296    }
 1297 }
 1298 
 1299 ir_rvalue *
 1300 ast_expression::hir(exec_list *instructions,
 1301                     struct _mesa_glsl_parse_state *state)
 1302 {
 1303    return do_hir(instructions, state, true);
 1304 }
 1305 
 1306 void
 1307 ast_expression::hir_no_rvalue(exec_list *instructions,
 1308                               struct _mesa_glsl_parse_state *state)
 1309 {
 1310    do_hir(instructions, state, false);
 1311 }
 1312 
 1313 void
 1314 ast_expression::set_is_lhs(bool new_value)
 1315 {
 1316    /* is_lhs is tracked only to print "variable used uninitialized" warnings,
 1317     * if we lack an identifier we can just skip it.
 1318     */
 1319    if (this->primary_expression.identifier == NULL)
 1320       return;
 1321 
 1322    this->is_lhs = new_value;
 1323 
 1324    /* We need to go through the subexpressions tree to cover cases like
 1325     * ast_field_selection
 1326     */
 1327    if (this->subexpressions[0] != NULL)
 1328       this->subexpressions[0]->set_is_lhs(new_value);
 1329 }
 1330 
 1331 ir_rvalue *
 1332 ast_expression::do_hir(exec_list *instructions,
 1333                        struct _mesa_glsl_parse_state *state,
 1334                        bool needs_rvalue)
 1335 {
 1336    void *ctx = state;
 1337    static const int operations[AST_NUM_OPERATORS] = {
 1338       -1,               /* ast_assign doesn't convert to ir_expression. */
 1339       -1,               /* ast_plus doesn't convert to ir_expression. */
 1340       ir_unop_neg,
 1341       ir_binop_add,
 1342       ir_binop_sub,
 1343       ir_binop_mul,
 1344       ir_binop_div,
 1345       ir_binop_mod,
 1346       ir_binop_lshift,
 1347       ir_binop_rshift,
 1348       ir_binop_less,
 1349       ir_binop_less,    /* This is correct.  See the ast_greater case below. */
 1350       ir_binop_gequal,  /* This is correct.  See the ast_lequal case below. */
 1351       ir_binop_gequal,
 1352       ir_binop_all_equal,
 1353       ir_binop_any_nequal,
 1354       ir_binop_bit_and,
 1355       ir_binop_bit_xor,
 1356       ir_binop_bit_or,
 1357       ir_unop_bit_not,
 1358       ir_binop_logic_and,
 1359       ir_binop_logic_xor,
 1360       ir_binop_logic_or,
 1361       ir_unop_logic_not,
 1362 
 1363       /* Note: The following block of expression types actually convert
 1364        * to multiple IR instructions.
 1365        */
 1366       ir_binop_mul,     /* ast_mul_assign */
 1367       ir_binop_div,     /* ast_div_assign */
 1368       ir_binop_mod,     /* ast_mod_assign */
 1369       ir_binop_add,     /* ast_add_assign */
 1370       ir_binop_sub,     /* ast_sub_assign */
 1371       ir_binop_lshift,  /* ast_ls_assign */
 1372       ir_binop_rshift,  /* ast_rs_assign */
 1373       ir_binop_bit_and, /* ast_and_assign */
 1374       ir_binop_bit_xor, /* ast_xor_assign */
 1375       ir_binop_bit_or,  /* ast_or_assign */
 1376 
 1377       -1,               /* ast_conditional doesn't convert to ir_expression. */
 1378       ir_binop_add,     /* ast_pre_inc. */
 1379       ir_binop_sub,     /* ast_pre_dec. */
 1380       ir_binop_add,     /* ast_post_inc. */
 1381       ir_binop_sub,     /* ast_post_dec. */
 1382       -1,               /* ast_field_selection doesn't conv to ir_expression. */
 1383       -1,               /* ast_array_index doesn't convert to ir_expression. */
 1384       -1,               /* ast_function_call doesn't conv to ir_expression. */
 1385       -1,               /* ast_identifier doesn't convert to ir_expression. */
 1386       -1,               /* ast_int_constant doesn't convert to ir_expression. */
 1387       -1,               /* ast_uint_constant doesn't conv to ir_expression. */
 1388       -1,               /* ast_float_constant doesn't conv to ir_expression. */
 1389       -1,               /* ast_bool_constant doesn't conv to ir_expression. */
 1390       -1,               /* ast_sequence doesn't convert to ir_expression. */
 1391       -1,               /* ast_aggregate shouldn't ever even get here. */
 1392    };
 1393    ir_rvalue *result = NULL;
 1394    ir_rvalue *op[3];
 1395    const struct glsl_type *type, *orig_type;
 1396    bool error_emitted = false;
 1397    YYLTYPE loc;
 1398 
 1399    loc = this->get_location();
 1400 
 1401    switch (this->oper) {
 1402    case ast_aggregate:
 1403       unreachable("ast_aggregate: Should never get here.");
 1404 
 1405    case ast_assign: {
 1406       this->subexpressions[0]->set_is_lhs(true);
 1407       op[0] = this->subexpressions[0]->hir(instructions, state);
 1408       op[1] = this->subexpressions[1]->hir(instructions, state);
 1409 
 1410       error_emitted =
 1411          do_assignment(instructions, state,
 1412                        this->subexpressions[0]->non_lvalue_description,
 1413                        op[0], op[1], &result, needs_rvalue, false,
 1414                        this->subexpressions[0]->get_location());
 1415       break;
 1416    }
 1417 
 1418    case ast_plus:
 1419       op[0] = this->subexpressions[0]->hir(instructions, state);
 1420 
 1421       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
 1422 
 1423       error_emitted = type->is_error();
 1424 
 1425       result = op[0];
 1426       break;
 1427 
 1428    case ast_neg:
 1429       op[0] = this->subexpressions[0]->hir(instructions, state);
 1430 
 1431       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
 1432 
 1433       error_emitted = type->is_error();
 1434 
 1435       result = new(ctx) ir_expression(operations[this->oper], type,
 1436                                       op[0], NULL);
 1437       break;
 1438 
 1439    case ast_add:
 1440    case ast_sub:
 1441    case ast_mul:
 1442    case ast_div:
 1443       op[0] = this->subexpressions[0]->hir(instructions, state);
 1444       op[1] = this->subexpressions[1]->hir(instructions, state);
 1445 
 1446       type = arithmetic_result_type(op[0], op[1],
 1447                                     (this->oper == ast_mul),
 1448                                     state, & loc);
 1449       error_emitted = type->is_error();
 1450 
 1451       result = new(ctx) ir_expression(operations[this->oper], type,
 1452                                       op[0], op[1]);
 1453       break;
 1454 
 1455    case ast_mod:
 1456       op[0] = this->subexpressions[0]->hir(instructions, state);
 1457       op[1] = this->subexpressions[1]->hir(instructions, state);
 1458 
 1459       type = modulus_result_type(op[0], op[1], state, &loc);
 1460 
 1461       assert(operations[this->oper] == ir_binop_mod);
 1462 
 1463       result = new(ctx) ir_expression(operations[this->oper], type,
 1464                                       op[0], op[1]);
 1465       error_emitted = type->is_error();
 1466       break;
 1467 
 1468    case ast_lshift:
 1469    case ast_rshift:
 1470        if (!state->check_bitwise_operations_allowed(&loc)) {
 1471           error_emitted = true;
 1472        }
 1473 
 1474        op[0] = this->subexpressions[0]->hir(instructions, state);
 1475        op[1] = this->subexpressions[1]->hir(instructions, state);
 1476        type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
 1477                                 &loc);
 1478        result = new(ctx) ir_expression(operations[this->oper], type,
 1479                                        op[0], op[1]);
 1480        error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
 1481        break;
 1482 
 1483    case ast_less:
 1484    case ast_greater:
 1485    case ast_lequal:
 1486    case ast_gequal:
 1487       op[0] = this->subexpressions[0]->hir(instructions, state);
 1488       op[1] = this->subexpressions[1]->hir(instructions, state);
 1489 
 1490       type = relational_result_type(op[0], op[1], state, & loc);
 1491 
 1492       /* The relational operators must either generate an error or result
 1493        * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.
 1494        */
 1495       assert(type->is_error()
 1496              || (type->is_boolean() && type->is_scalar()));
 1497 
 1498       /* Like NIR, GLSL IR does not have opcodes for > or <=.  Instead, swap
 1499        * the arguments and use < or >=.
 1500        */
 1501       if (this->oper == ast_greater || this->oper == ast_lequal) {
 1502          ir_rvalue *const tmp = op[0];
 1503          op[0] = op[1];
 1504          op[1] = tmp;
 1505       }
 1506 
 1507       result = new(ctx) ir_expression(operations[this->oper], type,
 1508                                       op[0], op[1]);
 1509       error_emitted = type->is_error();
 1510       break;
 1511 
 1512    case ast_nequal:
 1513    case ast_equal:
 1514       op[0] = this->subexpressions[0]->hir(instructions, state);
 1515       op[1] = this->subexpressions[1]->hir(instructions, state);
 1516 
 1517       /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
 1518        *
 1519        *    "The equality operators equal (==), and not equal (!=)
 1520        *    operate on all types. They result in a scalar Boolean. If
 1521        *    the operand types do not match, then there must be a
 1522        *    conversion from Section 4.1.10 "Implicit Conversions"
 1523        *    applied to one operand that can make them match, in which
 1524        *    case this conversion is done."
 1525        */
 1526 
 1527       if (op[0]->type == glsl_type::void_type || op[1]->type == glsl_type::void_type) {
 1528          _mesa_glsl_error(& loc, state, "`%s':  wrong operand types: "
 1529                          "no operation `%1$s' exists that takes a left-hand "
 1530                          "operand of type 'void' or a right operand of type "
 1531                          "'void'", (this->oper == ast_equal) ? "==" : "!=");
 1532          error_emitted = true;
 1533       } else if ((!apply_implicit_conversion(op[0]->type, op[1], state)
 1534            && !apply_implicit_conversion(op[1]->type, op[0], state))
 1535           || (op[0]->type != op[1]->type)) {
 1536          _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
 1537                           "type", (this->oper == ast_equal) ? "==" : "!=");
 1538          error_emitted = true;
 1539       } else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
 1540                  !state->check_version(120, 300, &loc,
 1541                                        "array comparisons forbidden")) {
 1542          error_emitted = true;
 1543       } else if ((op[0]->type->contains_subroutine() ||
 1544                   op[1]->type->contains_subroutine())) {
 1545          _mesa_glsl_error(&loc, state, "subroutine comparisons forbidden");
 1546          error_emitted = true;
 1547       } else if ((op[0]->type->contains_opaque() ||
 1548                   op[1]->type->contains_opaque())) {
 1549          _mesa_glsl_error(&loc, state, "opaque type comparisons forbidden");
 1550          error_emitted = true;
 1551       }
 1552 
 1553       if (error_emitted) {
 1554          result = new(ctx) ir_constant(false);
 1555       } else {
 1556          result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
 1557          assert(result->type == glsl_type::bool_type);
 1558       }
 1559       break;
 1560 
 1561    case ast_bit_and:
 1562    case ast_bit_xor:
 1563    case ast_bit_or:
 1564       op[0] = this->subexpressions[0]->hir(instructions, state);
 1565       op[1] = this->subexpressions[1]->hir(instructions, state);
 1566       type = bit_logic_result_type(op[0], op[1], this->oper, state, &loc);
 1567       result = new(ctx) ir_expression(operations[this->oper], type,
 1568                                       op[0], op[1]);
 1569       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
 1570       break;
 1571 
 1572    case ast_bit_not:
 1573       op[0] = this->subexpressions[0]->hir(instructions, state);
 1574 
 1575       if (!state->check_bitwise_operations_allowed(&loc)) {
 1576          error_emitted = true;
 1577       }
 1578 
 1579       if (!op[0]->type->is_integer_32_64()) {
 1580          _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
 1581          error_emitted = true;
 1582       }
 1583 
 1584       type = error_emitted ? glsl_type::error_type : op[0]->type;
 1585       result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);
 1586       break;
 1587 
 1588    case ast_logic_and: {
 1589       exec_list rhs_instructions;
 1590       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
 1591                                          "LHS", &error_emitted);
 1592       op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
 1593                                          "RHS", &error_emitted);
 1594 
 1595       if (rhs_instructions.is_empty()) {
 1596          result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
 1597       } else {
 1598          ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
 1599                                                        "and_tmp",
 1600                                                        ir_var_temporary);
 1601          instructions->push_tail(tmp);
 1602 
 1603          ir_if *const stmt = new(ctx) ir_if(op[0]);
 1604          instructions->push_tail(stmt);
 1605 
 1606          stmt->then_instructions.append_list(&rhs_instructions);
 1607          ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
 1608          ir_assignment *const then_assign =
 1609             new(ctx) ir_assignment(then_deref, op[1]);
 1610          stmt->then_instructions.push_tail(then_assign);
 1611 
 1612          ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
 1613          ir_assignment *const else_assign =
 1614             new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
 1615          stmt->else_instructions.push_tail(else_assign);
 1616 
 1617          result = new(ctx) ir_dereference_variable(tmp);
 1618       }
 1619       break;
 1620    }
 1621 
 1622    case ast_logic_or: {
 1623       exec_list rhs_instructions;
 1624       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
 1625                                          "LHS", &error_emitted);
 1626       op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
 1627                                          "RHS", &error_emitted);
 1628 
 1629       if (rhs_instructions.is_empty()) {
 1630          result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
 1631       } else {
 1632          ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
 1633                                                        "or_tmp",
 1634                                                        ir_var_temporary);
 1635          instructions->push_tail(tmp);
 1636 
 1637          ir_if *const stmt = new(ctx) ir_if(op[0]);
 1638          instructions->push_tail(stmt);
 1639 
 1640          ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
 1641          ir_assignment *const then_assign =
 1642             new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
 1643          stmt->then_instructions.push_tail(then_assign);
 1644 
 1645          stmt->else_instructions.append_list(&rhs_instructions);
 1646          ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
 1647          ir_assignment *const else_assign =
 1648             new(ctx) ir_assignment(else_deref, op[1]);
 1649          stmt->else_instructions.push_tail(else_assign);
 1650 
 1651          result = new(ctx) ir_dereference_variable(tmp);
 1652       }
 1653       break;
 1654    }
 1655 
 1656    case ast_logic_xor:
 1657       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
 1658        *
 1659        *    "The logical binary operators and (&&), or ( | | ), and
 1660        *     exclusive or (^^). They operate only on two Boolean
 1661        *     expressions and result in a Boolean expression."
 1662        */
 1663       op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
 1664                                          &error_emitted);
 1665       op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
 1666                                          &error_emitted);
 1667 
 1668       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
 1669                                       op[0], op[1]);
 1670       break;
 1671 
 1672    case ast_logic_not:
 1673       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
 1674                                          "operand", &error_emitted);
 1675 
 1676       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
 1677                                       op[0], NULL);
 1678       break;
 1679 
 1680    case ast_mul_assign:
 1681    case ast_div_assign:
 1682    case ast_add_assign:
 1683    case ast_sub_assign: {
 1684       this->subexpressions[0]->set_is_lhs(true);
 1685       op[0] = this->subexpressions[0]->hir(instructions, state);
 1686       op[1] = this->subexpressions[1]->hir(instructions, state);
 1687 
 1688       orig_type = op[0]->type;
 1689 
 1690       /* Break out if operand types were not parsed successfully. */
 1691       if ((op[0]->type == glsl_type::error_type ||
 1692            op[1]->type == glsl_type::error_type)) {
 1693          error_emitted = true;
 1694          break;
 1695       }
 1696 
 1697       type = arithmetic_result_type(op[0], op[1],
 1698                                     (this->oper == ast_mul_assign),
 1699                                     state, & loc);
 1700 
 1701       if (type != orig_type) {
 1702          _mesa_glsl_error(& loc, state,
 1703                           "could not implicitly convert "
 1704                           "%s to %s", type->name, orig_type->name);
 1705          type = glsl_type::error_type;
 1706       }
 1707 
 1708       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
 1709                                                    op[0], op[1]);
 1710 
 1711       error_emitted =
 1712          do_assignment(instructions, state,
 1713                        this->subexpressions[0]->non_lvalue_description,
 1714                        op[0]->clone(ctx, NULL), temp_rhs,
 1715                        &result, needs_rvalue, false,
 1716                        this->subexpressions[0]->get_location());
 1717 
 1718       /* GLSL 1.10 does not allow array assignment.  However, we don't have to
 1719        * explicitly test for this because none of the binary expression
 1720        * operators allow array operands either.
 1721        */
 1722 
 1723       break;
 1724    }
 1725 
 1726    case ast_mod_assign: {
 1727       this->subexpressions[0]->set_is_lhs(true);
 1728       op[0] = this->subexpressions[0]->hir(instructions, state);
 1729       op[1] = this->subexpressions[1]->hir(instructions, state);
 1730 
 1731       orig_type = op[0]->type;
 1732       type = modulus_result_type(op[0], op[1], state, &loc);
 1733 
 1734       if (type != orig_type) {
 1735          _mesa_glsl_error(& loc, state,
 1736                           "could not implicitly convert "
 1737                           "%s to %s", type->name, orig_type->name);
 1738          type = glsl_type::error_type;
 1739       }
 1740 
 1741       assert(operations[this->oper] == ir_binop_mod);
 1742 
 1743       ir_rvalue *temp_rhs;
 1744       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
 1745                                         op[0], op[1]);
 1746 
 1747       error_emitted =
 1748          do_assignment(instructions, state,
 1749                        this->subexpressions[0]->non_lvalue_description,
 1750                        op[0]->clone(ctx, NULL), temp_rhs,
 1751                        &result, needs_rvalue, false,
 1752                        this->subexpressions[0]->get_location());
 1753       break;
 1754    }
 1755 
 1756    case ast_ls_assign:
 1757    case ast_rs_assign: {
 1758       this->subexpressions[0]->set_is_lhs(true);
 1759       op[0] = this->subexpressions[0]->hir(instructions, state);
 1760       op[1] = this->subexpressions[1]->hir(instructions, state);
 1761       type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
 1762                                &loc);
 1763       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
 1764                                                    type, op[0], op[1]);
 1765       error_emitted =
 1766          do_assignment(instructions, state,
 1767                        this->subexpressions[0]->non_lvalue_description,
 1768                        op[0]->clone(ctx, NULL), temp_rhs,
 1769                        &result, needs_rvalue, false,
 1770                        this->subexpressions[0]->get_location());
 1771       break;
 1772    }
 1773 
 1774    case ast_and_assign:
 1775    case ast_xor_assign:
 1776    case ast_or_assign: {
 1777       this->subexpressions[0]->set_is_lhs(true);
 1778       op[0] = this->subexpressions[0]->hir(instructions, state);
 1779       op[1] = this->subexpressions[1]->hir(instructions, state);
 1780 
 1781       orig_type = op[0]->type;
 1782       type = bit_logic_result_type(op[0], op[1], this->oper, state, &loc);
 1783 
 1784       if (type != orig_type) {
 1785          _mesa_glsl_error(& loc, state,
 1786                           "could not implicitly convert "
 1787                           "%s to %s", type->name, orig_type->name);
 1788          type = glsl_type::error_type;
 1789       }
 1790 
 1791       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
 1792                                                    type, op[0], op[1]);
 1793       error_emitted =
 1794          do_assignment(instructions, state,
 1795                        this->subexpressions[0]->non_lvalue_description,
 1796                        op[0]->clone(ctx, NULL), temp_rhs,
 1797                        &result, needs_rvalue, false,
 1798                        this->subexpressions[0]->get_location());
 1799       break;
 1800    }
 1801 
 1802    case ast_conditional: {
 1803       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
 1804        *
 1805        *    "The ternary selection operator (?:). It operates on three
 1806        *    expressions (exp1 ? exp2 : exp3). This operator evaluates the
 1807        *    first expression, which must result in a scalar Boolean."
 1808        */
 1809       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
 1810                                          "condition", &error_emitted);
 1811 
 1812       /* The :? operator is implemented by generating an anonymous temporary
 1813        * followed by an if-statement.  The last instruction in each branch of
 1814        * the if-statement assigns a value to the anonymous temporary.  This
 1815        * temporary is the r-value of the expression.
 1816        */
 1817       exec_list then_instructions;
 1818       exec_list else_instructions;
 1819 
 1820       op[1] = this->subexpressions[1]->hir(&then_instructions, state);
 1821       op[2] = this->subexpressions[2]->hir(&else_instructions, state);
 1822 
 1823       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
 1824        *
 1825        *     "The second and third expressions can be any type, as
 1826        *     long their types match, or there is a conversion in
 1827        *     Section 4.1.10 "Implicit Conversions" that can be applied
 1828        *     to one of the expressions to make their types match. This
 1829        *     resulting matching type is the type of the entire
 1830        *     expression."
 1831        */
 1832       if ((!apply_implicit_conversion(op[1]->type, op[2], state)
 1833           && !apply_implicit_conversion(op[2]->type, op[1], state))
 1834           || (op[1]->type != op[2]->type)) {
 1835          YYLTYPE loc = this->subexpressions[1]->get_location();
 1836 
 1837          _mesa_glsl_error(& loc, state, "second and third operands of ?: "
 1838                           "operator must have matching types");
 1839          error_emitted = true;
 1840          type = glsl_type::error_type;
 1841       } else {
 1842          type = op[1]->type;
 1843       }
 1844 
 1845       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
 1846        *
 1847        *    "The second and third expressions must be the same type, but can
 1848        *    be of any type other than an array."
 1849        */
 1850       if (type->is_array() &&
 1851           !state->check_version(120, 300, &loc,
 1852                                 "second and third operands of ?: operator "
 1853                                 "cannot be arrays")) {
 1854          error_emitted = true;
 1855       }
 1856 
 1857       /* From section 4.1.7 of the GLSL 4.50 spec (Opaque Types):
 1858        *
 1859        *  "Except for array indexing, structure member selection, and
 1860        *   parentheses, opaque variables are not allowed to be operands in
 1861        *   expressions; such use results in a compile-time error."
 1862        */
 1863       if (type->contains_opaque()) {
 1864          if (!(state->has_bindless() && (type->is_image() || type->is_sampler()))) {
 1865             _mesa_glsl_error(&loc, state, "variables of type %s cannot be "
 1866                              "operands of the ?: operator", type->name);
 1867             error_emitted = true;
 1868          }
 1869       }
 1870 
 1871       ir_constant *cond_val = op[0]->constant_expression_value(ctx);
 1872 
 1873       if (then_instructions.is_empty()
 1874           && else_instructions.is_empty()
 1875           && cond_val != NULL) {
 1876          result = cond_val->value.b[0] ? op[1] : op[2];
 1877       } else {
 1878          /* The copy to conditional_tmp reads the whole array. */
 1879          if (type->is_array()) {
 1880             mark_whole_array_access(op[1]);
 1881             mark_whole_array_access(op[2]);
 1882          }
 1883 
 1884          ir_variable *const tmp =
 1885             new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
 1886          instructions->push_tail(tmp);
 1887 
 1888          ir_if *const stmt = new(ctx) ir_if(op[0]);
 1889          instructions->push_tail(stmt);
 1890 
 1891          then_instructions.move_nodes_to(& stmt->then_instructions);
 1892          ir_dereference *const then_deref =
 1893             new(ctx) ir_dereference_variable(tmp);
 1894          ir_assignment *const then_assign =
 1895             new(ctx) ir_assignment(then_deref, op[1]);
 1896          stmt->then_instructions.push_tail(then_assign);
 1897 
 1898          else_instructions.move_nodes_to(& stmt->else_instructions);
 1899          ir_dereference *const else_deref =
 1900             new(ctx) ir_dereference_variable(tmp);
 1901          ir_assignment *const else_assign =
 1902             new(ctx) ir_assignment(else_deref, op[2]);
 1903          stmt->else_instructions.push_tail(else_assign);
 1904 
 1905          result = new(ctx) ir_dereference_variable(tmp);
 1906       }
 1907       break;
 1908    }
 1909 
 1910    case ast_pre_inc:
 1911    case ast_pre_dec: {
 1912       this->non_lvalue_description = (this->oper == ast_pre_inc)
 1913          ? "pre-increment operation" : "pre-decrement operation";
 1914 
 1915       op[0] = this->subexpressions[0]->hir(instructions, state);
 1916       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
 1917 
 1918       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
 1919 
 1920       ir_rvalue *temp_rhs;
 1921       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
 1922                                         op[0], op[1]);
 1923 
 1924       error_emitted =
 1925          do_assignment(instructions, state,
 1926                        this->subexpressions[0]->non_lvalue_description,
 1927                        op[0]->clone(ctx, NULL), temp_rhs,
 1928                        &result, needs_rvalue, false,
 1929                        this->subexpressions[0]->get_location());
 1930       break;
 1931    }
 1932 
 1933    case ast_post_inc:
 1934    case ast_post_dec: {
 1935       this->non_lvalue_description = (this->oper == ast_post_inc)
 1936          ? "post-increment operation" : "post-decrement operation";
 1937       op[0] = this->subexpressions[0]->hir(instructions, state);
 1938       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
 1939 
 1940       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
 1941 
 1942       if (error_emitted) {
 1943          result = ir_rvalue::error_value(ctx);
 1944          break;
 1945       }
 1946 
 1947       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
 1948 
 1949       ir_rvalue *temp_rhs;
 1950       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
 1951                                         op[0], op[1]);
 1952 
 1953       /* Get a temporary of a copy of the lvalue before it's modified.
 1954        * This may get thrown away later.
 1955        */
 1956       result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
 1957 
 1958       ir_rvalue *junk_rvalue;
 1959       error_emitted =
 1960          do_assignment(instructions, state,
 1961                        this->subexpressions[0]->non_lvalue_description,
 1962                        op[0]->clone(ctx, NULL), temp_rhs,
 1963                        &junk_rvalue, false, false,
 1964                        this->subexpressions[0]->get_location());
 1965 
 1966       break;
 1967    }
 1968 
 1969    case ast_field_selection:
 1970       result = _mesa_ast_field_selection_to_hir(this, instructions, state);
 1971       break;
 1972 
 1973    case ast_array_index: {
 1974       YYLTYPE index_loc = subexpressions[1]->get_location();
 1975 
 1976       /* Getting if an array is being used uninitialized is beyond what we get
 1977        * from ir_value.data.assigned. Setting is_lhs as true would force to
 1978        * not raise a uninitialized warning when using an array
 1979        */
 1980       subexpressions[0]->set_is_lhs(true);
 1981       op[0] = subexpressions[0]->hir(instructions, state);
 1982       op[1] = subexpressions[1]->hir(instructions, state);
 1983 
 1984       result = _mesa_ast_array_index_to_hir(ctx, state, op[0], op[1],
 1985                                             loc, index_loc);
 1986 
 1987       if (result->type->is_error())
 1988          error_emitted = true;
 1989 
 1990       break;
 1991    }
 1992 
 1993    case ast_unsized_array_dim:
 1994       unreachable("ast_unsized_array_dim: Should never get here.");
 1995 
 1996    case ast_function_call:
 1997       /* Should *NEVER* get here.  ast_function_call should always be handled
 1998        * by ast_function_expression::hir.
 1999        */
 2000       unreachable("ast_function_call: handled elsewhere ");
 2001 
 2002    case ast_identifier: {
 2003       /* ast_identifier can appear several places in a full abstract syntax
 2004        * tree.  This particular use must be at location specified in the grammar
 2005        * as 'variable_identifier'.
 2006        */
 2007       ir_variable *var =
 2008          state->symbols->get_variable(this->primary_expression.identifier);
 2009 
 2010       if (var == NULL) {
 2011          /* the identifier might be a subroutine name */
 2012          char *sub_name;
 2013          sub_name = ralloc_asprintf(ctx, "%s_%s", _mesa_shader_stage_to_subroutine_prefix(state->stage), this->primary_expression.identifier);
 2014          var = state->symbols->get_variable(sub_name);
 2015          ralloc_free(sub_name);
 2016       }
 2017 
 2018       if (var != NULL) {
 2019          var->data.used = true;
 2020          result = new(ctx) ir_dereference_variable(var);
 2021 
 2022          if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_shader_out)
 2023              && !this->is_lhs
 2024              && result->variable_referenced()->data.assigned != true
 2025              && !is_gl_identifier(var->name)) {
 2026             _mesa_glsl_warning(&loc, state, "`%s' used uninitialized",
 2027                                this->primary_expression.identifier);
 2028          }
 2029 
 2030          /* From the EXT_shader_framebuffer_fetch spec:
 2031           *
 2032           *   "Unless the GL_EXT_shader_framebuffer_fetch extension has been
 2033           *    enabled in addition, it's an error to use gl_LastFragData if it
 2034           *    hasn't been explicitly redeclared with layout(noncoherent)."
 2035           */
 2036          if (var->data.fb_fetch_output && var->data.memory_coherent &&
 2037              !state->EXT_shader_framebuffer_fetch_enable) {
 2038             _mesa_glsl_error(&loc, state,
 2039                              "invalid use of framebuffer fetch output not "
 2040                              "qualified with layout(noncoherent)");
 2041          }
 2042 
 2043       } else {
 2044          _mesa_glsl_error(& loc, state, "`%s' undeclared",
 2045                           this->primary_expression.identifier);
 2046 
 2047          result = ir_rvalue::error_value(ctx);
 2048          error_emitted = true;
 2049       }
 2050       break;
 2051    }
 2052 
 2053    case ast_int_constant:
 2054       result = new(ctx) ir_constant(this->primary_expression.int_constant);
 2055       break;
 2056 
 2057    case ast_uint_constant:
 2058       result = new(ctx) ir_constant(this->primary_expression.uint_constant);
 2059       break;
 2060 
 2061    case ast_float_constant:
 2062       result = new(ctx) ir_constant(this->primary_expression.float_constant);
 2063       break;
 2064 
 2065    case ast_bool_constant:
 2066       result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
 2067       break;
 2068 
 2069    case ast_double_constant:
 2070       result = new(ctx) ir_constant(this->primary_expression.double_constant);
 2071       break;
 2072 
 2073    case ast_uint64_constant:
 2074       result = new(ctx) ir_constant(this->primary_expression.uint64_constant);
 2075       break;
 2076 
 2077    case ast_int64_constant:
 2078       result = new(ctx) ir_constant(this->primary_expression.int64_constant);
 2079       break;
 2080 
 2081    case ast_sequence: {
 2082       /* It should not be possible to generate a sequence in the AST without
 2083        * any expressions in it.
 2084        */
 2085       assert(!this->expressions.is_empty());
 2086 
 2087       /* The r-value of a sequence is the last expression in the sequence.  If
 2088        * the other expressions in the sequence do not have side-effects (and
 2089        * therefore add instructions to the instruction list), they get dropped
 2090        * on the floor.
 2091        */
 2092       exec_node *previous_tail = NULL;
 2093       YYLTYPE previous_operand_loc = loc;
 2094 
 2095       foreach_list_typed (ast_node, ast, link, &this->expressions) {
 2096          /* If one of the operands of comma operator does not generate any
 2097           * code, we want to emit a warning.  At each pass through the loop
 2098           * previous_tail will point to the last instruction in the stream
 2099           * *before* processing the previous operand.  Naturally,
 2100           * instructions->get_tail_raw() will point to the last instruction in
 2101           * the stream *after* processing the previous operand.  If the two
 2102           * pointers match, then the previous operand had no effect.
 2103           *
 2104           * The warning behavior here differs slightly from GCC.  GCC will
 2105           * only emit a warning if none of the left-hand operands have an
 2106           * effect.  However, it will emit a warning for each.  I believe that
 2107           * there are some cases in C (especially with GCC extensions) where
 2108           * it is useful to have an intermediate step in a sequence have no
 2109           * effect, but I don't think these cases exist in GLSL.  Either way,
 2110           * it would be a giant hassle to replicate that behavior.
 2111           */
 2112          if (previous_tail == instructions->get_tail_raw()) {
 2113             _mesa_glsl_warning(&previous_operand_loc, state,
 2114                                "left-hand operand of comma expression has "
 2115                                "no effect");
 2116          }
 2117 
 2118          /* The tail is directly accessed instead of using the get_tail()
 2119           * method for performance reasons.  get_tail() has extra code to
 2120           * return NULL when the list is empty.  We don't care about that
 2121           * here, so using get_tail_raw() is fine.
 2122           */
 2123          previous_tail = instructions->get_tail_raw();
 2124          previous_operand_loc = ast->get_location();
 2125 
 2126          result = ast->hir(instructions, state);
 2127       }
 2128 
 2129       /* Any errors should have already been emitted in the loop above.
 2130        */
 2131       error_emitted = true;
 2132       break;
 2133    }
 2134    }
 2135    type = NULL; /* use result->type, not type. */
 2136    assert(error_emitted || (result != NULL || !needs_rvalue));
 2137 
 2138    if (result && result->type->is_error() && !error_emitted)
 2139       _mesa_glsl_error(& loc, state, "type mismatch");
 2140 
 2141    return result;
 2142 }
 2143 
 2144 bool
 2145 ast_expression::has_sequence_subexpression() const
 2146 {
 2147    switch (this->oper) {
 2148    case ast_plus:
 2149    case ast_neg:
 2150    case ast_bit_not:
 2151    case ast_logic_not:
 2152    case ast_pre_inc:
 2153    case ast_pre_dec:
 2154    case ast_post_inc:
 2155    case ast_post_dec:
 2156       return this->subexpressions[0]->has_sequence_subexpression();
 2157 
 2158    case ast_assign:
 2159    case ast_add:
 2160    case ast_sub:
 2161    case ast_mul:
 2162    case ast_div:
 2163    case ast_mod:
 2164    case ast_lshift:
 2165    case ast_rshift:
 2166    case ast_less:
 2167    case ast_greater:
 2168    case ast_lequal:
 2169    case ast_gequal:
 2170    case ast_nequal:
 2171    case ast_equal:
 2172    case ast_bit_and:
 2173    case ast_bit_xor:
 2174    case ast_bit_or:
 2175    case ast_logic_and:
 2176    case ast_logic_or:
 2177    case ast_logic_xor:
 2178    case ast_array_index:
 2179    case ast_mul_assign:
 2180    case ast_div_assign:
 2181    case ast_add_assign:
 2182    case ast_sub_assign:
 2183    case ast_mod_assign:
 2184    case ast_ls_assign:
 2185    case ast_rs_assign:
 2186    case ast_and_assign:
 2187    case ast_xor_assign:
 2188    case ast_or_assign:
 2189       return this->subexpressions[0]->has_sequence_subexpression() ||
 2190              this->subexpressions[1]->has_sequence_subexpression();
 2191 
 2192    case ast_conditional:
 2193       return this->subexpressions[0]->has_sequence_subexpression() ||
 2194              this->subexpressions[1]->has_sequence_subexpression() ||
 2195              this->subexpressions[2]->has_sequence_subexpression();
 2196 
 2197    case ast_sequence:
 2198       return true;
 2199 
 2200    case ast_field_selection:
 2201    case ast_identifier:
 2202    case ast_int_constant:
 2203    case ast_uint_constant:
 2204    case ast_float_constant:
 2205    case ast_bool_constant:
 2206    case ast_double_constant:
 2207    case ast_int64_constant:
 2208    case ast_uint64_constant:
 2209       return false;
 2210 
 2211    case ast_aggregate:
 2212       return false;
 2213 
 2214    case ast_function_call:
 2215       unreachable("should be handled by ast_function_expression::hir");
 2216 
 2217    case ast_unsized_array_dim:
 2218       unreachable("ast_unsized_array_dim: Should never get here.");
 2219    }
 2220 
 2221    return false;
 2222 }
 2223 
 2224 ir_rvalue *
 2225 ast_expression_statement::hir(exec_list *instructions,
 2226                               struct _mesa_glsl_parse_state *state)
 2227 {
 2228    /* It is possible to have expression statements that don't have an
 2229     * expression.  This is the solitary semicolon:
 2230     *
 2231     * for (i = 0; i < 5; i++)
 2232     *     ;
 2233     *
 2234     * In this case the expression will be NULL.  Test for NULL and don't do
 2235     * anything in that case.
 2236     */
 2237    if (expression != NULL)
 2238       expression->hir_no_rvalue(instructions, state);
 2239 
 2240    /* Statements do not have r-values.
 2241     */
 2242    return NULL;
 2243 }
 2244 
 2245 
 2246 ir_rvalue *
 2247 ast_compound_statement::hir(exec_list *instructions,
 2248                             struct _mesa_glsl_parse_state *state)
 2249 {
 2250    if (new_scope)
 2251       state->symbols->push_scope();
 2252 
 2253    foreach_list_typed (ast_node, ast, link, &this->statements)
 2254       ast->hir(instructions, state);
 2255 
 2256    if (new_scope)
 2257       state->symbols->pop_scope();
 2258 
 2259    /* Compound statements do not have r-values.
 2260     */
 2261    return NULL;
 2262 }
 2263 
 2264 /**
 2265  * Evaluate the given exec_node (which should be an ast_node representing
 2266  * a single array dimension) and return its integer value.
 2267  */
 2268 static unsigned
 2269 process_array_size(exec_node *node,
 2270                    struct _mesa_glsl_parse_state *state)
 2271 {
 2272    void *mem_ctx = state;
 2273 
 2274    exec_list dummy_instructions;
 2275 
 2276    ast_node *array_size = exec_node_data(ast_node, node, link);
 2277 
 2278    /**
 2279     * Dimensions other than the outermost dimension can by unsized if they
 2280     * are immediately sized by a constructor or initializer.
 2281     */
 2282    if (((ast_expression*)array_size)->oper == ast_unsized_array_dim)
 2283       return 0;
 2284 
 2285    ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
 2286    YYLTYPE loc = array_size->get_location();
 2287 
 2288    if (ir == NULL) {
 2289       _mesa_glsl_error(& loc, state,
 2290                        "array size could not be resolved");
 2291       return 0;
 2292    }
 2293 
 2294    if (!ir->type->is_integer_32()) {
 2295       _mesa_glsl_error(& loc, state,
 2296                        "array size must be integer type");
 2297       return 0;
 2298    }
 2299 
 2300    if (!ir->type->is_scalar()) {
 2301       _mesa_glsl_error(& loc, state,
 2302                        "array size must be scalar type");
 2303       return 0;
 2304    }
 2305 
 2306    ir_constant *const size = ir->constant_expression_value(mem_ctx);
 2307    if (size == NULL ||
 2308        (state->is_version(120, 300) &&
 2309         array_size->has_sequence_subexpression())) {
 2310       _mesa_glsl_error(& loc, state, "array size must be a "
 2311                        "constant valued expression");
 2312       return 0;
 2313    }
 2314 
 2315    if (size->value.i[0] <= 0) {
 2316       _mesa_glsl_error(& loc, state, "array size must be > 0");
 2317       return 0;
 2318    }
 2319 
 2320    assert(size->type == ir->type);
 2321 
 2322    /* If the array size is const (and we've verified that
 2323     * it is) then no instructions should have been emitted
 2324     * when we converted it to HIR. If they were emitted,
 2325     * then either the array size isn't const after all, or
 2326     * we are emitting unnecessary instructions.
 2327     */
 2328    assert(dummy_instructions.is_empty());
 2329 
 2330    return size->value.u[0];
 2331 }
 2332 
 2333 static const glsl_type *
 2334 process_array_type(YYLTYPE *loc, const glsl_type *base,
 2335                    ast_array_specifier *array_specifier,
 2336                    struct _mesa_glsl_parse_state *state)
 2337 {
 2338    const glsl_type *array_type = base;
 2339 
 2340    if (array_specifier != NULL) {
 2341       if (base->is_array()) {
 2342 
 2343          /* From page 19 (page 25) of the GLSL 1.20 spec:
 2344           *
 2345           * "Only one-dimensional arrays may be declared."
 2346           */
 2347          if (!state->check_arrays_of_arrays_allowed(loc)) {
 2348             return glsl_type::error_type;
 2349          }
 2350       }
 2351 
 2352       for (exec_node *node = array_specifier->array_dimensions.get_tail_raw();
 2353            !node->is_head_sentinel(); node = node->prev) {
 2354          unsigned array_size = process_array_size(node, state);
 2355          array_type = glsl_type::get_array_instance(array_type, array_size);
 2356       }
 2357    }
 2358 
 2359    return array_type;
 2360 }
 2361 
 2362 static bool
 2363 precision_qualifier_allowed(const glsl_type *type)
 2364 {
 2365    /* Precision qualifiers apply to floating point, integer and opaque
 2366     * types.
 2367     *
 2368     * Section 4.5.2 (Precision Qualifiers) of the GLSL 1.30 spec says:
 2369     *    "Any floating point or any integer declaration can have the type
 2370     *    preceded by one of these precision qualifiers [...] Literal
 2371     *    constants do not have precision qualifiers. Neither do Boolean
 2372     *    variables.
 2373     *
 2374     * Section 4.5 (Precision and Precision Qualifiers) of the GLSL 1.30
 2375     * spec also says:
 2376     *
 2377     *     "Precision qualifiers are added for code portability with OpenGL
 2378     *     ES, not for functionality. They have the same syntax as in OpenGL
 2379     *     ES."
 2380     *
 2381     * Section 8 (Built-In Functions) of the GLSL ES 1.00 spec says:
 2382     *
 2383     *     "uniform lowp sampler2D sampler;
 2384     *     highp vec2 coord;
 2385     *     ...
 2386     *     lowp vec4 col = texture2D (sampler, coord);
 2387     *                                            // texture2D returns lowp"
 2388     *
 2389     * From this, we infer that GLSL 1.30 (and later) should allow precision
 2390     * qualifiers on sampler types just like float and integer types.
 2391     */
 2392    const glsl_type *const t = type->without_array();
 2393 
 2394    return (t->is_float() || t->is_integer_32() || t->contains_opaque()) &&
 2395           !t->is_struct();
 2396 }
 2397 
 2398 const glsl_type *
 2399 ast_type_specifier::glsl_type(const char **name,
 2400                               struct _mesa_glsl_parse_state *state) const
 2401 {
 2402    const struct glsl_type *type;
 2403 
 2404    if (this->type != NULL)
 2405       type = this->type;
 2406    else if (structure)
 2407       type = structure->type;
 2408    else
 2409       type = state->symbols->get_type(this->type_name);
 2410    *name = this->type_name;
 2411 
 2412    YYLTYPE loc = this->get_location();
 2413    type = process_array_type(&loc, type, this->array_specifier, state);
 2414 
 2415    return type;
 2416 }
 2417 
 2418 /**
 2419  * From the OpenGL ES 3.0 spec, 4.5.4 Default Precision Qualifiers:
 2420  *
 2421  * "The precision statement
 2422  *
 2423  *    precision precision-qualifier type;
 2424  *
 2425  *  can be used to establish a default precision qualifier. The type field can
 2426  *  be either int or float or any of the sampler types, (...) If type is float,
 2427  *  the directive applies to non-precision-qualified floating point type
 2428  *  (scalar, vector, and matrix) declarations. If type is int, the directive
 2429  *  applies to all non-precision-qualified integer type (scalar, vector, signed,
 2430  *  and unsigned) declarations."
 2431  *
 2432  * We use the symbol table to keep the values of the default precisions for
 2433  * each 'type' in each scope and we use the 'type' string from the precision
 2434  * statement as key in the symbol table. When we want to retrieve the default
 2435  * precision associated with a given glsl_type we need to know the type string
 2436  * associated with it. This is what this function returns.
 2437  */
 2438 static const char *
 2439 get_type_name_for_precision_qualifier(const glsl_type *type)
 2440 {
 2441    switch (type->base_type) {
 2442    case GLSL_TYPE_FLOAT:
 2443       return "float";
 2444    case GLSL_TYPE_UINT:
 2445    case GLSL_TYPE_INT:
 2446       return "int";
 2447    case GLSL_TYPE_ATOMIC_UINT:
 2448       return "atomic_uint";
 2449    case GLSL_TYPE_IMAGE:
 2450    /* fallthrough */
 2451    case GLSL_TYPE_SAMPLER: {
 2452       const unsigned type_idx =
 2453          type->sampler_array + 2 * type->sampler_shadow;
 2454       const unsigned offset = type->is_sampler() ? 0 : 4;
 2455       assert(type_idx < 4);
 2456       switch (type->sampled_type) {
 2457       case GLSL_TYPE_FLOAT:
 2458          switch (type->sampler_dimensionality) {
 2459          case GLSL_SAMPLER_DIM_1D: {
 2460             assert(type->is_sampler());
 2461             static const char *const names[4] = {
 2462               "sampler1D", "sampler1DArray",
 2463               "sampler1DShadow", "sampler1DArrayShadow"
 2464             };
 2465             return names[type_idx];
 2466          }
 2467          case GLSL_SAMPLER_DIM_2D: {
 2468             static const char *const names[8] = {
 2469               "sampler2D", "sampler2DArray",
 2470               "sampler2DShadow", "sampler2DArrayShadow",
 2471               "image2D", "image2DArray", NULL, NULL
 2472             };
 2473             return names[offset + type_idx];
 2474          }
 2475          case GLSL_SAMPLER_DIM_3D: {
 2476             static const char *const names[8] = {
 2477               "sampler3D", NULL, NULL, NULL,
 2478               "image3D", NULL, NULL, NULL
 2479             };
 2480             return names[offset + type_idx];
 2481          }
 2482          case GLSL_SAMPLER_DIM_CUBE: {
 2483             static const char *const names[8] = {
 2484               "samplerCube", "samplerCubeArray",
 2485               "samplerCubeShadow", "samplerCubeArrayShadow",
 2486               "imageCube", NULL, NULL, NULL
 2487             };
 2488             return names[offset + type_idx];
 2489          }
 2490          case GLSL_SAMPLER_DIM_MS: {
 2491             assert(type->is_sampler());
 2492             static const char *const names[4] = {
 2493               "sampler2DMS", "sampler2DMSArray", NULL, NULL
 2494             };
 2495             return names[type_idx];
 2496          }
 2497          case GLSL_SAMPLER_DIM_RECT: {
 2498             assert(type->is_sampler());
 2499             static const char *const names[4] = {
 2500               "samplerRect", NULL, "samplerRectShadow", NULL
 2501             };
 2502             return names[type_idx];
 2503          }
 2504          case GLSL_SAMPLER_DIM_BUF: {
 2505             static const char *const names[8] = {
 2506               "samplerBuffer", NULL, NULL, NULL,
 2507               "imageBuffer", NULL, NULL, NULL
 2508             };
 2509             return names[offset + type_idx];
 2510          }
 2511          case GLSL_SAMPLER_DIM_EXTERNAL: {
 2512             assert(type->is_sampler());
 2513             static const char *const names[4] = {
 2514               "samplerExternalOES", NULL, NULL, NULL
 2515             };
 2516             return names[type_idx];
 2517          }
 2518          default:
 2519             unreachable("Unsupported sampler/image dimensionality");
 2520          } /* sampler/image float dimensionality */
 2521          break;
 2522       case GLSL_TYPE_INT:
 2523          switch (type->sampler_dimensionality) {
 2524          case GLSL_SAMPLER_DIM_1D: {
 2525             assert(type->is_sampler());
 2526             static const char *const names[4] = {
 2527               "isampler1D", "isampler1DArray", NULL, NULL
 2528             };
 2529             return names[type_idx];
 2530          }
 2531          case GLSL_SAMPLER_DIM_2D: {
 2532             static const char *const names[8] = {
 2533               "isampler2D", "isampler2DArray", NULL, NULL,
 2534               "iimage2D", "iimage2DArray", NULL, NULL
 2535             };
 2536             return names[offset + type_idx];
 2537          }
 2538          case GLSL_SAMPLER_DIM_3D: {
 2539             static const char *const names[8] = {
 2540               "isampler3D", NULL, NULL, NULL,
 2541               "iimage3D", NULL, NULL, NULL
 2542             };
 2543             return names[offset + type_idx];
 2544          }
 2545          case GLSL_SAMPLER_DIM_CUBE: {
 2546             static const char *const names[8] = {
 2547               "isamplerCube", "isamplerCubeArray", NULL, NULL,
 2548               "iimageCube", NULL, NULL, NULL
 2549             };
 2550             return names[offset + type_idx];
 2551          }
 2552          case GLSL_SAMPLER_DIM_MS: {
 2553             assert(type->is_sampler());
 2554             static const char *const names[4] = {
 2555               "isampler2DMS", "isampler2DMSArray", NULL, NULL
 2556             };
 2557             return names[type_idx];
 2558          }
 2559          case GLSL_SAMPLER_DIM_RECT: {
 2560             assert(type->is_sampler());
 2561             static const char *const names[4] = {
 2562               "isamplerRect", NULL, "isamplerRectShadow", NULL
 2563             };
 2564             return names[type_idx];
 2565          }
 2566          case GLSL_SAMPLER_DIM_BUF: {
 2567             static const char *const names[8] = {
 2568               "isamplerBuffer", NULL, NULL, NULL,
 2569               "iimageBuffer", NULL, NULL, NULL
 2570             };
 2571             return names[offset + type_idx];
 2572          }
 2573          default:
 2574             unreachable("Unsupported isampler/iimage dimensionality");
 2575          } /* sampler/image int dimensionality */
 2576          break;
 2577       case GLSL_TYPE_UINT:
 2578          switch (type->sampler_dimensionality) {
 2579          case GLSL_SAMPLER_DIM_1D: {
 2580             assert(type->is_sampler());
 2581             static const char *const names[4] = {
 2582               "usampler1D", "usampler1DArray", NULL, NULL
 2583             };
 2584             return names[type_idx];
 2585          }
 2586          case GLSL_SAMPLER_DIM_2D: {
 2587             static const char *const names[8] = {
 2588               "usampler2D", "usampler2DArray", NULL, NULL,
 2589               "uimage2D", "uimage2DArray", NULL, NULL
 2590             };
 2591             return names[offset + type_idx];
 2592          }
 2593          case GLSL_SAMPLER_DIM_3D: {
 2594             static const char *const names[8] = {
 2595               "usampler3D", NULL, NULL, NULL,
 2596               "uimage3D", NULL, NULL, NULL
 2597             };
 2598             return names[offset + type_idx];
 2599          }
 2600          case GLSL_SAMPLER_DIM_CUBE: {
 2601             static const char *const names[8] = {
 2602               "usamplerCube", "usamplerCubeArray", NULL, NULL,
 2603               "uimageCube", NULL, NULL, NULL
 2604             };
 2605             return names[offset + type_idx];
 2606          }
 2607          case GLSL_SAMPLER_DIM_MS: {
 2608             assert(type->is_sampler());
 2609             static const char *const names[4] = {
 2610               "usampler2DMS", "usampler2DMSArray", NULL, NULL
 2611             };
 2612             return names[type_idx];
 2613          }
 2614          case GLSL_SAMPLER_DIM_RECT: {
 2615             assert(type->is_sampler());
 2616             static const char *const names[4] = {
 2617               "usamplerRect", NULL, "usamplerRectShadow", NULL
 2618             };
 2619             return names[type_idx];
 2620          }
 2621          case GLSL_SAMPLER_DIM_BUF: {
 2622             static const char *const names[8] = {
 2623               "usamplerBuffer", NULL, NULL, NULL,
 2624               "uimageBuffer", NULL, NULL, NULL
 2625             };
 2626             return names[offset + type_idx];
 2627          }
 2628          default:
 2629             unreachable("Unsupported usampler/uimage dimensionality");
 2630          } /* sampler/image uint dimensionality */
 2631          break;
 2632       default:
 2633          unreachable("Unsupported sampler/image type");
 2634       } /* sampler/image type */
 2635       break;
 2636    } /* GLSL_TYPE_SAMPLER/GLSL_TYPE_IMAGE */
 2637    break;
 2638    default:
 2639       unreachable("Unsupported type");
 2640    } /* base type */
 2641 }
 2642 
 2643 static unsigned
 2644 select_gles_precision(unsigned qual_precision,
 2645                       const glsl_type *type,
 2646                       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
 2647 {
 2648    /* Precision qualifiers do not have any meaning in Desktop GLSL.
 2649     * In GLES we take the precision from the type qualifier if present,
 2650     * otherwise, if the type of the variable allows precision qualifiers at
 2651     * all, we look for the default precision qualifier for that type in the
 2652     * current scope.
 2653     */
 2654    assert(state->es_shader);
 2655 
 2656    unsigned precision = GLSL_PRECISION_NONE;
 2657    if (qual_precision) {
 2658       precision = qual_precision;
 2659    } else if (precision_qualifier_allowed(type)) {
 2660       const char *type_name =
 2661          get_type_name_for_precision_qualifier(type->without_array());
 2662       assert(type_name != NULL);
 2663 
 2664       precision =
 2665          state->symbols->get_default_precision_qualifier(type_name);
 2666       if (precision == ast_precision_none) {
 2667          _mesa_glsl_error(loc, state,
 2668                           "No precision specified in this scope for type `%s'",
 2669                           type->name);
 2670       }
 2671    }
 2672 
 2673 
 2674    /* Section 4.1.7.3 (Atomic Counters) of the GLSL ES 3.10 spec says:
 2675     *
 2676     *    "The default precision of all atomic types is highp. It is an error to
 2677     *    declare an atomic type with a different precision or to specify the
 2678     *    default precision for an atomic type to be lowp or mediump."
 2679     */
 2680    if (type->is_atomic_uint() && precision != ast_precision_high) {
 2681       _mesa_glsl_error(loc, state,
 2682                        "atomic_uint can only have highp precision qualifier");
 2683    }
 2684 
 2685    return precision;
 2686 }
 2687 
 2688 const glsl_type *
 2689 ast_fully_specified_type::glsl_type(const char **name,
 2690                                     struct _mesa_glsl_parse_state *state) const
 2691 {
 2692    return this->specifier->glsl_type(name, state);
 2693 }
 2694 
 2695 /**
 2696  * Determine whether a toplevel variable declaration declares a varying.  This
 2697  * function operates by examining the variable's mode and the shader target,
 2698  * so it correctly identifies linkage variables regardless of whether they are
 2699  * declared using the deprecated "varying" syntax or the new "in/out" syntax.
 2700  *
 2701  * Passing a non-toplevel variable declaration (e.g. a function parameter) to
 2702  * this function will produce undefined results.
 2703  */
 2704 static bool
 2705 is_varying_var(ir_variable *var, gl_shader_stage target)
 2706 {
 2707    switch (target) {
 2708    case MESA_SHADER_VERTEX:
 2709       return var->data.mode == ir_var_shader_out;
 2710    case MESA_SHADER_FRAGMENT:
 2711       return var->data.mode == ir_var_shader_in ||
 2712              (var->data.mode == ir_var_system_value &&
 2713               var->data.location == SYSTEM_VALUE_FRAG_COORD);
 2714    default:
 2715       return var->data.mode == ir_var_shader_out || var->data.mode == ir_var_shader_in;
 2716    }
 2717 }
 2718 
 2719 static bool
 2720 is_allowed_invariant(ir_variable *var, struct _mesa_glsl_parse_state *state)
 2721 {
 2722    if (is_varying_var(var, state->stage))
 2723       return true;
 2724 
 2725    /* From Section 4.6.1 ("The Invariant Qualifier") GLSL 1.20 spec:
 2726     * "Only variables output from a vertex shader can be candidates
 2727     * for invariance".
 2728     */
 2729    if (!state->is_version(130, 100))
 2730       return false;
 2731 
 2732    /*
 2733     * Later specs remove this language - so allowed invariant
 2734     * on fragment shader outputs as well.
 2735     */
 2736    if (state->stage == MESA_SHADER_FRAGMENT &&
 2737        var->data.mode == ir_var_shader_out)
 2738       return true;
 2739    return false;
 2740 }
 2741 
 2742 /**
 2743  * Matrix layout qualifiers are only allowed on certain types
 2744  */
 2745 static void
 2746 validate_matrix_layout_for_type(struct _mesa_glsl_parse_state *state,
 2747                                 YYLTYPE *loc,
 2748                                 const glsl_type *type,
 2749                                 ir_variable *var)
 2750 {
 2751    if (var && !var->is_in_buffer_block()) {
 2752       /* Layout qualifiers may only apply to interface blocks and fields in
 2753        * them.
 2754        */
 2755       _mesa_glsl_error(loc, state,
 2756                        "uniform block layout qualifiers row_major and "
 2757                        "column_major may not be applied to variables "
 2758                        "outside of uniform blocks");
 2759    } else if (!type->without_array()->is_matrix()) {
 2760       /* The OpenGL ES 3.0 conformance tests did not originally allow
 2761        * matrix layout qualifiers on non-matrices.  However, the OpenGL
 2762        * 4.4 and OpenGL ES 3.0 (revision TBD) specifications were
 2763        * amended to specifically allow these layouts on all types.  Emit
 2764        * a warning so that people know their code may not be portable.
 2765        */
 2766       _mesa_glsl_warning(loc, state,
 2767                          "uniform block layout qualifiers row_major and "
 2768                          "column_major applied to non-matrix types may "
 2769                          "be rejected by older compilers");
 2770    }
 2771 }
 2772 
 2773 static bool
 2774 validate_xfb_buffer_qualifier(YYLTYPE *loc,
 2775                               struct _mesa_glsl_parse_state *state,
 2776                               unsigned xfb_buffer) {
 2777    if (xfb_buffer >= state->Const.MaxTransformFeedbackBuffers) {
 2778       _mesa_glsl_error(loc, state,
 2779                        "invalid xfb_buffer specified %d is larger than "
 2780                        "MAX_TRANSFORM_FEEDBACK_BUFFERS - 1 (%d).",
 2781                        xfb_buffer,
 2782                        state->Const.MaxTransformFeedbackBuffers - 1);
 2783       return false;
 2784    }
 2785 
 2786    return true;
 2787 }
 2788 
 2789 /* From the ARB_enhanced_layouts spec:
 2790  *
 2791  *    "Variables and block members qualified with *xfb_offset* can be
 2792  *    scalars, vectors, matrices, structures, and (sized) arrays of these.
 2793  *    The offset must be a multiple of the size of the first component of
 2794  *    the first qualified variable or block member, or a compile-time error
 2795  *    results.  Further, if applied to an aggregate containing a double,
 2796  *    the offset must also be a multiple of 8, and the space taken in the
 2797  *    buffer will be a multiple of 8.
 2798  */
 2799 static bool
 2800 validate_xfb_offset_qualifier(YYLTYPE *loc,
 2801                               struct _mesa_glsl_parse_state *state,
 2802                               int xfb_offset, const glsl_type *type,
 2803                               unsigned component_size) {
 2804   const glsl_type *t_without_array = type->without_array();
 2805 
 2806    if (xfb_offset != -1 && type->is_unsized_array()) {
 2807       _mesa_glsl_error(loc, state,
 2808                        "xfb_offset can't be used with unsized arrays.");
 2809       return false;
 2810    }
 2811 
 2812    /* Make sure nested structs don't contain unsized arrays, and validate
 2813     * any xfb_offsets on interface members.
 2814     */
 2815    if (t_without_array->is_struct() || t_without_array->is_interface())
 2816       for (unsigned int i = 0; i < t_without_array->length; i++) {
 2817          const glsl_type *member_t = t_without_array->fields.structure[i].type;
 2818 
 2819          /* When the interface block doesn't have an xfb_offset qualifier then
 2820           * we apply the component size rules at the member level.
 2821           */
 2822          if (xfb_offset == -1)
 2823             component_size = member_t->contains_double() ? 8 : 4;
 2824 
 2825          int xfb_offset = t_without_array->fields.structure[i].offset;
 2826          validate_xfb_offset_qualifier(loc, state, xfb_offset, member_t,
 2827                                        component_size);
 2828       }
 2829 
 2830   /* Nested structs or interface block without offset may not have had an
 2831    * offset applied yet so return.
 2832    */
 2833    if (xfb_offset == -1) {
 2834      return true;
 2835    }
 2836 
 2837    if (xfb_offset % component_size) {
 2838       _mesa_glsl_error(loc, state,
 2839                        "invalid qualifier xfb_offset=%d must be a multiple "
 2840                        "of the first component size of the first qualified "
 2841                        "variable or block member. Or double if an aggregate "
 2842                        "that contains a double (%d).",
 2843                        xfb_offset, component_size);
 2844       return false;
 2845    }
 2846 
 2847    return true;
 2848 }
 2849 
 2850 static bool
 2851 validate_stream_qualifier(YYLTYPE *loc, struct _mesa_glsl_parse_state *state,
 2852                           unsigned stream)
 2853 {
 2854    if (stream >= state->ctx->Const.MaxVertexStreams) {
 2855       _mesa_glsl_error(loc, state,
 2856                        "invalid stream specified %d is larger than "
 2857                        "MAX_VERTEX_STREAMS - 1 (%d).",
 2858                        stream, state->ctx->Const.MaxVertexStreams - 1);
 2859       return false;
 2860    }
 2861 
 2862    return true;
 2863 }
 2864 
 2865 static void
 2866 apply_explicit_binding(struct _mesa_glsl_parse_state *state,
 2867                        YYLTYPE *loc,
 2868                        ir_variable *var,
 2869                        const glsl_type *type,
 2870                        const ast_type_qualifier *qual)
 2871 {
 2872    if (!qual->flags.q.uniform && !qual->flags.q.buffer) {
 2873       _mesa_glsl_error(loc, state,
 2874                        "the \"binding\" qualifier only applies to uniforms and "
 2875                        "shader storage buffer objects");
 2876       return;
 2877    }
 2878 
 2879    unsigned qual_binding;
 2880    if (!process_qualifier_constant(state, loc, "binding", qual->binding,
 2881                                    &qual_binding)) {
 2882       return;
 2883    }
 2884 
 2885    const struct gl_context *const ctx = state->ctx;
 2886    unsigned elements = type->is_array() ? type->arrays_of_arrays_size() : 1;
 2887    unsigned max_index = qual_binding + elements - 1;
 2888    const glsl_type *base_type = type->without_array();
 2889 
 2890    if (base_type->is_interface()) {
 2891       /* UBOs.  From page 60 of the GLSL 4.20 specification:
 2892        * "If the binding point for any uniform block instance is less than zero,
 2893        *  or greater than or equal to the implementation-dependent maximum
 2894        *  number of uniform buffer bindings, a compilation error will occur.
 2895        *  When the binding identifier is used with a uniform block instanced as
 2896        *  an array of size N, all elements of the array from binding through
 2897        *  binding + N – 1 must be within this range."
 2898        *
 2899        * The implementation-dependent maximum is GL_MAX_UNIFORM_BUFFER_BINDINGS.
 2900        */
 2901       if (qual->flags.q.uniform &&
 2902          max_index >= ctx->Const.MaxUniformBufferBindings) {
 2903          _mesa_glsl_error(loc, state, "layout(binding = %u) for %d UBOs exceeds "
 2904                           "the maximum number of UBO binding points (%d)",
 2905                           qual_binding, elements,
 2906                           ctx->Const.MaxUniformBufferBindings);
 2907          return;
 2908       }
 2909 
 2910       /* SSBOs. From page 67 of the GLSL 4.30 specification:
 2911        * "If the binding point for any uniform or shader storage block instance
 2912        *  is less than zero, or greater than or equal to the
 2913        *  implementation-dependent maximum number of uniform buffer bindings, a
 2914        *  compile-time error will occur. When the binding identifier is used
 2915        *  with a uniform or shader storage block instanced as an array of size
 2916        *  N, all elements of the array from binding through binding + N – 1 must
 2917        *  be within this range."
 2918        */
 2919       if (qual->flags.q.buffer &&
 2920          max_index >= ctx->Const.MaxShaderStorageBufferBindings) {
 2921          _mesa_glsl_error(loc, state, "layout(binding = %u) for %d SSBOs exceeds "
 2922                           "the maximum number of SSBO binding points (%d)",
 2923                           qual_binding, elements,
 2924                           ctx->Const.MaxShaderStorageBufferBindings);
 2925          return;
 2926       }
 2927    } else if (base_type->is_sampler()) {
 2928       /* Samplers.  From page 63 of the GLSL 4.20 specification:
 2929        * "If the binding is less than zero, or greater than or equal to the
 2930        *  implementation-dependent maximum supported number of units, a
 2931        *  compilation error will occur. When the binding identifier is used
 2932        *  with an array of size N, all elements of the array from binding
 2933        *  through binding + N - 1 must be within this range."
 2934        */
 2935       unsigned limit = ctx->Const.MaxCombinedTextureImageUnits;
 2936 
 2937       if (max_index >= limit) {
 2938          _mesa_glsl_error(loc, state, "layout(binding = %d) for %d samplers "
 2939                           "exceeds the maximum number of texture image units "
 2940                           "(%u)", qual_binding, elements, limit);
 2941 
 2942          return;
 2943       }
 2944    } else if (base_type->contains_atomic()) {
 2945       assert(ctx->Const.MaxAtomicBufferBindings <= MAX_COMBINED_ATOMIC_BUFFERS);
 2946       if (qual_binding >= ctx->Const.MaxAtomicBufferBindings) {
 2947          _mesa_glsl_error(loc, state, "layout(binding = %d) exceeds the "
 2948                           "maximum number of atomic counter buffer bindings "
 2949                           "(%u)", qual_binding,
 2950                           ctx->Const.MaxAtomicBufferBindings);
 2951 
 2952          return;
 2953       }
 2954    } else if ((state->is_version(420, 310) ||
 2955                state->ARB_shading_language_420pack_enable) &&
 2956               base_type->is_image()) {
 2957       assert(ctx->Const.MaxImageUnits <= MAX_IMAGE_UNITS);
 2958       if (max_index >= ctx->Const.MaxImageUnits) {
 2959          _mesa_glsl_error(loc, state, "Image binding %d exceeds the "
 2960                           "maximum number of image units (%d)", max_index,
 2961                           ctx->Const.MaxImageUnits);
 2962          return;
 2963       }
 2964 
 2965    } else {
 2966       _mesa_glsl_error(loc, state,
 2967                        "the \"binding\" qualifier only applies to uniform "
 2968                        "blocks, storage blocks, opaque variables, or arrays "
 2969                        "thereof");
 2970       return;
 2971    }
 2972 
 2973    var->data.explicit_binding = true;
 2974    var->data.binding = qual_binding;
 2975 
 2976    return;
 2977 }
 2978 
 2979 static void
 2980 validate_fragment_flat_interpolation_input(struct _mesa_glsl_parse_state *state,
 2981                                            YYLTYPE *loc,
 2982                                            const glsl_interp_mode interpolation,
 2983                                            const struct glsl_type *var_type,
 2984                                            ir_variable_mode mode)
 2985 {
 2986    if (state->stage != MESA_SHADER_FRAGMENT ||
 2987        interpolation == INTERP_MODE_FLAT ||
 2988        mode != ir_var_shader_in)
 2989       return;
 2990 
 2991    /* Integer fragment inputs must be qualified with 'flat'.  In GLSL ES,
 2992     * so must integer vertex outputs.
 2993     *
 2994     * From section 4.3.4 ("Inputs") of the GLSL 1.50 spec:
 2995     *    "Fragment shader inputs that are signed or unsigned integers or
 2996     *    integer vectors must be qualified with the interpolation qualifier
 2997     *    flat."
 2998     *
 2999     * From section 4.3.4 ("Input Variables") of the GLSL 3.00 ES spec:
 3000     *    "Fragment shader inputs that are, or contain, signed or unsigned
 3001     *    integers or integer vectors must be qualified with the
 3002     *    interpolation qualifier flat."
 3003     *
 3004     * From section 4.3.6 ("Output Variables") of the GLSL 3.00 ES spec:
 3005     *    "Vertex shader outputs that are, or contain, signed or unsigned
 3006     *    integers or integer vectors must be qualified with the
 3007     *    interpolation qualifier flat."
 3008     *
 3009     * Note that prior to GLSL 1.50, this requirement applied to vertex
 3010     * outputs rather than fragment inputs.  That creates problems in the
 3011     * presence of geometry shaders, so we adopt the GLSL 1.50 rule for all
 3012     * desktop GL shaders.  For GLSL ES shaders, we follow the spec and
 3013     * apply the restriction to both vertex outputs and fragment inputs.
 3014     *
 3015     * Note also that the desktop GLSL specs are missing the text "or
 3016     * contain"; this is presumably an oversight, since there is no
 3017     * reasonable way to interpolate a fragment shader input that contains
 3018     * an integer. See Khronos bug #15671.
 3019     */
 3020    if ((state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
 3021        && var_type->contains_integer()) {
 3022       _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
 3023                        "an integer, then it must be qualified with 'flat'");
 3024    }
 3025 
 3026    /* Double fragment inputs must be qualified with 'flat'.
 3027     *
 3028     * From the "Overview" of the ARB_gpu_shader_fp64 extension spec:
 3029     *    "This extension does not support interpolation of double-precision
 3030     *    values; doubles used as fragment shader inputs must be qualified as
 3031     *    "flat"."
 3032     *
 3033     * From section 4.3.4 ("Inputs") of the GLSL 4.00 spec:
 3034     *    "Fragment shader inputs that are signed or unsigned integers, integer
 3035     *    vectors, or any double-precision floating-point type must be
 3036     *    qualified with the interpolation qualifier flat."
 3037     *
 3038     * Note that the GLSL specs are missing the text "or contain"; this is
 3039     * presumably an oversight. See Khronos bug #15671.
 3040     *
 3041     * The 'double' type does not exist in GLSL ES so far.
 3042     */
 3043    if (state->has_double()
 3044        && var_type->contains_double()) {
 3045       _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
 3046                        "a double, then it must be qualified with 'flat'");
 3047    }
 3048 
 3049    /* Bindless sampler/image fragment inputs must be qualified with 'flat'.
 3050     *
 3051     * From section 4.3.4 of the ARB_bindless_texture spec:
 3052     *
 3053     *    "(modify last paragraph, p. 35, allowing samplers and images as
 3054     *     fragment shader inputs) ... Fragment inputs can only be signed and
 3055     *     unsigned integers and integer vectors, floating point scalars,
 3056     *     floating-point vectors, matrices, sampler and image types, or arrays
 3057     *     or structures of these.  Fragment shader inputs that are signed or
 3058     *     unsigned integers, integer vectors, or any double-precision floating-
 3059     *     point type, or any sampler or image type must be qualified with the
 3060     *     interpolation qualifier "flat"."
 3061     */
 3062    if (state->has_bindless()
 3063        && (var_type->contains_sampler() || var_type->contains_image())) {
 3064       _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
 3065                        "a bindless sampler (or image), then it must be "
 3066                        "qualified with 'flat'");
 3067    }
 3068 }
 3069 
 3070 static void
 3071 validate_interpolation_qualifier(struct _mesa_glsl_parse_state *state,
 3072                                  YYLTYPE *loc,
 3073                                  const glsl_interp_mode interpolation,
 3074                                  const struct ast_type_qualifier *qual,
 3075                                  const struct glsl_type *var_type,
 3076                                  ir_variable_mode mode)
 3077 {
 3078    /* Interpolation qualifiers can only apply to shader inputs or outputs, but
 3079     * not to vertex shader inputs nor fragment shader outputs.
 3080     *
 3081     * From section 4.3 ("Storage Qualifiers") of the GLSL 1.30 spec:
 3082     *    "Outputs from a vertex shader (out) and inputs to a fragment
 3083     *    shader (in) can be further qualified with one or more of these
 3084     *    interpolation qualifiers"
 3085     *    ...
 3086     *    "These interpolation qualifiers may only precede the qualifiers in,
 3087     *    centroid in, out, or centroid out in a declaration. They do not apply
 3088     *    to the deprecated storage qualifiers varying or centroid
 3089     *    varying. They also do not apply to inputs into a vertex shader or
 3090     *    outputs from a fragment shader."
 3091     *
 3092     * From section 4.3 ("Storage Qualifiers") of the GLSL ES 3.00 spec:
 3093     *    "Outputs from a shader (out) and inputs to a shader (in) can be
 3094     *    further qualified with one of these interpolation qualifiers."
 3095     *    ...
 3096     *    "These interpolation qualifiers may only precede the qualifiers
 3097     *    in, centroid in, out, or centroid out in a declaration. They do
 3098     *    not apply to inputs into a vertex shader or outputs from a
 3099     *    fragment shader."
 3100     */
 3101    if ((state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
 3102        && interpolation != INTERP_MODE_NONE) {
 3103       const char *i = interpolation_string(interpolation);
 3104       if (mode != ir_var_shader_in && mode != ir_var_shader_out)
 3105          _mesa_glsl_error(loc, state,
 3106                           "interpolation qualifier `%s' can only be applied to "
 3107                           "shader inputs or outputs.", i);
 3108 
 3109       switch (state->stage) {
 3110       case MESA_SHADER_VERTEX:
 3111          if (mode == ir_var_shader_in) {
 3112             _mesa_glsl_error(loc, state,
 3113                              "interpolation qualifier '%s' cannot be applied to "
 3114                              "vertex shader inputs", i);
 3115          }
 3116          break;
 3117       case MESA_SHADER_FRAGMENT:
 3118          if (mode == ir_var_shader_out) {
 3119             _mesa_glsl_error(loc, state,
 3120                              "interpolation qualifier '%s' cannot be applied to "
 3121                              "fragment shader outputs", i);
 3122          }
 3123          break;
 3124       default:
 3125          break;
 3126       }
 3127    }
 3128 
 3129    /* Interpolation qualifiers cannot be applied to 'centroid' and
 3130     * 'centroid varying'.
 3131     *
 3132     * From section 4.3 ("Storage Qualifiers") of the GLSL 1.30 spec:
 3133     *    "interpolation qualifiers may only precede the qualifiers in,
 3134     *    centroid in, out, or centroid out in a declaration. They do not apply
 3135     *    to the deprecated storage qualifiers varying or centroid varying."
 3136     *
 3137     * These deprecated storage qualifiers do not exist in GLSL ES 3.00.
 3138     *
 3139     * GL_EXT_gpu_shader4 allows this.
 3140     */
 3141    if (state->is_version(130, 0) && !state->EXT_gpu_shader4_enable
 3142        && interpolation != INTERP_MODE_NONE
 3143        && qual->flags.q.varying) {
 3144 
 3145       const char *i = interpolation_string(interpolation);
 3146       const char *s;
 3147       if (qual->flags.q.centroid)
 3148          s = "centroid varying";
 3149       else
 3150          s = "varying";
 3151 
 3152       _mesa_glsl_error(loc, state,
 3153                        "qualifier '%s' cannot be applied to the "
 3154                        "deprecated storage qualifier '%s'", i, s);
 3155    }
 3156 
 3157    validate_fragment_flat_interpolation_input(state, loc, interpolation,
 3158                                               var_type, mode);
 3159 }
 3160 
 3161 static glsl_interp_mode
 3162 interpret_interpolation_qualifier(const struct ast_type_qualifier *qual,
 3163                                   const struct glsl_type *var_type,
 3164                                   ir_variable_mode mode,
 3165                                   struct _mesa_glsl_parse_state *state,
 3166                                   YYLTYPE *loc)
 3167 {
 3168    glsl_interp_mode interpolation;
 3169    if (qual->flags.q.flat)
 3170       interpolation = INTERP_MODE_FLAT;
 3171    else if (qual->flags.q.noperspective)
 3172       interpolation = INTERP_MODE_NOPERSPECTIVE;
 3173    else if (qual->flags.q.smooth)
 3174       interpolation = INTERP_MODE_SMOOTH;
 3175    else
 3176       interpolation = INTERP_MODE_NONE;
 3177 
 3178    validate_interpolation_qualifier(state, loc,
 3179                                     interpolation,
 3180                                     qual, var_type, mode);
 3181 
 3182    return interpolation;
 3183 }
 3184 
 3185 
 3186 static void
 3187 apply_explicit_location(const struct ast_type_qualifier *qual,
 3188                         ir_variable *var,
 3189                         struct _mesa_glsl_parse_state *state,
 3190                         YYLTYPE *loc)
 3191 {
 3192    bool fail = false;
 3193 
 3194    unsigned qual_location;
 3195    if (!process_qualifier_constant(state, loc, "location", qual->location,
 3196                                    &qual_location)) {
 3197       return;
 3198    }
 3199 
 3200    /* Checks for GL_ARB_explicit_uniform_location. */
 3201    if (qual->flags.q.uniform) {
 3202       if (!state->check_explicit_uniform_location_allowed(loc, var))
 3203          return;
 3204 
 3205       const struct gl_context *const ctx = state->ctx;
 3206       unsigned max_loc = qual_location + var->type->uniform_locations() - 1;
 3207 
 3208       if (max_loc >= ctx->Const.MaxUserAssignableUniformLocations) {
 3209          _mesa_glsl_error(loc, state, "location(s) consumed by uniform %s "
 3210                           ">= MAX_UNIFORM_LOCATIONS (%u)", var->name,
 3211                           ctx->Const.MaxUserAssignableUniformLocations);
 3212          return;
 3213       }
 3214 
 3215       var->data.explicit_location = true;
 3216       var->data.location = qual_location;
 3217       return;
 3218    }
 3219 
 3220    /* Between GL_ARB_explicit_attrib_location an
 3221     * GL_ARB_separate_shader_objects, the inputs and outputs of any shader
 3222     * stage can be assigned explicit locations.  The checking here associates
 3223     * the correct extension with the correct stage's input / output:
 3224     *
 3225     *                     input            output
 3226     *                     -----            ------
 3227     * vertex              explicit_loc     sso
 3228     * tess control        sso              sso
 3229     * tess eval           sso              sso
 3230     * geometry            sso              sso
 3231     * fragment            sso              explicit_loc
 3232     */
 3233    switch (state->stage) {
 3234    case MESA_SHADER_VERTEX:
 3235       if (var->data.mode == ir_var_shader_in) {
 3236          if (!state->check_explicit_attrib_location_allowed(loc, var))
 3237             return;
 3238 
 3239          break;
 3240       }
 3241 
 3242       if (var->data.mode == ir_var_shader_out) {
 3243          if (!state->check_separate_shader_objects_allowed(loc, var))
 3244             return;
 3245 
 3246          break;
 3247       }
 3248 
 3249       fail = true;
 3250       break;
 3251 
 3252    case MESA_SHADER_TESS_CTRL:
 3253    case MESA_SHADER_TESS_EVAL:
 3254    case MESA_SHADER_GEOMETRY:
 3255       if (var->data.mode == ir_var_shader_in || var->data.mode == ir_var_shader_out) {
 3256          if (!state->check_separate_shader_objects_allowed(loc, var))
 3257             return;
 3258 
 3259          break;
 3260       }
 3261 
 3262       fail = true;
 3263       break;
 3264 
 3265    case MESA_SHADER_FRAGMENT:
 3266       if (var->data.mode == ir_var_shader_in) {
 3267          if (!state->check_separate_shader_objects_allowed(loc, var))
 3268             return;
 3269 
 3270          break;
 3271       }
 3272 
 3273       if (var->data.mode == ir_var_shader_out) {
 3274          if (!state->check_explicit_attrib_location_allowed(loc, var))
 3275             return;
 3276 
 3277          break;
 3278       }
 3279 
 3280       fail = true;
 3281       break;
 3282 
 3283    case MESA_SHADER_COMPUTE:
 3284       _mesa_glsl_error(loc, state,
 3285                        "compute shader variables cannot be given "
 3286                        "explicit locations");
 3287       return;
 3288    default:
 3289       fail = true;
 3290       break;
 3291    };
 3292 
 3293    if (fail) {
 3294       _mesa_glsl_error(loc, state,
 3295                        "%s cannot be given an explicit location in %s shader",
 3296                        mode_string(var),
 3297       _mesa_shader_stage_to_string(state->stage));
 3298    } else {
 3299       var->data.explicit_location = true;
 3300 
 3301       switch (state->stage) {
 3302       case MESA_SHADER_VERTEX:
 3303          var->data.location = (var->data.mode == ir_var_shader_in)
 3304             ? (qual_location + VERT_ATTRIB_GENERIC0)
 3305             : (qual_location + VARYING_SLOT_VAR0);
 3306          break;
 3307 
 3308       case MESA_SHADER_TESS_CTRL:
 3309       case MESA_SHADER_TESS_EVAL:
 3310       case MESA_SHADER_GEOMETRY:
 3311          if (var->data.patch)
 3312             var->data.location = qual_location + VARYING_SLOT_PATCH0;
 3313          else
 3314             var->data.location = qual_location + VARYING_SLOT_VAR0;
 3315          break;
 3316 
 3317       case MESA_SHADER_FRAGMENT:
 3318          var->data.location = (var->data.mode == ir_var_shader_out)
 3319             ? (qual_location + FRAG_RESULT_DATA0)
 3320             : (qual_location + VARYING_SLOT_VAR0);
 3321          break;
 3322       default:
 3323          assert(!"Unexpected shader type");
 3324          break;
 3325       }
 3326 
 3327       /* Check if index was set for the uniform instead of the function */
 3328       if (qual->flags.q.explicit_index && qual->is_subroutine_decl()) {
 3329          _mesa_glsl_error(loc, state, "an index qualifier can only be "
 3330                           "used with subroutine functions");
 3331          return;
 3332       }
 3333 
 3334       unsigned qual_index;
 3335       if (qual->flags.q.explicit_index &&
 3336           process_qualifier_constant(state, loc, "index", qual->index,
 3337                                      &qual_index)) {
 3338          /* From the GLSL 4.30 specification, section 4.4.2 (Output
 3339           * Layout Qualifiers):
 3340           *
 3341           * "It is also a compile-time error if a fragment shader
 3342           *  sets a layout index to less than 0 or greater than 1."
 3343           *
 3344           * Older specifications don't mandate a behavior; we take
 3345           * this as a clarification and always generate the error.
 3346           */
 3347          if (qual_index > 1) {
 3348             _mesa_glsl_error(loc, state,
 3349                              "explicit index may only be 0 or 1");
 3350          } else {
 3351             var->data.explicit_index = true;
 3352             var->data.index = qual_index;
 3353          }
 3354       }
 3355    }
 3356 }
 3357 
 3358 static bool
 3359 validate_storage_for_sampler_image_types(ir_variable *var,
 3360                                          struct _mesa_glsl_parse_state *state,
 3361                                          YYLTYPE *loc)
 3362 {
 3363    /* From section 4.1.7 of the GLSL 4.40 spec:
 3364     *
 3365     *    "[Opaque types] can only be declared as function
 3366     *     parameters or uniform-qualified variables."
 3367     *
 3368     * From section 4.1.7 of the ARB_bindless_texture spec:
 3369     *
 3370     *    "Samplers may be declared as shader inputs and outputs, as uniform
 3371     *     variables, as temporary variables, and as function parameters."
 3372     *
 3373     * From section 4.1.X of the ARB_bindless_texture spec:
 3374     *
 3375     *    "Images may be declared as shader inputs and outputs, as uniform
 3376     *     variables, as temporary variables, and as function parameters."
 3377     */
 3378    if (state->has_bindless()) {
 3379       if (var->data.mode != ir_var_auto &&
 3380           var->data.mode != ir_var_uniform &&
 3381           var->data.mode != ir_var_shader_in &&
 3382           var->data.mode != ir_var_shader_out &&
 3383           var->data.mode != ir_var_function_in &&
 3384           var->data.mode != ir_var_function_out &&
 3385           var->data.mode != ir_var_function_inout) {
 3386          _mesa_glsl_error(loc, state, "bindless image/sampler variables may "
 3387                          "only be declared as shader inputs and outputs, as "
 3388                          "uniform variables, as temporary variables and as "
 3389                          "function parameters");
 3390          return false;
 3391       }
 3392    } else {
 3393       if (var->data.mode != ir_var_uniform &&
 3394           var->data.mode != ir_var_function_in) {
 3395          _mesa_glsl_error(loc, state, "image/sampler variables may only be "
 3396                           "declared as function parameters or "
 3397                           "uniform-qualified global variables");
 3398          return false;
 3399       }
 3400    }
 3401    return true;
 3402 }
 3403 
 3404 static bool
 3405 validate_memory_qualifier_for_type(struct _mesa_glsl_parse_state *state,
 3406                                    YYLTYPE *loc,
 3407                                    const struct ast_type_qualifier *qual,
 3408                                    const glsl_type *type)
 3409 {
 3410    /* From Section 4.10 (Memory Qualifiers) of the GLSL 4.50 spec:
 3411     *
 3412     * "Memory qualifiers are only supported in the declarations of image
 3413     *  variables, buffer variables, and shader storage blocks; it is an error
 3414     *  to use such qualifiers in any other declarations.
 3415     */
 3416    if (!type->is_image() && !qual->flags.q.buffer) {
 3417       if (qual->flags.q.read_only ||
 3418           qual->flags.q.write_only ||
 3419           qual->flags.q.coherent ||
 3420           qual->flags.q._volatile ||
 3421           qual->flags.q.restrict_flag) {
 3422          _mesa_glsl_error(loc, state, "memory qualifiers may only be applied "
 3423                           "in the declarations of image variables, buffer "
 3424                           "variables, and shader storage blocks");
 3425          return false;
 3426       }
 3427    }
 3428    return true;
 3429 }
 3430 
 3431 static bool
 3432 validate_image_format_qualifier_for_type(struct _mesa_glsl_parse_state *state,
 3433                                          YYLTYPE *loc,
 3434                                          const struct ast_type_qualifier *qual,
 3435                                          const glsl_type *type)
 3436 {
 3437    /* From section 4.4.6.2 (Format Layout Qualifiers) of the GLSL 4.50 spec:
 3438     *
 3439     * "Format layout qualifiers can be used on image variable declarations
 3440     *  (those declared with a basic type  having “image ” in its keyword)."
 3441     */
 3442    if (!type->is_image() && qual->flags.q.explicit_image_format) {
 3443       _mesa_glsl_error(loc, state, "format layout qualifiers may only be "
 3444                        "applied to images");
 3445       return false;
 3446    }
 3447    return true;
 3448 }
 3449 
 3450 static void
 3451 apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
 3452                                   ir_variable *var,
 3453                                   struct _mesa_glsl_parse_state *state,
 3454                                   YYLTYPE *loc)
 3455 {
 3456    const glsl_type *base_type = var->type->without_array();
 3457 
 3458    if (!validate_image_format_qualifier_for_type(state, loc, qual, base_type) ||
 3459        !validate_memory_qualifier_for_type(state, loc, qual, base_type))
 3460       return;
 3461 
 3462    if (!base_type->is_image())
 3463       return;
 3464 
 3465    if (!validate_storage_for_sampler_image_types(var, state, loc))
 3466       return;
 3467 
 3468    var->data.memory_read_only |= qual->flags.q.read_only;
 3469    var->data.memory_write_only |= qual->flags.q.write_only;
 3470    var->data.memory_coherent |= qual->flags.q.coherent;
 3471    var->data.memory_volatile |= qual->flags.q._volatile;
 3472    var->data.memory_restrict |= qual->flags.q.restrict_flag;
 3473 
 3474    if (qual->flags.q.explicit_image_format) {
 3475       if (var->data.mode == ir_var_function_in) {
 3476          _mesa_glsl_error(loc, state, "format qualifiers cannot be used on "
 3477                           "image function parameters");
 3478       }
 3479 
 3480       if (qual->image_base_type != base_type->sampled_type) {
 3481          _mesa_glsl_error(loc, state, "format qualifier doesn't match the base "
 3482                           "data type of the image");
 3483       }
 3484 
 3485       var->data.image_format = qual->image_format;
 3486    } else if (state->has_image_load_formatted()) {
 3487       if (var->data.mode == ir_var_uniform &&
 3488           state->EXT_shader_image_load_formatted_warn) {
 3489          _mesa_glsl_warning(loc, state, "GL_EXT_image_load_formatted used");
 3490       }
 3491    } else {
 3492       if (var->data.mode == ir_var_uniform) {
 3493          if (state->es_shader ||
 3494              !(state->is_version(420, 310) || state->ARB_shader_image_load_store_enable)) {
 3495             _mesa_glsl_error(loc, state, "all image uniforms must have a "
 3496                              "format layout qualifier");
 3497          } else if (!qual->flags.q.write_only) {
 3498             _mesa_glsl_error(loc, state, "image uniforms not qualified with "
 3499                              "`writeonly' must have a format layout qualifier");
 3500          }
 3501       }
 3502       var->data.image_format = PIPE_FORMAT_NONE;
 3503    }
 3504 
 3505    /* From page 70 of the GLSL ES 3.1 specification:
 3506     *
 3507     * "Except for image variables qualified with the format qualifiers r32f,
 3508     *  r32i, and r32ui, image variables must specify either memory qualifier
 3509     *  readonly or the memory qualifier writeonly."
 3510     */
 3511    if (state->es_shader &&
 3512        var->data.image_format != PIPE_FORMAT_R32_FLOAT &&
 3513        var->data.image_format != PIPE_FORMAT_R32_SINT &&
 3514        var->data.image_format != PIPE_FORMAT_R32_UINT &&
 3515        !var->data.memory_read_only &&
 3516        !var->data.memory_write_only) {
 3517       _mesa_glsl_error(loc, state, "image variables of format other than r32f, "
 3518                        "r32i or r32ui must be qualified `readonly' or "
 3519                        "`writeonly'");
 3520    }
 3521 }
 3522 
 3523 static inline const char*
 3524 get_layout_qualifier_string(bool origin_upper_left, bool pixel_center_integer)
 3525 {
 3526    if (origin_upper_left && pixel_center_integer)
 3527       return "origin_upper_left, pixel_center_integer";
 3528    else if (origin_upper_left)
 3529       return "origin_upper_left";
 3530    else if (pixel_center_integer)
 3531       return "pixel_center_integer";
 3532    else
 3533       return " ";
 3534 }
 3535 
 3536 static inline bool
 3537 is_conflicting_fragcoord_redeclaration(struct _mesa_glsl_parse_state *state,
 3538                                        const struct ast_type_qualifier *qual)
 3539 {
 3540    /* If gl_FragCoord was previously declared, and the qualifiers were
 3541     * different in any way, return true.
 3542     */
 3543    if (state->fs_redeclares_gl_fragcoord) {
 3544       return (state->fs_pixel_center_integer != qual->flags.q.pixel_center_integer
 3545          || state->fs_origin_upper_left != qual->flags.q.origin_upper_left);
 3546    }
 3547 
 3548    return false;
 3549 }
 3550 
 3551 static inline bool
 3552 is_conflicting_layer_redeclaration(struct _mesa_glsl_parse_state *state,
 3553                                    const struct ast_type_qualifier *qual)
 3554 {
 3555    if (state->redeclares_gl_layer) {
 3556       return state->layer_viewport_relative != qual->flags.q.viewport_relative;
 3557    }
 3558    return false;
 3559 }
 3560 
 3561 static inline void
 3562 validate_array_dimensions(const glsl_type *t,
 3563                           struct _mesa_glsl_parse_state *state,
 3564                           YYLTYPE *loc) {
 3565    if (t->is_array()) {
 3566       t = t->fields.array;
 3567       while (t->is_array()) {
 3568          if (t->is_unsized_array()) {
 3569             _mesa_glsl_error(loc, state,
 3570                              "only the outermost array dimension can "
 3571                              "be unsized",
 3572                              t->name);
 3573             break;
 3574          }
 3575          t = t->fields.array;
 3576       }
 3577    }
 3578 }
 3579 
 3580 static void
 3581 apply_bindless_qualifier_to_variable(const struct ast_type_qualifier *qual,
 3582                                      ir_variable *var,
 3583                                      struct _mesa_glsl_parse_state *state,
 3584                                      YYLTYPE *loc)
 3585 {
 3586    bool has_local_qualifiers = qual->flags.q.bindless_sampler ||
 3587                                qual->flags.q.bindless_image ||
 3588                                qual->flags.q.bound_sampler ||
 3589                                qual->flags.q.bound_image;
 3590 
 3591    /* The ARB_bindless_texture spec says:
 3592     *
 3593     * "Modify Section 4.4.6 Opaque-Uniform Layout Qualifiers of the GLSL 4.30
 3594     *  spec"
 3595     *
 3596     * "If these layout qualifiers are applied to other types of default block
 3597     *  uniforms, or variables with non-uniform storage, a compile-time error
 3598     *  will be generated."
 3599     */
 3600    if (has_local_qualifiers && !qual->flags.q.uniform) {
 3601       _mesa_glsl_error(loc, state, "ARB_bindless_texture layout qualifiers "
 3602                        "can only be applied to default block uniforms or "
 3603                        "variables with uniform storage");
 3604       return;
 3605    }
 3606 
 3607    /* The ARB_bindless_texture spec doesn't state anything in this situation,
 3608     * but it makes sense to only allow bindless_sampler/bound_sampler for
 3609     * sampler types, and respectively bindless_image/bound_image for image
 3610     * types.
 3611     */
 3612    if ((qual->flags.q.bindless_sampler || qual->flags.q.bound_sampler) &&
 3613        !var->type->contains_sampler()) {
 3614       _mesa_glsl_error(loc, state, "bindless_sampler or bound_sampler can only "
 3615                        "be applied to sampler types");
 3616       return;
 3617    }
 3618 
 3619    if ((qual->flags.q.bindless_image || qual->flags.q.bound_image) &&
 3620        !var->type->contains_image()) {
 3621       _mesa_glsl_error(loc, state, "bindless_image or bound_image can only be "
 3622                        "applied to image types");
 3623       return;
 3624    }
 3625 
 3626    /* The bindless_sampler/bindless_image (and respectively
 3627     * bound_sampler/bound_image) layout qualifiers can be set at global and at
 3628     * local scope.
 3629     */
 3630    if (var->type->contains_sampler() || var->type->contains_image()) {
 3631       var->data.bindless = qual->flags.q.bindless_sampler ||
 3632                            qual->flags.q.bindless_image ||
 3633                            state->bindless_sampler_specified ||
 3634                            state->bindless_image_specified;
 3635 
 3636       var->data.bound = qual->flags.q.bound_sampler ||
 3637                         qual->flags.q.bound_image ||
 3638                         state->bound_sampler_specified ||
 3639                         state->bound_image_specified;
 3640    }
 3641 }
 3642 
 3643 static void
 3644 apply_layout_qualifier_to_variable(const struct ast_type_qualifier *qual,
 3645                                    ir_variable *var,
 3646                                    struct _mesa_glsl_parse_state *state,
 3647                                    YYLTYPE *loc)
 3648 {
 3649    if (var->name != NULL && strcmp(var->name, "gl_FragCoord") == 0) {
 3650 
 3651       /* Section 4.3.8.1, page 39 of GLSL 1.50 spec says:
 3652        *
 3653        *    "Within any shader, the first redeclarations of gl_FragCoord
 3654        *     must appear before any use of gl_FragCoord."
 3655        *
 3656        * Generate a compiler error if above condition is not met by the
 3657        * fragment shader.
 3658        */
 3659       ir_variable *earlier = state->symbols->get_variable("gl_FragCoord");
 3660       if (earlier != NULL &&
 3661           earlier->data.used &&
 3662           !state->fs_redeclares_gl_fragcoord) {
 3663          _mesa_glsl_error(loc, state,
 3664                           "gl_FragCoord used before its first redeclaration "
 3665                           "in fragment shader");
 3666       }
 3667 
 3668       /* Make sure all gl_FragCoord redeclarations specify the same layout
 3669        * qualifiers.
 3670        */
 3671       if (is_conflicting_fragcoord_redeclaration(state, qual)) {
 3672          const char *const qual_string =
 3673             get_layout_qualifier_string(qual->flags.q.origin_upper_left,
 3674                                         qual->flags.q.pixel_center_integer);
 3675 
 3676          const char *const state_string =
 3677             get_layout_qualifier_string(state->fs_origin_upper_left,
 3678                                         state->fs_pixel_center_integer);
 3679 
 3680          _mesa_glsl_error(loc, state,
 3681                           "gl_FragCoord redeclared with different layout "
 3682                           "qualifiers (%s) and (%s) ",
 3683                           state_string,
 3684                           qual_string);
 3685       }
 3686       state->fs_origin_upper_left = qual->flags.q.origin_upper_left;
 3687       state->fs_pixel_center_integer = qual->flags.q.pixel_center_integer;
 3688       state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers =
 3689          !qual->flags.q.origin_upper_left && !qual->flags.q.pixel_center_integer;
 3690       state->fs_redeclares_gl_fragcoord =
 3691          state->fs_origin_upper_left ||
 3692          state->fs_pixel_center_integer ||
 3693          state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
 3694    }
 3695 
 3696    if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
 3697        && (strcmp(var->name, "gl_FragCoord") != 0)) {
 3698       const char *const qual_string = (qual->flags.q.origin_upper_left)
 3699          ? "origin_upper_left" : "pixel_center_integer";
 3700 
 3701       _mesa_glsl_error(loc, state,
 3702                        "layout qualifier `%s' can only be applied to "
 3703                        "fragment shader input `gl_FragCoord'",
 3704                        qual_string);
 3705    }
 3706 
 3707    if (qual->flags.q.explicit_location) {
 3708       apply_explicit_location(qual, var, state, loc);
 3709 
 3710       if (qual->flags.q.explicit_component) {
 3711          unsigned qual_component;
 3712          if (process_qualifier_constant(state, loc, "component",
 3713                                         qual->component, &qual_component)) {
 3714             const glsl_type *type = var->type->without_array();
 3715             unsigned components = type->component_slots();
 3716 
 3717             if (type->is_matrix() || type->is_struct()) {
 3718                _mesa_glsl_error(loc, state, "component layout qualifier "
 3719                                 "cannot be applied to a matrix, a structure, "
 3720                                 "a block, or an array containing any of "
 3721                                 "these.");
 3722             } else if (components > 4 && type->is_64bit()) {
 3723                _mesa_glsl_error(loc, state, "component layout qualifier "
 3724                                 "cannot be applied to dvec%u.",
 3725                                 components / 2);
 3726             } else if (qual_component != 0 &&
 3727                 (qual_component + components - 1) > 3) {
 3728                _mesa_glsl_error(loc, state, "component overflow (%u > 3)",
 3729                                 (qual_component + components - 1));
 3730             } else if (qual_component == 1 && type->is_64bit()) {
 3731                /* We don't bother checking for 3 as it should be caught by the
 3732                 * overflow check above.
 3733                 */
 3734                _mesa_glsl_error(loc, state, "doubles cannot begin at "
 3735                                 "component 1 or 3");
 3736             } else {
 3737                var->data.explicit_component = true;
 3738                var->data.location_frac = qual_component;
 3739             }
 3740          }
 3741       }
 3742    } else if (qual->flags.q.explicit_index) {
 3743       if (!qual->subroutine_list)
 3744          _mesa_glsl_error(loc, state,
 3745                           "explicit index requires explicit location");
 3746    } else if (qual->flags.q.explicit_component) {
 3747       _mesa_glsl_error(loc, state,
 3748                        "explicit component requires explicit location");
 3749    }
 3750 
 3751    if (qual->flags.q.explicit_binding) {
 3752       apply_explicit_binding(state, loc, var, var->type, qual);
 3753    }
 3754 
 3755    if (state->stage == MESA_SHADER_GEOMETRY &&
 3756        qual->flags.q.out && qual->flags.q.stream) {
 3757       unsigned qual_stream;
 3758       if (process_qualifier_constant(state, loc, "stream", qual->stream,
 3759                                      &qual_stream) &&
 3760           validate_stream_qualifier(loc, state, qual_stream)) {
 3761          var->data.stream = qual_stream;
 3762       }
 3763    }
 3764 
 3765    if (qual->flags.q.out && qual->flags.q.xfb_buffer) {
 3766       unsigned qual_xfb_buffer;
 3767       if (process_qualifier_constant(state, loc, "xfb_buffer",
 3768                                      qual->xfb_buffer, &qual_xfb_buffer) &&
 3769           validate_xfb_buffer_qualifier(loc, state, qual_xfb_buffer)) {
 3770          var->data.xfb_buffer = qual_xfb_buffer;
 3771          if (qual->flags.q.explicit_xfb_buffer)
 3772             var->data.explicit_xfb_buffer = true;
 3773       }
 3774    }
 3775 
 3776    if (qual->flags.q.explicit_xfb_offset) {
 3777       unsigned qual_xfb_offset;
 3778       unsigned component_size = var->type->contains_double() ? 8 : 4;
 3779 
 3780       if (process_qualifier_constant(state, loc, "xfb_offset",
 3781                                      qual->offset, &qual_xfb_offset) &&
 3782           validate_xfb_offset_qualifier(loc, state, (int) qual_xfb_offset,
 3783                                         var->type, component_size)) {
 3784          var->data.offset = qual_xfb_offset;
 3785          var->data.explicit_xfb_offset = true;
 3786       }
 3787    }
 3788 
 3789    if (qual->flags.q.explicit_xfb_stride) {
 3790       unsigned qual_xfb_stride;
 3791       if (process_qualifier_constant(state, loc, "xfb_stride",
 3792                                      qual->xfb_stride, &qual_xfb_stride)) {
 3793          var->data.xfb_stride = qual_xfb_stride;
 3794          var->data.explicit_xfb_stride = true;
 3795       }
 3796    }
 3797 
 3798    if (var->type->contains_atomic()) {
 3799       if (var->data.mode == ir_var_uniform) {
 3800          if (var->data.explicit_binding) {
 3801             unsigned *offset =
 3802                &state->atomic_counter_offsets[var->data.binding];
 3803 
 3804             if (*offset % ATOMIC_COUNTER_SIZE)
 3805                _mesa_glsl_error(loc, state,
 3806                                 "misaligned atomic counter offset");
 3807 
 3808             var->data.offset = *offset;
 3809             *offset += var->type->atomic_size();
 3810 
 3811          } else {
 3812             _mesa_glsl_error(loc, state,
 3813                              "atomic counters require explicit binding point");
 3814          }
 3815       } else if (var->data.mode != ir_var_function_in) {
 3816          _mesa_glsl_error(loc, state, "atomic counters may only be declared as "
 3817                           "function parameters or uniform-qualified "
 3818                           "global variables");
 3819       }
 3820    }
 3821 
 3822    if (var->type->contains_sampler() &&
 3823        !validate_storage_for_sampler_image_types(var, state, loc))
 3824       return;
 3825 
 3826    /* Is the 'layout' keyword used with parameters that allow relaxed checking.
 3827     * Many implementations of GL_ARB_fragment_coord_conventions_enable and some
 3828     * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable
 3829     * allowed the layout qualifier to be used with 'varying' and 'attribute'.
 3830     * These extensions and all following extensions that add the 'layout'
 3831     * keyword have been modified to require the use of 'in' or 'out'.
 3832     *
 3833     * The following extension do not allow the deprecated keywords:
 3834     *
 3835     *    GL_AMD_conservative_depth
 3836     *    GL_ARB_conservative_depth
 3837     *    GL_ARB_gpu_shader5
 3838     *    GL_ARB_separate_shader_objects
 3839     *    GL_ARB_tessellation_shader
 3840     *    GL_ARB_transform_feedback3
 3841     *    GL_ARB_uniform_buffer_object
 3842     *
 3843     * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5
 3844     * allow layout with the deprecated keywords.
 3845     */
 3846    const bool relaxed_layout_qualifier_checking =
 3847       state->ARB_fragment_coord_conventions_enable;
 3848 
 3849    const bool uses_deprecated_qualifier = qual->flags.q.attribute
 3850       || qual->flags.q.varying;
 3851    if (qual->has_layout() && uses_deprecated_qualifier) {
 3852       if (relaxed_layout_qualifier_checking) {
 3853          _mesa_glsl_warning(loc, state,
 3854                             "`layout' qualifier may not be used with "
 3855                             "`attribute' or `varying'");
 3856       } else {
 3857          _mesa_glsl_error(loc, state,
 3858                           "`layout' qualifier may not be used with "
 3859                           "`attribute' or `varying'");
 3860       }
 3861    }
 3862 
 3863    /* Layout qualifiers for gl_FragDepth, which are enabled by extension
 3864     * AMD_conservative_depth.
 3865     */
 3866    if (qual->flags.q.depth_type
 3867        && !state->is_version(420, 0)
 3868        && !state->AMD_conservative_depth_enable
 3869        && !state->ARB_conservative_depth_enable) {
 3870        _mesa_glsl_error(loc, state,
 3871                         "extension GL_AMD_conservative_depth or "
 3872                         "GL_ARB_conservative_depth must be enabled "
 3873                         "to use depth layout qualifiers");
 3874    } else if (qual->flags.q.depth_type
 3875               && strcmp(var->name, "gl_FragDepth") != 0) {
 3876        _mesa_glsl_error(loc, state,
 3877                         "depth layout qualifiers can be applied only to "
 3878                         "gl_FragDepth");
 3879    }
 3880 
 3881    switch (qual->depth_type) {
 3882    case ast_depth_any:
 3883       var->data.depth_layout = ir_depth_layout_any;
 3884       break;
 3885    case ast_depth_greater:
 3886       var->data.depth_layout = ir_depth_layout_greater;
 3887       break;
 3888    case ast_depth_less:
 3889       var->data.depth_layout = ir_depth_layout_less;
 3890       break;
 3891    case ast_depth_unchanged:
 3892       var->data.depth_layout = ir_depth_layout_unchanged;
 3893       break;
 3894    default:
 3895       var->data.depth_layout = ir_depth_layout_none;
 3896       break;
 3897    }
 3898 
 3899    if (qual->flags.q.std140 ||
 3900        qual->flags.q.std430 ||
 3901        qual->flags.q.packed ||
 3902        qual->flags.q.shared) {
 3903       _mesa_glsl_error(loc, state,
 3904                        "uniform and shader storage block layout qualifiers "
 3905                        "std140, std430, packed, and shared can only be "
 3906                        "applied to uniform or shader storage blocks, not "
 3907                        "members");
 3908    }
 3909 
 3910    if (qual->flags.q.row_major || qual->flags.q.column_major) {
 3911       validate_matrix_layout_for_type(state, loc, var->type, var);
 3912    }
 3913 
 3914    /* From section 4.4.1.3 of the GLSL 4.50 specification (Fragment Shader
 3915     * Inputs):
 3916     *
 3917     *  "Fragment shaders also allow the following layout qualifier on in only
 3918     *   (not with variable declarations)
 3919     *     layout-qualifier-id
 3920     *        early_fragment_tests
 3921     *   [...]"
 3922     */
 3923    if (qual->flags.q.early_fragment_tests) {
 3924       _mesa_glsl_error(loc, state, "early_fragment_tests layout qualifier only "
 3925                        "valid in fragment shader input layout declaration.");
 3926    }
 3927 
 3928    if (qual->flags.q.inner_coverage) {
 3929       _mesa_glsl_error(loc, state, "inner_coverage layout qualifier only "
 3930                        "valid in fragment shader input layout declaration.");
 3931    }
 3932 
 3933    if (qual->flags.q.post_depth_coverage) {
 3934       _mesa_glsl_error(loc, state, "post_depth_coverage layout qualifier only "
 3935                        "valid in fragment shader input layout declaration.");
 3936    }
 3937 
 3938    if (state->has_bindless())
 3939       apply_bindless_qualifier_to_variable(qual, var, state, loc);
 3940 
 3941    if (qual->flags.q.pixel_interlock_ordered ||
 3942        qual->flags.q.pixel_interlock_unordered ||
 3943        qual->flags.q.sample_interlock_ordered ||
 3944        qual->flags.q.sample_interlock_unordered) {
 3945       _mesa_glsl_error(loc, state, "interlock layout qualifiers: "
 3946                        "pixel_interlock_ordered, pixel_interlock_unordered, "
 3947                        "sample_interlock_ordered and sample_interlock_unordered, "
 3948                        "only valid in fragment shader input layout declaration.");
 3949    }
 3950 
 3951    if (var->name != NULL && strcmp(var->name, "gl_Layer") == 0) {
 3952       if (is_conflicting_layer_redeclaration(state, qual)) {
 3953          _mesa_glsl_error(loc, state, "gl_Layer redeclaration with "
 3954                           "different viewport_relative setting than earlier");
 3955       }
 3956       state->redeclares_gl_layer = 1;
 3957       if (qual->flags.q.viewport_relative) {
 3958          state->layer_viewport_relative = 1;
 3959       }
 3960    } else if (qual->flags.q.viewport_relative) {
 3961       _mesa_glsl_error(loc, state,
 3962                        "viewport_relative qualifier "
 3963                        "can only be applied to gl_Layer.");
 3964    }
 3965 }
 3966 
 3967 static void
 3968 apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
 3969                                  ir_variable *var,
 3970                                  struct _mesa_glsl_parse_state *state,
 3971                                  YYLTYPE *loc,
 3972                                  bool is_parameter)
 3973 {
 3974    STATIC_ASSERT(sizeof(qual->flags.q) <= sizeof(qual->flags.i));
 3975 
 3976    if (qual->flags.q.invariant) {
 3977       if (var->data.used) {
 3978          _mesa_glsl_error(loc, state,
 3979                           "variable `%s' may not be redeclared "
 3980                           "`invariant' after being used",
 3981                           var->name);
 3982       } else {
 3983          var->data.explicit_invariant = true;
 3984          var->data.invariant = true;
 3985       }
 3986    }
 3987 
 3988    if (qual->flags.q.precise) {
 3989       if (var->data.used) {
 3990          _mesa_glsl_error(loc, state,
 3991                           "variable `%s' may not be redeclared "
 3992                           "`precise' after being used",
 3993                           var->name);
 3994       } else {
 3995          var->data.precise = 1;
 3996       }
 3997    }
 3998 
 3999    if (qual->is_subroutine_decl() && !qual->flags.q.uniform) {
 4000       _mesa_glsl_error(loc, state,
 4001                        "`subroutine' may only be applied to uniforms, "
 4002                        "subroutine type declarations, or function definitions");
 4003    }
 4004 
 4005    if (qual->flags.q.constant || qual->flags.q.attribute
 4006        || qual->flags.q.uniform
 4007        || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
 4008       var->data.read_only = 1;
 4009 
 4010    if (qual->flags.q.centroid)
 4011       var->data.centroid = 1;
 4012 
 4013    if (qual->flags.q.sample)
 4014       var->data.sample = 1;
 4015 
 4016    /* Precision qualifiers do not hold any meaning in Desktop GLSL */
 4017    if (state->es_shader) {
 4018       var->data.precision =
 4019          select_gles_precision(qual->precision, var->type, state, loc);
 4020    }
 4021 
 4022    if (qual->flags.q.patch)
 4023       var->data.patch = 1;
 4024 
 4025    if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) {
 4026       var->type = glsl_type::error_type;
 4027       _mesa_glsl_error(loc, state,
 4028                        "`attribute' variables may not be declared in the "
 4029                        "%s shader",
 4030                        _mesa_shader_stage_to_string(state->stage));
 4031    }
 4032 
 4033    /* Disallow layout qualifiers which may only appear on layout declarations. */
 4034    if (qual->flags.q.prim_type) {
 4035       _mesa_glsl_error(loc, state,
 4036                        "Primitive type may only be specified on GS input or output "
 4037                        "layout declaration, not on variables.");
 4038    }
 4039 
 4040    /* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says:
 4041     *
 4042     *     "However, the const qualifier cannot be used with out or inout."
 4043     *
 4044     * The same section of the GLSL 4.40 spec further clarifies this saying:
 4045     *
 4046     *     "The const qualifier cannot be used with out or inout, or a
 4047     *     compile-time error results."
 4048     */
 4049    if (is_parameter && qual->flags.q.constant && qual->flags.q.out) {
 4050       _mesa_glsl_error(loc, state,
 4051                        "`const' may not be applied to `out' or `inout' "
 4052                        "function parameters");
 4053    }
 4054 
 4055    /* If there is no qualifier that changes the mode of the variable, leave
 4056     * the setting alone.
 4057     */
 4058    assert(var->data.mode != ir_var_temporary);
 4059    if (qual->flags.q.in && qual->flags.q.out)
 4060       var->data.mode = is_parameter ? ir_var_function_inout : ir_var_shader_out;
 4061    else if (qual->flags.q.in)
 4062       var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in;
 4063    else if (qual->flags.q.attribute
 4064             || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
 4065       var->data.mode = ir_var_shader_in;
 4066    else if (qual->flags.q.out)
 4067       var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out;
 4068    else if (qual->flags.q.varying && (state->stage == MESA_SHADER_VERTEX))
 4069       var->data.mode = ir_var_shader_out;
 4070    else if (qual->flags.q.uniform)
 4071       var->data.mode = ir_var_uniform;
 4072    else if (qual->flags.q.buffer)
 4073       var->data.mode = ir_var_shader_storage;
 4074    else if (qual->flags.q.shared_storage)
 4075       var->data.mode = ir_var_shader_shared;
 4076 
 4077    if (!is_parameter && state->has_framebuffer_fetch() &&
 4078        state->stage == MESA_SHADER_FRAGMENT) {
 4079       if (state->is_version(130, 300))
 4080          var->data.fb_fetch_output = qual->flags.q.in && qual->flags.q.out;
 4081       else
 4082          var->data.fb_fetch_output = (strcmp(var->name, "gl_LastFragData") == 0);
 4083    }
 4084 
 4085    if (var->data.fb_fetch_output) {
 4086       var->data.assigned = true;
 4087       var->data.memory_coherent = !qual->flags.q.non_coherent;
 4088 
 4089       /* From the EXT_shader_framebuffer_fetch spec:
 4090        *
 4091        *   "It is an error to declare an inout fragment output not qualified
 4092        *    with layout(noncoherent) if the GL_EXT_shader_framebuffer_fetch
 4093        *    extension hasn't been enabled."
 4094        */
 4095       if (var->data.memory_coherent &&
 4096           !state->EXT_shader_framebuffer_fetch_enable)
 4097          _mesa_glsl_error(loc, state,
 4098                           "invalid declaration of framebuffer fetch output not "
 4099                           "qualified with layout(noncoherent)");
 4100 
 4101    } else {
 4102       /* From the EXT_shader_framebuffer_fetch spec:
 4103        *
 4104        *   "Fragment outputs declared inout may specify the following layout
 4105        *    qualifier: [...] noncoherent"
 4106        */
 4107       if (qual->flags.q.non_coherent)
 4108          _mesa_glsl_error(loc, state,
 4109                           "invalid layout(noncoherent) qualifier not part of "
 4110                           "framebuffer fetch output declaration");
 4111    }
 4112 
 4113    if (!is_parameter && is_varying_var(var, state->stage)) {
 4114       /* User-defined ins/outs are not permitted in compute shaders. */
 4115       if (state->stage == MESA_SHADER_COMPUTE) {
 4116          _mesa_glsl_error(loc, state,
 4117                           "user-defined input and output variables are not "
 4118                           "permitted in compute shaders");
 4119       }
 4120 
 4121       /* This variable is being used to link data between shader stages (in
 4122        * pre-glsl-1.30 parlance, it's a "varying").  Check that it has a type
 4123        * that is allowed for such purposes.
 4124        *
 4125        * From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:
 4126        *
 4127        *     "The varying qualifier can be used only with the data types
 4128        *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of
 4129        *     these."
 4130        *
 4131        * This was relaxed in GLSL version 1.30 and GLSL ES version 3.00.  From
 4132        * page 31 (page 37 of the PDF) of the GLSL 1.30 spec:
 4133        *
 4134        *     "Fragment inputs can only be signed and unsigned integers and
 4135        *     integer vectors, float, floating-point vectors, matrices, or
 4136        *     arrays of these. Structures cannot be input.
 4137        *
 4138        * Similar text exists in the section on vertex shader outputs.
 4139        *
 4140        * Similar text exists in the GLSL ES 3.00 spec, except that the GLSL ES
 4141        * 3.00 spec allows structs as well.  Varying structs are also allowed
 4142        * in GLSL 1.50.
 4143        *
 4144        * From section 4.3.4 of the ARB_bindless_texture spec:
 4145        *
 4146        *     "(modify third paragraph of the section to allow sampler and image
 4147        *     types) ...  Vertex shader inputs can only be float,
 4148        *     single-precision floating-point scalars, single-precision
 4149        *     floating-point vectors, matrices, signed and unsigned integers
 4150        *     and integer vectors, sampler and image types."
 4151        *
 4152        * From section 4.3.6 of the ARB_bindless_texture spec:
 4153        *
 4154        *     "Output variables can only be floating-point scalars,
 4155        *     floating-point vectors, matrices, signed or unsigned integers or
 4156        *     integer vectors, sampler or image types, or arrays or structures
 4157        *     of any these."
 4158        */
 4159       switch (var->type->without_array()->base_type) {
 4160       case GLSL_TYPE_FLOAT:
 4161          /* Ok in all GLSL versions */
 4162          break;
 4163       case GLSL_TYPE_UINT:
 4164       case GLSL_TYPE_INT:
 4165          if (state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
 4166             break;
 4167          _mesa_glsl_error(loc, state,
 4168                           "varying variables must be of base type float in %s",
 4169                           state->get_version_string());
 4170          break;
 4171       case GLSL_TYPE_STRUCT:
 4172          if (state->is_version(150, 300))
 4173             break;
 4174          _mesa_glsl_error(loc, state,
 4175                           "varying variables may not be of type struct");
 4176          break;
 4177       case GLSL_TYPE_DOUBLE:
 4178       case GLSL_TYPE_UINT64:
 4179       case GLSL_TYPE_INT64:
 4180          break;
 4181       case GLSL_TYPE_SAMPLER:
 4182       case GLSL_TYPE_IMAGE:
 4183          if (state->has_bindless())
 4184             break;
 4185          /* fallthrough */
 4186       default:
 4187          _mesa_glsl_error(loc, state, "illegal type for a varying variable");
 4188          break;
 4189       }
 4190    }
 4191 
 4192    if (state->all_invariant && var->data.mode == ir_var_shader_out) {
 4193       var->data.explicit_invariant = true;
 4194       var->data.invariant = true;
 4195    }
 4196 
 4197    var->data.interpolation =
 4198       interpret_interpolation_qualifier(qual, var->type,
 4199                                         (ir_variable_mode) var->data.mode,
 4200                                         state, loc);
 4201 
 4202    /* Does the declaration use the deprecated 'attribute' or 'varying'
 4203     * keywords?
 4204     */
 4205    const bool uses_deprecated_qualifier = qual->flags.q.attribute
 4206       || qual->flags.q.varying;
 4207 
 4208 
 4209    /* Validate auxiliary storage qualifiers */
 4210 
 4211    /* From section 4.3.4 of the GLSL 1.30 spec:
 4212     *    "It is an error to use centroid in in a vertex shader."
 4213     *
 4214     * From section 4.3.4 of the GLSL ES 3.00 spec:
 4215     *    "It is an error to use centroid in or interpolation qualifiers in
 4216     *    a vertex shader input."
 4217     */
 4218 
 4219    /* Section 4.3.6 of the GLSL 1.30 specification states:
 4220     * "It is an error to use centroid out in a fragment shader."
 4221     *
 4222     * The GL_ARB_shading_language_420pack extension specification states:
 4223     * "It is an error to use auxiliary storage qualifiers or interpolation
 4224     *  qualifiers on an output in a fragment shader."
 4225     */
 4226    if (qual->flags.q.sample && (!is_varying_var(var, state->stage) || uses_deprecated_qualifier)) {
 4227       _mesa_glsl_error(loc, state,
 4228                        "sample qualifier may only be used on `in` or `out` "
 4229                        "variables between shader stages");
 4230    }
 4231    if (qual->flags.q.centroid && !is_varying_var(var, state->stage)) {
 4232       _mesa_glsl_error(loc, state,
 4233                        "centroid qualifier may only be used with `in', "
 4234                        "`out' or `varying' variables between shader stages");
 4235    }
 4236 
 4237    if (qual->flags.q.shared_storage && state->stage != MESA_SHADER_COMPUTE) {
 4238       _mesa_glsl_error(loc, state,
 4239                        "the shared storage qualifiers can only be used with "
 4240                        "compute shaders");
 4241    }
 4242 
 4243    apply_image_qualifier_to_variable(qual, var, state, loc);
 4244 }
 4245 
 4246 /**
 4247  * Get the variable that is being redeclared by this declaration or if it
 4248  * does not exist, the current declared variable.
 4249  *
 4250  * Semantic checks to verify the validity of the redeclaration are also
 4251  * performed.  If semantic checks fail, compilation error will be emitted via
 4252  * \c _mesa_glsl_error, but a non-\c NULL pointer will still be returned.
 4253  *
 4254  * \returns
 4255  * A pointer to an existing variable in the current scope if the declaration
 4256  * is a redeclaration, current variable otherwise. \c is_declared boolean
 4257  * will return \c true if the declaration is a redeclaration, \c false
 4258  * otherwise.
 4259  */
 4260 static ir_variable *
 4261 get_variable_being_redeclared(ir_variable **var_ptr, YYLTYPE loc,
 4262                               struct _mesa_glsl_parse_state *state,
 4263                               bool allow_all_redeclarations,
 4264                               bool *is_redeclaration)
 4265 {
 4266    ir_variable *var = *var_ptr;
 4267 
 4268    /* Check if this declaration is actually a re-declaration, either to
 4269     * resize an array or add qualifiers to an existing variable.
 4270     *
 4271     * This is allowed for variables in the current scope, or when at
 4272     * global scope (for built-ins in the implicit outer scope).
 4273     */
 4274    ir_variable *earlier = state->symbols->get_variable(var->name);
 4275    if (earlier == NULL ||
 4276        (state->current_function != NULL &&
 4277        !state->symbols->name_declared_this_scope(var->name))) {
 4278       *is_redeclaration = false;
 4279       return var;
 4280    }
 4281 
 4282    *is_redeclaration = true;
 4283 
 4284    if (earlier->data.how_declared == ir_var_declared_implicitly) {
 4285       /* Verify that the redeclaration of a built-in does not change the
 4286        * storage qualifier.  There are a couple special cases.
 4287        *
 4288        * 1. Some built-in variables that are defined as 'in' in the
 4289        *    specification are implemented as system values.  Allow
 4290        *    ir_var_system_value -> ir_var_shader_in.
 4291        *
 4292        * 2. gl_LastFragData is implemented as a ir_var_shader_out, but the
 4293        *    specification requires that redeclarations omit any qualifier.
 4294        *    Allow ir_var_shader_out -> ir_var_auto for this one variable.
 4295        */
 4296       if (earlier->data.mode != var->data.mode &&
 4297           !(earlier->data.mode == ir_var_system_value &&
 4298             var->data.mode == ir_var_shader_in) &&
 4299           !(strcmp(var->name, "gl_LastFragData") == 0 &&
 4300             var->data.mode == ir_var_auto)) {
 4301          _mesa_glsl_error(&loc, state,
 4302                           "redeclaration cannot change qualification of `%s'",
 4303                           var->name);
 4304       }
 4305    }
 4306 
 4307    /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec,
 4308     *
 4309     * "It is legal to declare an array without a size and then
 4310     *  later re-declare the same name as an array of the same
 4311     *  type and specify a size."
 4312     */
 4313    if (earlier->type->is_unsized_array() && var->type->is_array()
 4314        && (var->type->fields.array == earlier->type->fields.array)) {
 4315       const int size = var->type->array_size();
 4316       check_builtin_array_max_size(var->name, size, loc, state);
 4317       if ((size > 0) && (size <= earlier->data.max_array_access)) {
 4318          _mesa_glsl_error(& loc, state, "array size must be > %u due to "
 4319                           "previous access",
 4320                           earlier->data.max_array_access);
 4321       }
 4322 
 4323       earlier->type = var->type;
 4324       delete var;
 4325       var = NULL;
 4326       *var_ptr = NULL;
 4327    } else if (earlier->type != var->type) {
 4328       _mesa_glsl_error(&loc, state,
 4329                        "redeclaration of `%s' has incorrect type",
 4330                        var->name);
 4331    } else if ((state->ARB_fragment_coord_conventions_enable ||
 4332               state->is_version(150, 0))
 4333               && strcmp(var->name, "gl_FragCoord") == 0) {
 4334       /* Allow redeclaration of gl_FragCoord for ARB_fcc layout
 4335        * qualifiers.
 4336        *
 4337        * We don't really need to do anything here, just allow the
 4338        * redeclaration. Any error on the gl_FragCoord is handled on the ast
 4339        * level at apply_layout_qualifier_to_variable using the
 4340        * ast_type_qualifier and _mesa_glsl_parse_state, or later at
 4341        * linker.cpp.
 4342        */
 4343       /* According to section 4.3.7 of the GLSL 1.30 spec,
 4344        * the following built-in varaibles can be redeclared with an
 4345        * interpolation qualifier:
 4346        *    * gl_FrontColor
 4347        *    * gl_BackColor
 4348        *    * gl_FrontSecondaryColor
 4349        *    * gl_BackSecondaryColor
 4350        *    * gl_Color
 4351        *    * gl_SecondaryColor
 4352        */
 4353    } else if (state->is_version(130, 0)
 4354               && (strcmp(var->name, "gl_FrontColor") == 0
 4355                   || strcmp(var->name, "gl_BackColor") == 0
 4356                   || strcmp(var->name, "gl_FrontSecondaryColor") == 0
 4357                   || strcmp(var->name, "gl_BackSecondaryColor") == 0
 4358                   || strcmp(var->name, "gl_Color") == 0
 4359                   || strcmp(var->name, "gl_SecondaryColor") == 0)) {
 4360       earlier->data.interpolation = var->data.interpolation;
 4361 
 4362       /* Layout qualifiers for gl_FragDepth. */
 4363    } else if ((state->is_version(420, 0) ||
 4364                state->AMD_conservative_depth_enable ||
 4365                state->ARB_conservative_depth_enable)
 4366               && strcmp(var->name, "gl_FragDepth") == 0) {
 4367 
 4368       /** From the AMD_conservative_depth spec:
 4369        *     Within any shader, the first redeclarations of gl_FragDepth
 4370        *     must appear before any use of gl_FragDepth.
 4371        */
 4372       if (earlier->data.used) {
 4373          _mesa_glsl_error(&loc, state,
 4374                           "the first redeclaration of gl_FragDepth "
 4375                           "must appear before any use of gl_FragDepth");
 4376       }
 4377 
 4378       /* Prevent inconsistent redeclaration of depth layout qualifier. */
 4379       if (earlier->data.depth_layout != ir_depth_layout_none
 4380           && earlier->data.depth_layout != var->data.depth_layout) {
 4381             _mesa_glsl_error(&loc, state,
 4382                              "gl_FragDepth: depth layout is declared here "
 4383                              "as '%s, but it was previously declared as "
 4384                              "'%s'",
 4385                              depth_layout_string(var->data.depth_layout),
 4386                              depth_layout_string(earlier->data.depth_layout));
 4387       }
 4388 
 4389       earlier->data.depth_layout = var->data.depth_layout;
 4390 
 4391    } else if (state->has_framebuffer_fetch() &&
 4392               strcmp(var->name, "gl_LastFragData") == 0 &&
 4393               var->data.mode == ir_var_auto) {
 4394       /* According to the EXT_shader_framebuffer_fetch spec:
 4395        *
 4396        *   "By default, gl_LastFragData is declared with the mediump precision
 4397        *    qualifier. This can be changed by redeclaring the corresponding
 4398        *    variables with the desired precision qualifier."
 4399        *
 4400        *   "Fragment shaders may specify the following layout qualifier only for
 4401        *    redeclaring the built-in gl_LastFragData array [...]: noncoherent"
 4402        */
 4403       earlier->data.precision = var->data.precision;
 4404       earlier->data.memory_coherent = var->data.memory_coherent;
 4405 
 4406    } else if (state->NV_viewport_array2_enable &&
 4407               strcmp(var->name, "gl_Layer") == 0 &&
 4408               earlier->data.how_declared == ir_var_declared_implicitly) {
 4409       /* No need to do anything, just allow it. Qualifier is stored in state */
 4410 
 4411    } else if ((earlier->data.how_declared == ir_var_declared_implicitly &&
 4412                state->allow_builtin_variable_redeclaration) ||
 4413               allow_all_redeclarations) {
 4414       /* Allow verbatim redeclarations of built-in variables. Not explicitly
 4415        * valid, but some applications do it.
 4416        */
 4417    } else {
 4418       _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name);
 4419    }
 4420 
 4421    return earlier;
 4422 }
 4423 
 4424 /**
 4425  * Generate the IR for an initializer in a variable declaration
 4426  */
 4427 static ir_rvalue *
 4428 process_initializer(ir_variable *var, ast_declaration *decl,
 4429                     ast_fully_specified_type *type,
 4430                     exec_list *initializer_instructions,
 4431                     struct _mesa_glsl_parse_state *state)
 4432 {
 4433    void *mem_ctx = state;
 4434    ir_rvalue *result = NULL;
 4435 
 4436    YYLTYPE initializer_loc = decl->initializer->get_location();
 4437 
 4438    /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:
 4439     *
 4440     *    "All uniform variables are read-only and are initialized either
 4441     *    directly by an application via API commands, or indirectly by
 4442     *    OpenGL."
 4443     */
 4444    if (var->data.mode == ir_var_uniform) {
 4445       state->check_version(120, 0, &initializer_loc,
 4446                            "cannot initialize uniform %s",
 4447                            var->name);
 4448    }
 4449 
 4450    /* Section 4.3.7 "Buffer Variables" of the GLSL 4.30 spec:
 4451     *
 4452     *    "Buffer variables cannot have initializers."
 4453     */
 4454    if (var->data.mode == ir_var_shader_storage) {
 4455       _mesa_glsl_error(&initializer_loc, state,
 4456                        "cannot initialize buffer variable %s",
 4457                        var->name);
 4458    }
 4459 
 4460    /* From section 4.1.7 of the GLSL 4.40 spec:
 4461     *
 4462     *    "Opaque variables [...] are initialized only through the
 4463     *     OpenGL API; they cannot be declared with an initializer in a
 4464     *     shader."
 4465     *
 4466     * From section 4.1.7 of the ARB_bindless_texture spec:
 4467     *
 4468     *    "Samplers may be declared as shader inputs and outputs, as uniform
 4469     *     variables, as temporary variables, and as function parameters."
 4470     *
 4471     * From section 4.1.X of the ARB_bindless_texture spec:
 4472     *
 4473     *    "Images may be declared as shader inputs and outputs, as uniform
 4474     *     variables, as temporary variables, and as function parameters."
 4475     */
 4476    if (var->type->contains_atomic() ||
 4477        (!state->has_bindless() && var->type->contains_opaque())) {
 4478       _mesa_glsl_error(&initializer_loc, state,
 4479                        "cannot initialize %s variable %s",
 4480                        var->name, state->has_bindless() ? "atomic" : "opaque");
 4481    }
 4482 
 4483    if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
 4484       _mesa_glsl_error(&initializer_loc, state,
 4485                        "cannot initialize %s shader input / %s %s",
 4486                        _mesa_shader_stage_to_string(state->stage),
 4487                        (state->stage == MESA_SHADER_VERTEX)
 4488                        ? "attribute" : "varying",
 4489                        var->name);
 4490    }
 4491 
 4492    if (var->data.mode == ir_var_shader_out && state->current_function == NULL) {
 4493       _mesa_glsl_error(&initializer_loc, state,
 4494                        "cannot initialize %s shader output %s",
 4495                        _mesa_shader_stage_to_string(state->stage),
 4496                        var->name);
 4497    }
 4498 
 4499    /* If the initializer is an ast_aggregate_initializer, recursively store
 4500     * type information from the LHS into it, so that its hir() function can do
 4501     * type checking.
 4502     */
 4503    if (decl->initializer->oper == ast_aggregate)
 4504       _mesa_ast_set_aggregate_type(var->type, decl->initializer);
 4505 
 4506    ir_dereference *const lhs = new(state) ir_dereference_variable(var);
 4507    ir_rvalue *rhs = decl->initializer->hir(initializer_instructions, state);
 4508 
 4509    /* Calculate the constant value if this is a const or uniform
 4510     * declaration.
 4511     *
 4512     * Section 4.3 (Storage Qualifiers) of the GLSL ES 1.00.17 spec says:
 4513     *
 4514     *     "Declarations of globals without a storage qualifier, or with
 4515     *     just the const qualifier, may include initializers, in which case
 4516     *     they will be initialized before the first line of main() is
 4517     *     executed.  Such initializers must be a constant expression."
 4518     *
 4519     * The same section of the GLSL ES 3.00.4 spec has similar language.
 4520     */
 4521    if (type->qualifier.flags.q.constant
 4522        || type->qualifier.flags.q.uniform
 4523        || (state->es_shader && state->current_function == NULL)) {
 4524       ir_rvalue *new_rhs = validate_assignment(state, initializer_loc,
 4525                                                lhs, rhs, true);
 4526       if (new_rhs != NULL) {
 4527          rhs = new_rhs;
 4528 
 4529          /* Section 4.3.3 (Constant Expressions) of the GLSL ES 3.00.4 spec
 4530           * says:
 4531           *
 4532           *     "A constant expression is one of
 4533           *
 4534           *        ...
 4535           *
 4536           *        - an expression formed by an operator on operands that are
 4537           *          all constant expressions, including getting an element of
 4538           *          a constant array, or a field of a constant structure, or
 4539           *          components of a constant vector.  However, the sequence
 4540           *          operator ( , ) and the assignment operators ( =, +=, ...)
 4541           *          are not included in the operators that can create a
 4542           *          constant expression."
 4543           *
 4544           * Section 12.43 (Sequence operator and constant expressions) says:
 4545           *
 4546           *     "Should the following construct be allowed?
 4547           *
 4548           *         float a[2,3];
 4549           *
 4550           *     The expression within the brackets uses the sequence operator
 4551           *     (',') and returns the integer 3 so the construct is declaring
 4552           *     a single-dimensional array of size 3.  In some languages, the
 4553           *     construct declares a two-dimensional array.  It would be
 4554           *     preferable to make this construct illegal to avoid confusion.
 4555           *
 4556           *     One possibility is to change the definition of the sequence
 4557           *     operator so that it does not return a constant-expression and
 4558           *     hence cannot be used to declare an array size.
 4559           *
 4560           *     RESOLUTION: The result of a sequence operator is not a
 4561           *     constant-expression."
 4562           *
 4563           * Section 4.3.3 (Constant Expressions) of the GLSL 4.30.9 spec
 4564           * contains language almost identical to the section 4.3.3 in the
 4565           * GLSL ES 3.00.4 spec.  This is a new limitation for these GLSL
 4566           * versions.
 4567           */
 4568          ir_constant *constant_value =
 4569             rhs->constant_expression_value(mem_ctx);
 4570 
 4571          if (!constant_value ||
 4572              (state->is_version(430, 300) &&
 4573               decl->initializer->has_sequence_subexpression())) {
 4574             const char *const variable_mode =
 4575                (type->qualifier.flags.q.constant)
 4576                ? "const"
 4577                : ((type->qualifier.flags.q.uniform) ? "uniform" : "global");
 4578 
 4579             /* If ARB_shading_language_420pack is enabled, initializers of
 4580              * const-qualified local variables do not have to be constant
 4581              * expressions. Const-qualified global variables must still be
 4582              * initialized with constant expressions.
 4583              */
 4584             if (!state->has_420pack()
 4585                 || state->current_function == NULL) {
 4586                _mesa_glsl_error(& initializer_loc, state,
 4587                                 "initializer of %s variable `%s' must be a "
 4588                                 "constant expression",
 4589                                 variable_mode,
 4590                                 decl->identifier);
 4591                if (var->type->is_numeric()) {
 4592                   /* Reduce cascading errors. */
 4593                   var->constant_value = type->qualifier.flags.q.constant
 4594                      ? ir_constant::zero(state, var->type) : NULL;
 4595                }
 4596             }
 4597          } else {
 4598             rhs = constant_value;
 4599             var->constant_value = type->qualifier.flags.q.constant
 4600                ? constant_value : NULL;
 4601          }
 4602       } else {
 4603          if (var->type->is_numeric()) {
 4604             /* Reduce cascading errors. */
 4605             rhs = var->constant_value = type->qualifier.flags.q.constant
 4606                ? ir_constant::zero(state, var->type) : NULL;
 4607          }
 4608       }
 4609    }
 4610 
 4611    if (rhs && !rhs->type->is_error()) {
 4612       bool temp = var->data.read_only;
 4613       if (type->qualifier.flags.q.constant)
 4614          var->data.read_only = false;
 4615 
 4616       /* Never emit code to initialize a uniform.
 4617        */
 4618       const glsl_type *initializer_type;
 4619       bool error_emitted = false;
 4620       if (!type->qualifier.flags.q.uniform) {
 4621          error_emitted =
 4622             do_assignment(initializer_instructions, state,
 4623                           NULL, lhs, rhs,
 4624                           &result, true, true,
 4625                           type->get_location());
 4626          initializer_type = result->type;
 4627       } else
 4628          initializer_type = rhs->type;
 4629 
 4630       if (!error_emitted) {
 4631          var->constant_initializer = rhs->constant_expression_value(mem_ctx);
 4632          var->data.has_initializer = true;
 4633 
 4634          /* If the declared variable is an unsized array, it must inherrit
 4635          * its full type from the initializer.  A declaration such as
 4636          *
 4637          *     uniform float a[] = float[](1.0, 2.0, 3.0, 3.0);
 4638          *
 4639          * becomes
 4640          *
 4641          *     uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0);
 4642          *
 4643          * The assignment generated in the if-statement (below) will also
 4644          * automatically handle this case for non-uniforms.
 4645          *
 4646          * If the declared variable is not an array, the types must
 4647          * already match exactly.  As a result, the type assignment
 4648          * here can be done unconditionally.  For non-uniforms the call
 4649          * to do_assignment can change the type of the initializer (via
 4650          * the implicit conversion rules).  For uniforms the initializer
 4651          * must be a constant expression, and the type of that expression
 4652          * was validated above.
 4653          */
 4654          var->type = initializer_type;
 4655       }
 4656 
 4657       var->data.read_only = temp;
 4658    }
 4659 
 4660    return result;
 4661 }
 4662 
 4663 static void
 4664 validate_layout_qualifier_vertex_count(struct _mesa_glsl_parse_state *state,
 4665                                        YYLTYPE loc, ir_variable *var,
 4666                                        unsigned num_vertices,
 4667                                        unsigned *size,
 4668                                        const char *var_category)
 4669 {
 4670    if (var->type->is_unsized_array()) {
 4671       /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec says:
 4672        *
 4673        *   All geometry shader input unsized array declarations will be
 4674        *   sized by an earlier input layout qualifier, when present, as per
 4675        *   the following table.
 4676        *
 4677        * Followed by a table mapping each allowed input layout qualifier to
 4678        * the corresponding input length.
 4679        *
 4680        * Similarly for tessellation control shader outputs.
 4681        */
 4682       if (num_vertices != 0)
 4683          var->type = glsl_type::get_array_instance(var->type->fields.array,
 4684                                                    num_vertices);
 4685    } else {
 4686       /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec
 4687        * includes the following examples of compile-time errors:
 4688        *
 4689        *   // code sequence within one shader...
 4690        *   in vec4 Color1[];    // size unknown
 4691        *   ...Color1.length()...// illegal, length() unknown
 4692        *   in vec4 Color2[2];   // size is 2
 4693        *   ...Color1.length()...// illegal, Color1 still has no size
 4694        *   in vec4 Color3[3];   // illegal, input sizes are inconsistent
 4695        *   layout(lines) in;    // legal, input size is 2, matching
 4696        *   in vec4 Color4[3];   // illegal, contradicts layout
 4697        *   ...
 4698        *
 4699        * To detect the case illustrated by Color3, we verify that the size of
 4700        * an explicitly-sized array matches the size of any previously declared
 4701        * explicitly-sized array.  To detect the case illustrated by Color4, we
 4702        * verify that the size of an explicitly-sized array is consistent with
 4703        * any previously declared input layout.
 4704        */
 4705       if (num_vertices != 0 && var->type->length != num_vertices) {
 4706          _mesa_glsl_error(&loc, state,
 4707                           "%s size contradicts previously declared layout "
 4708                           "(size is %u, but layout requires a size of %u)",
 4709                           var_category, var->type->length, num_vertices);
 4710       } else if (*size != 0 && var->type->length != *size) {
 4711          _mesa_glsl_error(&loc, state,
 4712                           "%s sizes are inconsistent (size is %u, but a "
 4713                           "previous declaration has size %u)",
 4714                           var_category, var->type->length, *size);
 4715       } else {
 4716          *size = var->type->length;
 4717       }
 4718    }
 4719 }
 4720 
 4721 static void
 4722 handle_tess_ctrl_shader_output_decl(struct _mesa_glsl_parse_state *state,
 4723                                     YYLTYPE loc, ir_variable *var)
 4724 {
 4725    unsigned num_vertices = 0;
 4726 
 4727    if (state->tcs_output_vertices_specified) {
 4728       if (!state->out_qualifier->vertices->
 4729              process_qualifier_constant(state, "vertices",
 4730                                         &num_vertices, false)) {
 4731          return;
 4732       }
 4733 
 4734       if (num_vertices > state->Const.MaxPatchVertices) {
 4735          _mesa_glsl_error(&loc, state, "vertices (%d) exceeds "
 4736                           "GL_MAX_PATCH_VERTICES", num_vertices);
 4737          return;
 4738       }
 4739    }
 4740 
 4741    if (!var->type->is_array() && !var->data.patch) {
 4742       _mesa_glsl_error(&loc, state,
 4743                        "tessellation control shader outputs must be arrays");
 4744 
 4745       /* To avoid cascading failures, short circuit the checks below. */
 4746       return;
 4747    }
 4748 
 4749    if (var->data.patch)
 4750       return;
 4751 
 4752    validate_layout_qualifier_vertex_count(state, loc, var, num_vertices,
 4753                                           &state->tcs_output_size,
 4754                                           "tessellation control shader output");
 4755 }
 4756 
 4757 /**
 4758  * Do additional processing necessary for tessellation control/evaluation shader
 4759  * input declarations. This covers both interface block arrays and bare input
 4760  * variables.
 4761  */
 4762 static void
 4763 handle_tess_shader_input_decl(struct _mesa_glsl_parse_state *state,
 4764                               YYLTYPE loc, ir_variable *var)
 4765 {
 4766    if (!var->type->is_array() && !var->data.patch) {
 4767       _mesa_glsl_error(&loc, state,
 4768                        "per-vertex tessellation shader inputs must be arrays");
 4769       /* Avoid cascading failures. */
 4770       return;
 4771    }
 4772 
 4773    if (var->data.patch)
 4774       return;
 4775 
 4776    /* The ARB_tessellation_shader spec says:
 4777     *
 4778     *    "Declaring an array size is optional.  If no size is specified, it
 4779     *     will be taken from the implementation-dependent maximum patch size
 4780     *     (gl_MaxPatchVertices).  If a size is specified, it must match the
 4781     *     maximum patch size; otherwise, a compile or link error will occur."
 4782     *
 4783     * This text appears twice, once for TCS inputs, and again for TES inputs.
 4784     */
 4785    if (var->type->is_unsized_array()) {
 4786       var->type = glsl_type::get_array_instance(var->type->fields.array,
 4787             state->Const.MaxPatchVertices);
 4788    } else if (var->type->length != state->Const.MaxPatchVertices) {
 4789       _mesa_glsl_error(&loc, state,
 4790                        "per-vertex tessellation shader input arrays must be "
 4791                        "sized to gl_MaxPatchVertices (%d).",
 4792                        state->Const.MaxPatchVertices);
 4793    }
 4794 }
 4795 
 4796 
 4797 /**
 4798  * Do additional processing necessary for geometry shader input declarations
 4799  * (this covers both interface blocks arrays and bare input variables).
 4800  */
 4801 static void
 4802 handle_geometry_shader_input_decl(struct _mesa_glsl_parse_state *state,
 4803                                   YYLTYPE loc, ir_variable *var)
 4804 {
 4805    unsigned num_vertices = 0;
 4806 
 4807    if (state->gs_input_prim_type_specified) {
 4808       num_vertices = vertices_per_prim(state->in_qualifier->prim_type);
 4809    }
 4810 
 4811    /* Geometry shader input variables must be arrays.  Caller should have
 4812     * reported an error for this.
 4813     */
 4814    if (!var->type->is_array()) {
 4815       assert(state->error);
 4816 
 4817       /* To avoid cascading failures, short circuit the checks below. */
 4818       return;
 4819    }
 4820 
 4821    validate_layout_qualifier_vertex_count(state, loc, var, num_vertices,
 4822                                           &state->gs_input_size,
 4823                                           "geometry shader input");
 4824 }
 4825 
 4826 static void
 4827 validate_identifier(const char *identifier, YYLTYPE loc,
 4828                     struct _mesa_glsl_parse_state *state)
 4829 {
 4830    /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
 4831     *
 4832     *   "Identifiers starting with "gl_" are reserved for use by
 4833     *   OpenGL, and may not be declared in a shader as either a
 4834     *   variable or a function."
 4835     */
 4836    if (is_gl_identifier(identifier)) {
 4837       _mesa_glsl_error(&loc, state,
 4838                        "identifier `%s' uses reserved `gl_' prefix",
 4839                        identifier);
 4840    } else if (strstr(identifier, "__")) {
 4841       /* From page 14 (page 20 of the PDF) of the GLSL 1.10
 4842        * spec:
 4843        *
 4844        *     "In addition, all identifiers containing two
 4845        *      consecutive underscores (__) are reserved as
 4846        *      possible future keywords."
 4847        *
 4848        * The intention is that names containing __ are reserved for internal
 4849        * use by the implementation, and names prefixed with GL_ are reserved
 4850        * for use by Khronos.  Names simply containing __ are dangerous to use,
 4851        * but should be allowed.
 4852        *
 4853        * A future version of the GLSL specification will clarify this.
 4854        */
 4855       _mesa_glsl_warning(&loc, state,
 4856                          "identifier `%s' uses reserved `__' string",
 4857                          identifier);
 4858    }
 4859 }
 4860 
 4861 ir_rvalue *
 4862 ast_declarator_list::hir(exec_list *instructions,
 4863                          struct _mesa_glsl_parse_state *state)
 4864 {
 4865    void *ctx = state;
 4866    const struct glsl_type *decl_type;
 4867    const char *type_name = NULL;
 4868    ir_rvalue *result = NULL;
 4869    YYLTYPE loc = this->get_location();
 4870 
 4871    /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec:
 4872     *
 4873     *     "To ensure that a particular output variable is invariant, it is
 4874     *     necessary to use the invariant qualifier. It can either be used to
 4875     *     qualify a previously declared variable as being invariant
 4876     *
 4877     *         invariant gl_Position; // make existing gl_Position be invariant"
 4878     *
 4879     * In these cases the parser will set the 'invariant' flag in the declarator
 4880     * list, and the type will be NULL.
 4881     */
 4882    if (this->invariant) {
 4883       assert(this->type == NULL);
 4884 
 4885       if (state->current_function != NULL) {
 4886          _mesa_glsl_error(& loc, state,
 4887                           "all uses of `invariant' keyword must be at global "
 4888                           "scope");
 4889       }
 4890 
 4891       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
 4892          assert(decl->array_specifier == NULL);
 4893          assert(decl->initializer == NULL);
 4894 
 4895          ir_variable *const earlier =
 4896             state->symbols->get_variable(decl->identifier);
 4897          if (earlier == NULL) {
 4898             _mesa_glsl_error(& loc, state,
 4899                              "undeclared variable `%s' cannot be marked "
 4900                              "invariant", decl->identifier);
 4901          } else if (!is_allowed_invariant(earlier, state)) {
 4902             _mesa_glsl_error(&loc, state,
 4903                              "`%s' cannot be marked invariant; interfaces between "
 4904                              "shader stages only.", decl->identifier);
 4905          } else if (earlier->data.used) {
 4906             _mesa_glsl_error(& loc, state,
 4907                             "variable `%s' may not be redeclared "
 4908                             "`invariant' after being used",
 4909                             earlier->name);
 4910          } else {
 4911             earlier->data.explicit_invariant = true;
 4912             earlier->data.invariant = true;
 4913          }
 4914       }
 4915 
 4916       /* Invariant redeclarations do not have r-values.
 4917        */
 4918       return NULL;
 4919    }
 4920 
 4921    if (this->precise) {
 4922       assert(this->type == NULL);
 4923 
 4924       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
 4925          assert(decl->array_specifier == NULL);
 4926          assert(decl->initializer == NULL);
 4927 
 4928          ir_variable *const earlier =
 4929             state->symbols->get_variable(decl->identifier);
 4930          if (earlier == NULL) {
 4931             _mesa_glsl_error(& loc, state,
 4932                              "undeclared variable `%s' cannot be marked "
 4933                              "precise", decl->identifier);
 4934          } else if (state->current_function != NULL &&
 4935                     !state->symbols->name_declared_this_scope(decl->identifier)) {
 4936             /* Note: we have to check if we're in a function, since
 4937              * builtins are treated as having come from another scope.
 4938              */
 4939             _mesa_glsl_error(& loc, state,
 4940                              "variable `%s' from an outer scope may not be "
 4941                              "redeclared `precise' in this scope",
 4942                              earlier->name);
 4943          } else if (earlier->data.used) {
 4944             _mesa_glsl_error(& loc, state,
 4945                              "variable `%s' may not be redeclared "
 4946                              "`precise' after being used",
 4947                              earlier->name);
 4948          } else {
 4949             earlier->data.precise = true;
 4950          }
 4951       }
 4952 
 4953       /* Precise redeclarations do not have r-values either. */
 4954       return NULL;
 4955    }
 4956 
 4957    assert(this->type != NULL);
 4958    assert(!this->invariant);
 4959    assert(!this->precise);
 4960 
 4961    /* GL_EXT_shader_image_load_store base type uses GLSL_TYPE_VOID as a special value to
 4962     * indicate that it needs to be updated later (see glsl_parser.yy).
 4963     * This is done here, based on the layout qualifier and the type of the image var
 4964     */
 4965    if (this->type->qualifier.flags.q.explicit_image_format &&
 4966          this->type->specifier->type->is_image() &&
 4967          this->type->qualifier.image_base_type == GLSL_TYPE_VOID) {
 4968       /*     "The ARB_shader_image_load_store says:
 4969        *     If both extensions are enabled in the shading language, the "size*" layout
 4970        *     qualifiers are treated as format qualifiers, and are mapped to equivalent
 4971        *     format qualifiers in the table below, according to the type of image
 4972        *     variable.
 4973        *                     image*    iimage*   uimage*
 4974        *                     --------  --------  --------
 4975        *       size1x8       n/a       r8i       r8ui
 4976        *       size1x16      r16f      r16i      r16ui
 4977        *       size1x32      r32f      r32i      r32ui
 4978        *       size2x32      rg32f     rg32i     rg32ui
 4979        *       size4x32      rgba32f   rgba32i   rgba32ui"
 4980        */
 4981       if (strncmp(this->type->specifier->type_name, "image", strlen("image")) == 0) {
 4982          switch (this->type->qualifier.image_format) {
 4983          case PIPE_FORMAT_R8_SINT:
 4984             /* The GL_EXT_shader_image_load_store spec says:
 4985              *    A layout of "size1x8" is illegal for image variables associated
 4986              *    with floating-point data types.
 4987              */
 4988             _mesa_glsl_error(& loc, state,
 4989                              "size1x8 is illegal for image variables "
 4990                              "with floating-point data types.");
 4991             return NULL;
 4992          case PIPE_FORMAT_R16_SINT:
 4993             this->type->qualifier.image_format = PIPE_FORMAT_R16_FLOAT;
 4994             break;
 4995          case PIPE_FORMAT_R32_SINT:
 4996             this->type->qualifier.image_format = PIPE_FORMAT_R32_FLOAT;
 4997             break;
 4998          case PIPE_FORMAT_R32G32_SINT:
 4999             this->type->qualifier.image_format = PIPE_FORMAT_R32G32_FLOAT;
 5000             break;
 5001          case PIPE_FORMAT_R32G32B32A32_SINT:
 5002             this->type->qualifier.image_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 5003             break;
 5004          default:
 5005             unreachable("Unknown image format");
 5006          }
 5007          this->type->qualifier.image_base_type = GLSL_TYPE_FLOAT;
 5008       } else if (strncmp(this->type->specifier->type_name, "uimage", strlen("uimage")) == 0) {
 5009          switch (this->type->qualifier.image_format) {
 5010          case PIPE_FORMAT_R8_SINT:
 5011             this->type->qualifier.image_format = PIPE_FORMAT_R8_UINT;
 5012             break;
 5013          case PIPE_FORMAT_R16_SINT:
 5014             this->type->qualifier.image_format = PIPE_FORMAT_R16_UINT;
 5015             break;
 5016          case PIPE_FORMAT_R32_SINT:
 5017             this->type->qualifier.image_format = PIPE_FORMAT_R32_UINT;
 5018             break;
 5019          case PIPE_FORMAT_R32G32_SINT:
 5020             this->type->qualifier.image_format = PIPE_FORMAT_R32G32_UINT;
 5021             break;
 5022          case PIPE_FORMAT_R32G32B32A32_SINT:
 5023             this->type->qualifier.image_format = PIPE_FORMAT_R32G32B32A32_UINT;
 5024             break;
 5025          default:
 5026             unreachable("Unknown image format");
 5027          }
 5028          this->type->qualifier.image_base_type = GLSL_TYPE_UINT;
 5029       } else if (strncmp(this->type->specifier->type_name, "iimage", strlen("iimage")) == 0) {
 5030          this->type->qualifier.image_base_type = GLSL_TYPE_INT;
 5031       } else {
 5032          assert(false);
 5033       }
 5034    }
 5035 
 5036    /* The type specifier may contain a structure definition.  Process that
 5037     * before any of the variable declarations.
 5038     */
 5039    (void) this->type->specifier->hir(instructions, state);
 5040 
 5041    decl_type = this->type->glsl_type(& type_name, state);
 5042 
 5043    /* Section 4.3.7 "Buffer Variables" of the GLSL 4.30 spec:
 5044     *    "Buffer variables may only be declared inside interface blocks
 5045     *    (section 4.3.9 “Interface Blocks”), which are then referred to as
 5046     *    shader storage blocks. It is a compile-time error to declare buffer
 5047     *    variables at global scope (outside a block)."
 5048     */
 5049    if (type->qualifier.flags.q.buffer && !decl_type->is_interface()) {
 5050       _mesa_glsl_error(&loc, state,
 5051                        "buffer variables cannot be declared outside "
 5052                        "interface blocks");
 5053    }
 5054 
 5055    /* An offset-qualified atomic counter declaration sets the default
 5056     * offset for the next declaration within the same atomic counter
 5057     * buffer.
 5058     */
 5059    if (decl_type && decl_type->contains_atomic()) {
 5060       if (type->qualifier.flags.q.explicit_binding &&
 5061           type->qualifier.flags.q.explicit_offset) {
 5062          unsigned qual_binding;
 5063          unsigned qual_offset;
 5064          if (process_qualifier_constant(state, &loc, "binding",
 5065                                         type->qualifier.binding,
 5066                                         &qual_binding)
 5067              && process_qualifier_constant(state, &loc, "offset",
 5068                                         type->qualifier.offset,
 5069                                         &qual_offset)) {
 5070             if (qual_binding < ARRAY_SIZE(state->atomic_counter_offsets))
 5071                state->atomic_counter_offsets[qual_binding] = qual_offset;
 5072          }
 5073       }
 5074 
 5075       ast_type_qualifier allowed_atomic_qual_mask;
 5076       allowed_atomic_qual_mask.flags.i = 0;
 5077       allowed_atomic_qual_mask.flags.q.explicit_binding = 1;
 5078       allowed_atomic_qual_mask.flags.q.explicit_offset = 1;
 5079       allowed_atomic_qual_mask.flags.q.uniform = 1;
 5080 
 5081       type->qualifier.validate_flags(&loc, state, allowed_atomic_qual_mask,
 5082                                      "invalid layout qualifier for",
 5083                                      "atomic_uint");
 5084    }
 5085 
 5086    if (this->declarations.is_empty()) {
 5087       /* If there is no structure involved in the program text, there are two
 5088        * possible scenarios:
 5089        *
 5090        * - The program text contained something like 'vec4;'.  This is an
 5091        *   empty declaration.  It is valid but weird.  Emit a warning.
 5092        *
 5093        * - The program text contained something like 'S;' and 'S' is not the
 5094        *   name of a known structure type.  This is both invalid and weird.
 5095        *   Emit an error.
 5096        *
 5097        * - The program text contained something like 'mediump float;'
 5098        *   when the programmer probably meant 'precision mediump
 5099        *   float;' Emit a warning with a description of what they
 5100        *   probably meant to do.
 5101        *
 5102        * Note that if decl_type is NULL and there is a structure involved,
 5103        * there must have been some sort of error with the structure.  In this
 5104        * case we assume that an error was already generated on this line of
 5105        * code for the structure.  There is no need to generate an additional,
 5106        * confusing error.
 5107        */
 5108       assert(this->type->specifier->structure == NULL || decl_type != NULL
 5109              || state->error);
 5110 
 5111       if (decl_type == NULL) {
 5112          _mesa_glsl_error(&loc, state,
 5113                           "invalid type `%s' in empty declaration",
 5114                           type_name);
 5115       } else {
 5116          if (decl_type->is_array()) {
 5117             /* From Section 13.22 (Array Declarations) of the GLSL ES 3.2
 5118              * spec:
 5119              *
 5120              *    "... any declaration that leaves the size undefined is
 5121              *    disallowed as this would add complexity and there are no
 5122              *    use-cases."
 5123              */
 5124             if (state->es_shader && decl_type->is_unsized_array()) {
 5125                _mesa_glsl_error(&loc, state, "array size must be explicitly "
 5126                                 "or implicitly defined");
 5127             }
 5128 
 5129             /* From Section 4.12 (Empty Declarations) of the GLSL 4.5 spec:
 5130              *
 5131              *    "The combinations of types and qualifiers that cause
 5132              *    compile-time or link-time errors are the same whether or not
 5133              *    the declaration is empty."
 5134              */
 5135             validate_array_dimensions(decl_type, state, &loc);
 5136          }
 5137 
 5138          if (decl_type->is_atomic_uint()) {
 5139             /* Empty atomic counter declarations are allowed and useful
 5140              * to set the default offset qualifier.
 5141              */
 5142             return NULL;
 5143          } else if (this->type->qualifier.precision != ast_precision_none) {
 5144             if (this->type->specifier->structure != NULL) {
 5145                _mesa_glsl_error(&loc, state,
 5146                                 "precision qualifiers can't be applied "
 5147                                 "to structures");
 5148             } else {
 5149                static const char *const precision_names[] = {
 5150                   "highp",
 5151                   "highp",
 5152                   "mediump",
 5153                   "lowp"
 5154                };
 5155 
 5156                _mesa_glsl_warning(&loc, state,
 5157                                   "empty declaration with precision "
 5158                                   "qualifier, to set the default precision, "
 5159                                   "use `precision %s %s;'",
 5160                                   precision_names[this->type->
 5161                                      qualifier.precision],
 5162                                   type_name);
 5163             }
 5164          } else if (this->type->specifier->structure == NULL) {
 5165             _mesa_glsl_warning(&loc, state, "empty declaration");
 5166          }
 5167       }
 5168    }
 5169 
 5170    foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
 5171       const struct glsl_type *var_type;
 5172       ir_variable *var;
 5173       const char *identifier = decl->identifier;
 5174       /* FINISHME: Emit a warning if a variable declaration shadows a
 5175        * FINISHME: declaration at a higher scope.
 5176        */
 5177 
 5178       if ((decl_type == NULL) || decl_type->is_void()) {
 5179          if (type_name != NULL) {
 5180             _mesa_glsl_error(& loc, state,
 5181                              "invalid type `%s' in declaration of `%s'",
 5182                              type_name, decl->identifier);
 5183          } else {
 5184             _mesa_glsl_error(& loc, state,
 5185                              "invalid type in declaration of `%s'",
 5186                              decl->identifier);
 5187          }
 5188          continue;
 5189       }
 5190 
 5191       if (this->type->qualifier.is_subroutine_decl()) {
 5192          const glsl_type *t;
 5193          const char *name;
 5194 
 5195          t = state->symbols->get_type(this->type->specifier->type_name);
 5196          if (!t)
 5197             _mesa_glsl_error(& loc, state,
 5198                              "invalid type in declaration of `%s'",
 5199                              decl->identifier);
 5200          name = ralloc_asprintf(ctx, "%s_%s", _mesa_shader_stage_to_subroutine_prefix(state->stage), decl->identifier);
 5201 
 5202          identifier = name;
 5203 
 5204       }
 5205       var_type = process_array_type(&loc, decl_type, decl->array_specifier,
 5206                                     state);
 5207 
 5208       var = new(ctx) ir_variable(var_type, identifier, ir_var_auto);
 5209 
 5210       /* The 'varying in' and 'varying out' qualifiers can only be used with
 5211        * ARB_geometry_shader4 and EXT_geometry_shader4, which we don't support
 5212        * yet.
 5213        */
 5214       if (this->type->qualifier.flags.q.varying) {
 5215          if (this->type->qualifier.flags.q.in) {
 5216             _mesa_glsl_error(& loc, state,
 5217                              "`varying in' qualifier in declaration of "
 5218                              "`%s' only valid for geometry shaders using "
 5219                              "ARB_geometry_shader4 or EXT_geometry_shader4",
 5220                              decl->identifier);
 5221          } else if (this->type->qualifier.flags.q.out) {
 5222             _mesa_glsl_error(& loc, state,
 5223                              "`varying out' qualifier in declaration of "
 5224                              "`%s' only valid for geometry shaders using "
 5225                              "ARB_geometry_shader4 or EXT_geometry_shader4",
 5226                              decl->identifier);
 5227          }
 5228       }
 5229 
 5230       /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
 5231        *
 5232        *     "Global variables can only use the qualifiers const,
 5233        *     attribute, uniform, or varying. Only one may be
 5234        *     specified.
 5235        *
 5236        *     Local variables can only use the qualifier const."
 5237        *
 5238        * This is relaxed in GLSL 1.30 and GLSL ES 3.00.  It is also relaxed by
 5239        * any extension that adds the 'layout' keyword.
 5240        */
 5241       if (!state->is_version(130, 300)
 5242           && !state->has_explicit_attrib_location()
 5243           && !state->has_separate_shader_objects()
 5244           && !state->ARB_fragment_coord_conventions_enable) {
 5245          /* GL_EXT_gpu_shader4 only allows "varying out" on fragment shader
 5246           * outputs. (the varying flag is not set by the parser)
 5247           */
 5248          if (this->type->qualifier.flags.q.out &&
 5249              (!state->EXT_gpu_shader4_enable ||
 5250               state->stage != MESA_SHADER_FRAGMENT)) {
 5251             _mesa_glsl_error(& loc, state,
 5252                              "`out' qualifier in declaration of `%s' "
 5253                              "only valid for function parameters in %s",
 5254                              decl->identifier, state->get_version_string());
 5255          }
 5256          if (this->type->qualifier.flags.q.in) {
 5257             _mesa_glsl_error(& loc, state,
 5258                              "`in' qualifier in declaration of `%s' "
 5259                              "only valid for function parameters in %s",
 5260                              decl->identifier, state->get_version_string());
 5261          }
 5262          /* FINISHME: Test for other invalid qualifiers. */
 5263       }
 5264 
 5265       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
 5266                                        & loc, false);
 5267       apply_layout_qualifier_to_variable(&this->type->qualifier, var, state,
 5268                                          &loc);
 5269 
 5270       if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_temporary
 5271            || var->data.mode == ir_var_shader_out)
 5272           && (var->type->is_numeric() || var->type->is_boolean())
 5273           && state->zero_init) {
 5274          const ir_constant_data data = { { 0 } };
 5275          var->data.has_initializer = true;
 5276          var->constant_initializer = new(var) ir_constant(var->type, &data);
 5277       }
 5278 
 5279       if (this->type->qualifier.flags.q.invariant) {
 5280          if (!is_allowed_invariant(var, state)) {
 5281             _mesa_glsl_error(&loc, state,
 5282                              "`%s' cannot be marked invariant; interfaces between "
 5283                              "shader stages only", var->name);
 5284          }