Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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 "glsl_types.h"
  56. #include "program/hash_table.h"
  57. #include "ir.h"
  58. #include "ir_builder.h"
  59.  
  60. using namespace ir_builder;
  61.  
  62. static void
  63. detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
  64.                                exec_list *instructions);
  65. static void
  66. remove_per_vertex_blocks(exec_list *instructions,
  67.                          _mesa_glsl_parse_state *state, ir_variable_mode mode);
  68.  
  69.  
  70. void
  71. _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
  72. {
  73.    _mesa_glsl_initialize_variables(instructions, state);
  74.  
  75.    state->symbols->separate_function_namespace = state->language_version == 110;
  76.  
  77.    state->current_function = NULL;
  78.  
  79.    state->toplevel_ir = instructions;
  80.  
  81.    state->gs_input_prim_type_specified = false;
  82.    state->cs_input_local_size_specified = false;
  83.  
  84.    /* Section 4.2 of the GLSL 1.20 specification states:
  85.     * "The built-in functions are scoped in a scope outside the global scope
  86.     *  users declare global variables in.  That is, a shader's global scope,
  87.     *  available for user-defined functions and global variables, is nested
  88.     *  inside the scope containing the built-in functions."
  89.     *
  90.     * Since built-in functions like ftransform() access built-in variables,
  91.     * it follows that those must be in the outer scope as well.
  92.     *
  93.     * We push scope here to create this nesting effect...but don't pop.
  94.     * This way, a shader's globals are still in the symbol table for use
  95.     * by the linker.
  96.     */
  97.    state->symbols->push_scope();
  98.  
  99.    foreach_list_typed (ast_node, ast, link, & state->translation_unit)
  100.       ast->hir(instructions, state);
  101.  
  102.    detect_recursion_unlinked(state, instructions);
  103.    detect_conflicting_assignments(state, instructions);
  104.  
  105.    state->toplevel_ir = NULL;
  106.  
  107.    /* Move all of the variable declarations to the front of the IR list, and
  108.     * reverse the order.  This has the (intended!) side effect that vertex
  109.     * shader inputs and fragment shader outputs will appear in the IR in the
  110.     * same order that they appeared in the shader code.  This results in the
  111.     * locations being assigned in the declared order.  Many (arguably buggy)
  112.     * applications depend on this behavior, and it matches what nearly all
  113.     * other drivers do.
  114.     */
  115.    foreach_in_list_safe(ir_instruction, node, instructions) {
  116.       ir_variable *const var = node->as_variable();
  117.  
  118.       if (var == NULL)
  119.          continue;
  120.  
  121.       var->remove();
  122.       instructions->push_head(var);
  123.    }
  124.  
  125.    /* Figure out if gl_FragCoord is actually used in fragment shader */
  126.    ir_variable *const var = state->symbols->get_variable("gl_FragCoord");
  127.    if (var != NULL)
  128.       state->fs_uses_gl_fragcoord = var->data.used;
  129.  
  130.    /* From section 7.1 (Built-In Language Variables) of the GLSL 4.10 spec:
  131.     *
  132.     *     If multiple shaders using members of a built-in block belonging to
  133.     *     the same interface are linked together in the same program, they
  134.     *     must all redeclare the built-in block in the same way, as described
  135.     *     in section 4.3.7 "Interface Blocks" for interface block matching, or
  136.     *     a link error will result.
  137.     *
  138.     * The phrase "using members of a built-in block" implies that if two
  139.     * shaders are linked together and one of them *does not use* any members
  140.     * of the built-in block, then that shader does not need to have a matching
  141.     * redeclaration of the built-in block.
  142.     *
  143.     * This appears to be a clarification to the behaviour established for
  144.     * gl_PerVertex by GLSL 1.50, therefore implement it regardless of GLSL
  145.     * version.
  146.     *
  147.     * The definition of "interface" in section 4.3.7 that applies here is as
  148.     * follows:
  149.     *
  150.     *     The boundary between adjacent programmable pipeline stages: This
  151.     *     spans all the outputs in all compilation units of the first stage
  152.     *     and all the inputs in all compilation units of the second stage.
  153.     *
  154.     * Therefore this rule applies to both inter- and intra-stage linking.
  155.     *
  156.     * The easiest way to implement this is to check whether the shader uses
  157.     * gl_PerVertex right after ast-to-ir conversion, and if it doesn't, simply
  158.     * remove all the relevant variable declaration from the IR, so that the
  159.     * linker won't see them and complain about mismatches.
  160.     */
  161.    remove_per_vertex_blocks(instructions, state, ir_var_shader_in);
  162.    remove_per_vertex_blocks(instructions, state, ir_var_shader_out);
  163. }
  164.  
  165.  
  166. static ir_expression_operation
  167. get_conversion_operation(const glsl_type *to, const glsl_type *from,
  168.                          struct _mesa_glsl_parse_state *state)
  169. {
  170.    switch (to->base_type) {
  171.    case GLSL_TYPE_FLOAT:
  172.       switch (from->base_type) {
  173.       case GLSL_TYPE_INT: return ir_unop_i2f;
  174.       case GLSL_TYPE_UINT: return ir_unop_u2f;
  175.       case GLSL_TYPE_DOUBLE: return ir_unop_d2f;
  176.       default: return (ir_expression_operation)0;
  177.       }
  178.  
  179.    case GLSL_TYPE_UINT:
  180.       if (!state->is_version(400, 0) && !state->ARB_gpu_shader5_enable)
  181.          return (ir_expression_operation)0;
  182.       switch (from->base_type) {
  183.          case GLSL_TYPE_INT: return ir_unop_i2u;
  184.          default: return (ir_expression_operation)0;
  185.       }
  186.  
  187.    case GLSL_TYPE_DOUBLE:
  188.       if (!state->has_double())
  189.          return (ir_expression_operation)0;
  190.       switch (from->base_type) {
  191.       case GLSL_TYPE_INT: return ir_unop_i2d;
  192.       case GLSL_TYPE_UINT: return ir_unop_u2d;
  193.       case GLSL_TYPE_FLOAT: return ir_unop_f2d;
  194.       default: return (ir_expression_operation)0;
  195.       }
  196.  
  197.    default: return (ir_expression_operation)0;
  198.    }
  199. }
  200.  
  201.  
  202. /**
  203.  * If a conversion is available, convert one operand to a different type
  204.  *
  205.  * The \c from \c ir_rvalue is converted "in place".
  206.  *
  207.  * \param to     Type that the operand it to be converted to
  208.  * \param from   Operand that is being converted
  209.  * \param state  GLSL compiler state
  210.  *
  211.  * \return
  212.  * If a conversion is possible (or unnecessary), \c true is returned.
  213.  * Otherwise \c false is returned.
  214.  */
  215. bool
  216. apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
  217.                           struct _mesa_glsl_parse_state *state)
  218. {
  219.    void *ctx = state;
  220.    if (to->base_type == from->type->base_type)
  221.       return true;
  222.  
  223.    /* Prior to GLSL 1.20, there are no implicit conversions */
  224.    if (!state->is_version(120, 0))
  225.       return false;
  226.  
  227.    /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
  228.     *
  229.     *    "There are no implicit array or structure conversions. For
  230.     *    example, an array of int cannot be implicitly converted to an
  231.     *    array of float.
  232.     */
  233.    if (!to->is_numeric() || !from->type->is_numeric())
  234.       return false;
  235.  
  236.    /* We don't actually want the specific type `to`, we want a type
  237.     * with the same base type as `to`, but the same vector width as
  238.     * `from`.
  239.     */
  240.    to = glsl_type::get_instance(to->base_type, from->type->vector_elements,
  241.                                 from->type->matrix_columns);
  242.  
  243.    ir_expression_operation op = get_conversion_operation(to, from->type, state);
  244.    if (op) {
  245.       from = new(ctx) ir_expression(op, to, from, NULL);
  246.       return true;
  247.    } else {
  248.       return false;
  249.    }
  250. }
  251.  
  252.  
  253. static const struct glsl_type *
  254. arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  255.                        bool multiply,
  256.                        struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  257. {
  258.    const glsl_type *type_a = value_a->type;
  259.    const glsl_type *type_b = value_b->type;
  260.  
  261.    /* From GLSL 1.50 spec, page 56:
  262.     *
  263.     *    "The arithmetic binary operators add (+), subtract (-),
  264.     *    multiply (*), and divide (/) operate on integer and
  265.     *    floating-point scalars, vectors, and matrices."
  266.     */
  267.    if (!type_a->is_numeric() || !type_b->is_numeric()) {
  268.       _mesa_glsl_error(loc, state,
  269.                        "operands to arithmetic operators must be numeric");
  270.       return glsl_type::error_type;
  271.    }
  272.  
  273.  
  274.    /*    "If one operand is floating-point based and the other is
  275.     *    not, then the conversions from Section 4.1.10 "Implicit
  276.     *    Conversions" are applied to the non-floating-point-based operand."
  277.     */
  278.    if (!apply_implicit_conversion(type_a, value_b, state)
  279.        && !apply_implicit_conversion(type_b, value_a, state)) {
  280.       _mesa_glsl_error(loc, state,
  281.                        "could not implicitly convert operands to "
  282.                        "arithmetic operator");
  283.       return glsl_type::error_type;
  284.    }
  285.    type_a = value_a->type;
  286.    type_b = value_b->type;
  287.  
  288.    /*    "If the operands are integer types, they must both be signed or
  289.     *    both be unsigned."
  290.     *
  291.     * From this rule and the preceeding conversion it can be inferred that
  292.     * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
  293.     * The is_numeric check above already filtered out the case where either
  294.     * type is not one of these, so now the base types need only be tested for
  295.     * equality.
  296.     */
  297.    if (type_a->base_type != type_b->base_type) {
  298.       _mesa_glsl_error(loc, state,
  299.                        "base type mismatch for arithmetic operator");
  300.       return glsl_type::error_type;
  301.    }
  302.  
  303.    /*    "All arithmetic binary operators result in the same fundamental type
  304.     *    (signed integer, unsigned integer, or floating-point) as the
  305.     *    operands they operate on, after operand type conversion. After
  306.     *    conversion, the following cases are valid
  307.     *
  308.     *    * The two operands are scalars. In this case the operation is
  309.     *      applied, resulting in a scalar."
  310.     */
  311.    if (type_a->is_scalar() && type_b->is_scalar())
  312.       return type_a;
  313.  
  314.    /*   "* One operand is a scalar, and the other is a vector or matrix.
  315.     *      In this case, the scalar operation is applied independently to each
  316.     *      component of the vector or matrix, resulting in the same size
  317.     *      vector or matrix."
  318.     */
  319.    if (type_a->is_scalar()) {
  320.       if (!type_b->is_scalar())
  321.          return type_b;
  322.    } else if (type_b->is_scalar()) {
  323.       return type_a;
  324.    }
  325.  
  326.    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  327.     * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
  328.     * handled.
  329.     */
  330.    assert(!type_a->is_scalar());
  331.    assert(!type_b->is_scalar());
  332.  
  333.    /*   "* The two operands are vectors of the same size. In this case, the
  334.     *      operation is done component-wise resulting in the same size
  335.     *      vector."
  336.     */
  337.    if (type_a->is_vector() && type_b->is_vector()) {
  338.       if (type_a == type_b) {
  339.          return type_a;
  340.       } else {
  341.          _mesa_glsl_error(loc, state,
  342.                           "vector size mismatch for arithmetic operator");
  343.          return glsl_type::error_type;
  344.       }
  345.    }
  346.  
  347.    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  348.     * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
  349.     * <vector, vector> have been handled.  At least one of the operands must
  350.     * be matrix.  Further, since there are no integer matrix types, the base
  351.     * type of both operands must be float.
  352.     */
  353.    assert(type_a->is_matrix() || type_b->is_matrix());
  354.    assert(type_a->base_type == GLSL_TYPE_FLOAT ||
  355.           type_a->base_type == GLSL_TYPE_DOUBLE);
  356.    assert(type_b->base_type == GLSL_TYPE_FLOAT ||
  357.           type_b->base_type == GLSL_TYPE_DOUBLE);
  358.  
  359.    /*   "* The operator is add (+), subtract (-), or divide (/), and the
  360.     *      operands are matrices with the same number of rows and the same
  361.     *      number of columns. In this case, the operation is done component-
  362.     *      wise resulting in the same size matrix."
  363.     *    * The operator is multiply (*), where both operands are matrices or
  364.     *      one operand is a vector and the other a matrix. A right vector
  365.     *      operand is treated as a column vector and a left vector operand as a
  366.     *      row vector. In all these cases, it is required that the number of
  367.     *      columns of the left operand is equal to the number of rows of the
  368.     *      right operand. Then, the multiply (*) operation does a linear
  369.     *      algebraic multiply, yielding an object that has the same number of
  370.     *      rows as the left operand and the same number of columns as the right
  371.     *      operand. Section 5.10 "Vector and Matrix Operations" explains in
  372.     *      more detail how vectors and matrices are operated on."
  373.     */
  374.    if (! multiply) {
  375.       if (type_a == type_b)
  376.          return type_a;
  377.    } else {
  378.       const glsl_type *type = glsl_type::get_mul_type(type_a, type_b);
  379.  
  380.       if (type == glsl_type::error_type) {
  381.          _mesa_glsl_error(loc, state,
  382.                           "size mismatch for matrix multiplication");
  383.       }
  384.  
  385.       return type;
  386.    }
  387.  
  388.  
  389.    /*    "All other cases are illegal."
  390.     */
  391.    _mesa_glsl_error(loc, state, "type mismatch");
  392.    return glsl_type::error_type;
  393. }
  394.  
  395.  
  396. static const struct glsl_type *
  397. unary_arithmetic_result_type(const struct glsl_type *type,
  398.                              struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  399. {
  400.    /* From GLSL 1.50 spec, page 57:
  401.     *
  402.     *    "The arithmetic unary operators negate (-), post- and pre-increment
  403.     *     and decrement (-- and ++) operate on integer or floating-point
  404.     *     values (including vectors and matrices). All unary operators work
  405.     *     component-wise on their operands. These result with the same type
  406.     *     they operated on."
  407.     */
  408.    if (!type->is_numeric()) {
  409.       _mesa_glsl_error(loc, state,
  410.                        "operands to arithmetic operators must be numeric");
  411.       return glsl_type::error_type;
  412.    }
  413.  
  414.    return type;
  415. }
  416.  
  417. /**
  418.  * \brief Return the result type of a bit-logic operation.
  419.  *
  420.  * If the given types to the bit-logic operator are invalid, return
  421.  * glsl_type::error_type.
  422.  *
  423.  * \param type_a Type of LHS of bit-logic op
  424.  * \param type_b Type of RHS of bit-logic op
  425.  */
  426. static const struct glsl_type *
  427. bit_logic_result_type(const struct glsl_type *type_a,
  428.                       const struct glsl_type *type_b,
  429.                       ast_operators op,
  430.                       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  431. {
  432.     if (!state->check_bitwise_operations_allowed(loc)) {
  433.        return glsl_type::error_type;
  434.     }
  435.  
  436.     /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:
  437.      *
  438.      *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or
  439.      *     (|). The operands must be of type signed or unsigned integers or
  440.      *     integer vectors."
  441.      */
  442.     if (!type_a->is_integer()) {
  443.        _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",
  444.                          ast_expression::operator_string(op));
  445.        return glsl_type::error_type;
  446.     }
  447.     if (!type_b->is_integer()) {
  448.        _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",
  449.                         ast_expression::operator_string(op));
  450.        return glsl_type::error_type;
  451.     }
  452.  
  453.     /*     "The fundamental types of the operands (signed or unsigned) must
  454.      *     match,"
  455.      */
  456.     if (type_a->base_type != type_b->base_type) {
  457.        _mesa_glsl_error(loc, state, "operands of `%s' must have the same "
  458.                         "base type", ast_expression::operator_string(op));
  459.        return glsl_type::error_type;
  460.     }
  461.  
  462.     /*     "The operands cannot be vectors of differing size." */
  463.     if (type_a->is_vector() &&
  464.         type_b->is_vector() &&
  465.         type_a->vector_elements != type_b->vector_elements) {
  466.        _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "
  467.                         "different sizes", ast_expression::operator_string(op));
  468.        return glsl_type::error_type;
  469.     }
  470.  
  471.     /*     "If one operand is a scalar and the other a vector, the scalar is
  472.      *     applied component-wise to the vector, resulting in the same type as
  473.      *     the vector. The fundamental types of the operands [...] will be the
  474.      *     resulting fundamental type."
  475.      */
  476.     if (type_a->is_scalar())
  477.         return type_b;
  478.     else
  479.         return type_a;
  480. }
  481.  
  482. static const struct glsl_type *
  483. modulus_result_type(const struct glsl_type *type_a,
  484.                     const struct glsl_type *type_b,
  485.                     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  486. {
  487.    if (!state->check_version(130, 300, loc, "operator '%%' is reserved")) {
  488.       return glsl_type::error_type;
  489.    }
  490.  
  491.    /* From GLSL 1.50 spec, page 56:
  492.     *    "The operator modulus (%) operates on signed or unsigned integers or
  493.     *    integer vectors. The operand types must both be signed or both be
  494.     *    unsigned."
  495.     */
  496.    if (!type_a->is_integer()) {
  497.       _mesa_glsl_error(loc, state, "LHS of operator %% must be an integer");
  498.       return glsl_type::error_type;
  499.    }
  500.    if (!type_b->is_integer()) {
  501.       _mesa_glsl_error(loc, state, "RHS of operator %% must be an integer");
  502.       return glsl_type::error_type;
  503.    }
  504.    if (type_a->base_type != type_b->base_type) {
  505.       _mesa_glsl_error(loc, state,
  506.                        "operands of %% must have the same base type");
  507.       return glsl_type::error_type;
  508.    }
  509.  
  510.    /*    "The operands cannot be vectors of differing size. If one operand is
  511.     *    a scalar and the other vector, then the scalar is applied component-
  512.     *    wise to the vector, resulting in the same type as the vector. If both
  513.     *    are vectors of the same size, the result is computed component-wise."
  514.     */
  515.    if (type_a->is_vector()) {
  516.       if (!type_b->is_vector()
  517.           || (type_a->vector_elements == type_b->vector_elements))
  518.       return type_a;
  519.    } else
  520.       return type_b;
  521.  
  522.    /*    "The operator modulus (%) is not defined for any other data types
  523.     *    (non-integer types)."
  524.     */
  525.    _mesa_glsl_error(loc, state, "type mismatch");
  526.    return glsl_type::error_type;
  527. }
  528.  
  529.  
  530. static const struct glsl_type *
  531. relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
  532.                        struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  533. {
  534.    const glsl_type *type_a = value_a->type;
  535.    const glsl_type *type_b = value_b->type;
  536.  
  537.    /* From GLSL 1.50 spec, page 56:
  538.     *    "The relational operators greater than (>), less than (<), greater
  539.     *    than or equal (>=), and less than or equal (<=) operate only on
  540.     *    scalar integer and scalar floating-point expressions."
  541.     */
  542.    if (!type_a->is_numeric()
  543.        || !type_b->is_numeric()
  544.        || !type_a->is_scalar()
  545.        || !type_b->is_scalar()) {
  546.       _mesa_glsl_error(loc, state,
  547.                        "operands to relational operators must be scalar and "
  548.                        "numeric");
  549.       return glsl_type::error_type;
  550.    }
  551.  
  552.    /*    "Either the operands' types must match, or the conversions from
  553.     *    Section 4.1.10 "Implicit Conversions" will be applied to the integer
  554.     *    operand, after which the types must match."
  555.     */
  556.    if (!apply_implicit_conversion(type_a, value_b, state)
  557.        && !apply_implicit_conversion(type_b, value_a, state)) {
  558.       _mesa_glsl_error(loc, state,
  559.                        "could not implicitly convert operands to "
  560.                        "relational operator");
  561.       return glsl_type::error_type;
  562.    }
  563.    type_a = value_a->type;
  564.    type_b = value_b->type;
  565.  
  566.    if (type_a->base_type != type_b->base_type) {
  567.       _mesa_glsl_error(loc, state, "base type mismatch");
  568.       return glsl_type::error_type;
  569.    }
  570.  
  571.    /*    "The result is scalar Boolean."
  572.     */
  573.    return glsl_type::bool_type;
  574. }
  575.  
  576. /**
  577.  * \brief Return the result type of a bit-shift operation.
  578.  *
  579.  * If the given types to the bit-shift operator are invalid, return
  580.  * glsl_type::error_type.
  581.  *
  582.  * \param type_a Type of LHS of bit-shift op
  583.  * \param type_b Type of RHS of bit-shift op
  584.  */
  585. static const struct glsl_type *
  586. shift_result_type(const struct glsl_type *type_a,
  587.                   const struct glsl_type *type_b,
  588.                   ast_operators op,
  589.                   struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
  590. {
  591.    if (!state->check_bitwise_operations_allowed(loc)) {
  592.       return glsl_type::error_type;
  593.    }
  594.  
  595.    /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:
  596.     *
  597.     *     "The shift operators (<<) and (>>). For both operators, the operands
  598.     *     must be signed or unsigned integers or integer vectors. One operand
  599.     *     can be signed while the other is unsigned."
  600.     */
  601.    if (!type_a->is_integer()) {
  602.       _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
  603.                        "integer vector", ast_expression::operator_string(op));
  604.      return glsl_type::error_type;
  605.  
  606.    }
  607.    if (!type_b->is_integer()) {
  608.       _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
  609.                        "integer vector", ast_expression::operator_string(op));
  610.      return glsl_type::error_type;
  611.    }
  612.  
  613.    /*     "If the first operand is a scalar, the second operand has to be
  614.     *     a scalar as well."
  615.     */
  616.    if (type_a->is_scalar() && !type_b->is_scalar()) {
  617.       _mesa_glsl_error(loc, state, "if the first operand of %s is scalar, the "
  618.                        "second must be scalar as well",
  619.                        ast_expression::operator_string(op));
  620.      return glsl_type::error_type;
  621.    }
  622.  
  623.    /* If both operands are vectors, check that they have same number of
  624.     * elements.
  625.     */
  626.    if (type_a->is_vector() &&
  627.       type_b->is_vector() &&
  628.       type_a->vector_elements != type_b->vector_elements) {
  629.       _mesa_glsl_error(loc, state, "vector operands to operator %s must "
  630.                        "have same number of elements",
  631.                        ast_expression::operator_string(op));
  632.      return glsl_type::error_type;
  633.    }
  634.  
  635.    /*     "In all cases, the resulting type will be the same type as the left
  636.     *     operand."
  637.     */
  638.    return type_a;
  639. }
  640.  
  641. /**
  642.  * Validates that a value can be assigned to a location with a specified type
  643.  *
  644.  * Validates that \c rhs can be assigned to some location.  If the types are
  645.  * not an exact match but an automatic conversion is possible, \c rhs will be
  646.  * converted.
  647.  *
  648.  * \return
  649.  * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
  650.  * Otherwise the actual RHS to be assigned will be returned.  This may be
  651.  * \c rhs, or it may be \c rhs after some type conversion.
  652.  *
  653.  * \note
  654.  * In addition to being used for assignments, this function is used to
  655.  * type-check return values.
  656.  */
  657. ir_rvalue *
  658. validate_assignment(struct _mesa_glsl_parse_state *state,
  659.                     YYLTYPE loc, const glsl_type *lhs_type,
  660.                     ir_rvalue *rhs, bool is_initializer)
  661. {
  662.    /* If there is already some error in the RHS, just return it.  Anything
  663.     * else will lead to an avalanche of error message back to the user.
  664.     */
  665.    if (rhs->type->is_error())
  666.       return rhs;
  667.  
  668.    /* If the types are identical, the assignment can trivially proceed.
  669.     */
  670.    if (rhs->type == lhs_type)
  671.       return rhs;
  672.  
  673.    /* If the array element types are the same and the LHS is unsized,
  674.     * the assignment is okay for initializers embedded in variable
  675.     * declarations.
  676.     *
  677.     * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
  678.     * is handled by ir_dereference::is_lvalue.
  679.     */
  680.    if (lhs_type->is_unsized_array() && rhs->type->is_array()
  681.        && (lhs_type->element_type() == rhs->type->element_type())) {
  682.       if (is_initializer) {
  683.          return rhs;
  684.       } else {
  685.          _mesa_glsl_error(&loc, state,
  686.                           "implicitly sized arrays cannot be assigned");
  687.          return NULL;
  688.       }
  689.    }
  690.  
  691.    /* Check for implicit conversion in GLSL 1.20 */
  692.    if (apply_implicit_conversion(lhs_type, rhs, state)) {
  693.       if (rhs->type == lhs_type)
  694.          return rhs;
  695.    }
  696.  
  697.    _mesa_glsl_error(&loc, state,
  698.                     "%s of type %s cannot be assigned to "
  699.                     "variable of type %s",
  700.                     is_initializer ? "initializer" : "value",
  701.                     rhs->type->name, lhs_type->name);
  702.  
  703.    return NULL;
  704. }
  705.  
  706. static void
  707. mark_whole_array_access(ir_rvalue *access)
  708. {
  709.    ir_dereference_variable *deref = access->as_dereference_variable();
  710.  
  711.    if (deref && deref->var) {
  712.       deref->var->data.max_array_access = deref->type->length - 1;
  713.    }
  714. }
  715.  
  716. static bool
  717. do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
  718.               const char *non_lvalue_description,
  719.               ir_rvalue *lhs, ir_rvalue *rhs,
  720.               ir_rvalue **out_rvalue, bool needs_rvalue,
  721.               bool is_initializer,
  722.               YYLTYPE lhs_loc)
  723. {
  724.    void *ctx = state;
  725.    bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());
  726.    ir_rvalue *extract_channel = NULL;
  727.  
  728.    /* If the assignment LHS comes back as an ir_binop_vector_extract
  729.     * expression, move it to the RHS as an ir_triop_vector_insert.
  730.     */
  731.    if (lhs->ir_type == ir_type_expression) {
  732.       ir_expression *const lhs_expr = lhs->as_expression();
  733.  
  734.       if (unlikely(lhs_expr->operation == ir_binop_vector_extract)) {
  735.          ir_rvalue *new_rhs =
  736.             validate_assignment(state, lhs_loc, lhs->type,
  737.                                 rhs, is_initializer);
  738.  
  739.          if (new_rhs == NULL) {
  740.             return lhs;
  741.          } else {
  742.             /* This converts:
  743.              * - LHS: (expression float vector_extract <vec> <channel>)
  744.              * - RHS: <scalar>
  745.              * into:
  746.              * - LHS: <vec>
  747.              * - RHS: (expression vec2 vector_insert <vec> <channel> <scalar>)
  748.              *
  749.              * The LHS type is now a vector instead of a scalar.  Since GLSL
  750.              * allows assignments to be used as rvalues, we need to re-extract
  751.              * the channel from assignment_temp when returning the rvalue.
  752.              */
  753.             extract_channel = lhs_expr->operands[1];
  754.             rhs = new(ctx) ir_expression(ir_triop_vector_insert,
  755.                                          lhs_expr->operands[0]->type,
  756.                                          lhs_expr->operands[0],
  757.                                          new_rhs,
  758.                                          extract_channel);
  759.             lhs = lhs_expr->operands[0]->clone(ctx, NULL);
  760.          }
  761.       }
  762.    }
  763.  
  764.    ir_variable *lhs_var = lhs->variable_referenced();
  765.    if (lhs_var)
  766.       lhs_var->data.assigned = true;
  767.  
  768.    if (!error_emitted) {
  769.       if (non_lvalue_description != NULL) {
  770.          _mesa_glsl_error(&lhs_loc, state,
  771.                           "assignment to %s",
  772.                           non_lvalue_description);
  773.          error_emitted = true;
  774.       } else if (lhs_var != NULL && lhs_var->data.read_only) {
  775.          _mesa_glsl_error(&lhs_loc, state,
  776.                           "assignment to read-only variable '%s'",
  777.                           lhs_var->name);
  778.          error_emitted = true;
  779.       } else if (lhs->type->is_array() &&
  780.                  !state->check_version(120, 300, &lhs_loc,
  781.                                        "whole array assignment forbidden")) {
  782.          /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
  783.           *
  784.           *    "Other binary or unary expressions, non-dereferenced
  785.           *     arrays, function names, swizzles with repeated fields,
  786.           *     and constants cannot be l-values."
  787.           *
  788.           * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
  789.           */
  790.          error_emitted = true;
  791.       } else if (!lhs->is_lvalue()) {
  792.          _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
  793.          error_emitted = true;
  794.       }
  795.    }
  796.  
  797.    ir_rvalue *new_rhs =
  798.       validate_assignment(state, lhs_loc, lhs->type, rhs, is_initializer);
  799.    if (new_rhs != NULL) {
  800.       rhs = new_rhs;
  801.  
  802.       /* If the LHS array was not declared with a size, it takes it size from
  803.        * the RHS.  If the LHS is an l-value and a whole array, it must be a
  804.        * dereference of a variable.  Any other case would require that the LHS
  805.        * is either not an l-value or not a whole array.
  806.        */
  807.       if (lhs->type->is_unsized_array()) {
  808.          ir_dereference *const d = lhs->as_dereference();
  809.  
  810.          assert(d != NULL);
  811.  
  812.          ir_variable *const var = d->variable_referenced();
  813.  
  814.          assert(var != NULL);
  815.  
  816.          if (var->data.max_array_access >= unsigned(rhs->type->array_size())) {
  817.             /* FINISHME: This should actually log the location of the RHS. */
  818.             _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
  819.                              "previous access",
  820.                              var->data.max_array_access);
  821.          }
  822.  
  823.          var->type = glsl_type::get_array_instance(lhs->type->element_type(),
  824.                                                    rhs->type->array_size());
  825.          d->type = var->type;
  826.       }
  827.       if (lhs->type->is_array()) {
  828.          mark_whole_array_access(rhs);
  829.          mark_whole_array_access(lhs);
  830.       }
  831.    }
  832.  
  833.    /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,
  834.     * but not post_inc) need the converted assigned value as an rvalue
  835.     * to handle things like:
  836.     *
  837.     * i = j += 1;
  838.     */
  839.    if (needs_rvalue) {
  840.       ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
  841.                                               ir_var_temporary);
  842.       instructions->push_tail(var);
  843.       instructions->push_tail(assign(var, rhs));
  844.  
  845.       if (!error_emitted) {
  846.          ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var);
  847.          instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var));
  848.       }
  849.       ir_rvalue *rvalue = new(ctx) ir_dereference_variable(var);
  850.  
  851.       if (extract_channel) {
  852.          rvalue = new(ctx) ir_expression(ir_binop_vector_extract,
  853.                                          rvalue,
  854.                                          extract_channel->clone(ctx, NULL));
  855.       }
  856.  
  857.       *out_rvalue = rvalue;
  858.    } else {
  859.       if (!error_emitted)
  860.          instructions->push_tail(new(ctx) ir_assignment(lhs, rhs));
  861.       *out_rvalue = NULL;
  862.    }
  863.  
  864.    return error_emitted;
  865. }
  866.  
  867. static ir_rvalue *
  868. get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
  869. {
  870.    void *ctx = ralloc_parent(lvalue);
  871.    ir_variable *var;
  872.  
  873.    var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
  874.                               ir_var_temporary);
  875.    instructions->push_tail(var);
  876.  
  877.    instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
  878.                                                   lvalue));
  879.  
  880.    return new(ctx) ir_dereference_variable(var);
  881. }
  882.  
  883.  
  884. ir_rvalue *
  885. ast_node::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
  886. {
  887.    (void) instructions;
  888.    (void) state;
  889.  
  890.    return NULL;
  891. }
  892.  
  893. void
  894. ast_function_expression::hir_no_rvalue(exec_list *instructions,
  895.                                        struct _mesa_glsl_parse_state *state)
  896. {
  897.    (void)hir(instructions, state);
  898. }
  899.  
  900. void
  901. ast_aggregate_initializer::hir_no_rvalue(exec_list *instructions,
  902.                                          struct _mesa_glsl_parse_state *state)
  903. {
  904.    (void)hir(instructions, state);
  905. }
  906.  
  907. static ir_rvalue *
  908. do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
  909. {
  910.    int join_op;
  911.    ir_rvalue *cmp = NULL;
  912.  
  913.    if (operation == ir_binop_all_equal)
  914.       join_op = ir_binop_logic_and;
  915.    else
  916.       join_op = ir_binop_logic_or;
  917.  
  918.    switch (op0->type->base_type) {
  919.    case GLSL_TYPE_FLOAT:
  920.    case GLSL_TYPE_UINT:
  921.    case GLSL_TYPE_INT:
  922.    case GLSL_TYPE_BOOL:
  923.    case GLSL_TYPE_DOUBLE:
  924.       return new(mem_ctx) ir_expression(operation, op0, op1);
  925.  
  926.    case GLSL_TYPE_ARRAY: {
  927.       for (unsigned int i = 0; i < op0->type->length; i++) {
  928.          ir_rvalue *e0, *e1, *result;
  929.  
  930.          e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
  931.                                                 new(mem_ctx) ir_constant(i));
  932.          e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
  933.                                                 new(mem_ctx) ir_constant(i));
  934.          result = do_comparison(mem_ctx, operation, e0, e1);
  935.  
  936.          if (cmp) {
  937.             cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
  938.          } else {
  939.             cmp = result;
  940.          }
  941.       }
  942.  
  943.       mark_whole_array_access(op0);
  944.       mark_whole_array_access(op1);
  945.       break;
  946.    }
  947.  
  948.    case GLSL_TYPE_STRUCT: {
  949.       for (unsigned int i = 0; i < op0->type->length; i++) {
  950.          ir_rvalue *e0, *e1, *result;
  951.          const char *field_name = op0->type->fields.structure[i].name;
  952.  
  953.          e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
  954.                                                  field_name);
  955.          e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
  956.                                                  field_name);
  957.          result = do_comparison(mem_ctx, operation, e0, e1);
  958.  
  959.          if (cmp) {
  960.             cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
  961.          } else {
  962.             cmp = result;
  963.          }
  964.       }
  965.       break;
  966.    }
  967.  
  968.    case GLSL_TYPE_ERROR:
  969.    case GLSL_TYPE_VOID:
  970.    case GLSL_TYPE_SAMPLER:
  971.    case GLSL_TYPE_IMAGE:
  972.    case GLSL_TYPE_INTERFACE:
  973.    case GLSL_TYPE_ATOMIC_UINT:
  974.       /* I assume a comparison of a struct containing a sampler just
  975.        * ignores the sampler present in the type.
  976.        */
  977.       break;
  978.    }
  979.  
  980.    if (cmp == NULL)
  981.       cmp = new(mem_ctx) ir_constant(true);
  982.  
  983.    return cmp;
  984. }
  985.  
  986. /* For logical operations, we want to ensure that the operands are
  987.  * scalar booleans.  If it isn't, emit an error and return a constant
  988.  * boolean to avoid triggering cascading error messages.
  989.  */
  990. ir_rvalue *
  991. get_scalar_boolean_operand(exec_list *instructions,
  992.                            struct _mesa_glsl_parse_state *state,
  993.                            ast_expression *parent_expr,
  994.                            int operand,
  995.                            const char *operand_name,
  996.                            bool *error_emitted)
  997. {
  998.    ast_expression *expr = parent_expr->subexpressions[operand];
  999.    void *ctx = state;
  1000.    ir_rvalue *val = expr->hir(instructions, state);
  1001.  
  1002.    if (val->type->is_boolean() && val->type->is_scalar())
  1003.       return val;
  1004.  
  1005.    if (!*error_emitted) {
  1006.       YYLTYPE loc = expr->get_location();
  1007.       _mesa_glsl_error(&loc, state, "%s of `%s' must be scalar boolean",
  1008.                        operand_name,
  1009.                        parent_expr->operator_string(parent_expr->oper));
  1010.       *error_emitted = true;
  1011.    }
  1012.  
  1013.    return new(ctx) ir_constant(true);
  1014. }
  1015.  
  1016. /**
  1017.  * If name refers to a builtin array whose maximum allowed size is less than
  1018.  * size, report an error and return true.  Otherwise return false.
  1019.  */
  1020. void
  1021. check_builtin_array_max_size(const char *name, unsigned size,
  1022.                              YYLTYPE loc, struct _mesa_glsl_parse_state *state)
  1023. {
  1024.    if ((strcmp("gl_TexCoord", name) == 0)
  1025.        && (size > state->Const.MaxTextureCoords)) {
  1026.       /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
  1027.        *
  1028.        *     "The size [of gl_TexCoord] can be at most
  1029.        *     gl_MaxTextureCoords."
  1030.        */
  1031.       _mesa_glsl_error(&loc, state, "`gl_TexCoord' array size cannot "
  1032.                        "be larger than gl_MaxTextureCoords (%u)",
  1033.                        state->Const.MaxTextureCoords);
  1034.    } else if (strcmp("gl_ClipDistance", name) == 0
  1035.               && size > state->Const.MaxClipPlanes) {
  1036.       /* From section 7.1 (Vertex Shader Special Variables) of the
  1037.        * GLSL 1.30 spec:
  1038.        *
  1039.        *   "The gl_ClipDistance array is predeclared as unsized and
  1040.        *   must be sized by the shader either redeclaring it with a
  1041.        *   size or indexing it only with integral constant
  1042.        *   expressions. ... The size can be at most
  1043.        *   gl_MaxClipDistances."
  1044.        */
  1045.       _mesa_glsl_error(&loc, state, "`gl_ClipDistance' array size cannot "
  1046.                        "be larger than gl_MaxClipDistances (%u)",
  1047.                        state->Const.MaxClipPlanes);
  1048.    }
  1049. }
  1050.  
  1051. /**
  1052.  * Create the constant 1, of a which is appropriate for incrementing and
  1053.  * decrementing values of the given GLSL type.  For example, if type is vec4,
  1054.  * this creates a constant value of 1.0 having type float.
  1055.  *
  1056.  * If the given type is invalid for increment and decrement operators, return
  1057.  * a floating point 1--the error will be detected later.
  1058.  */
  1059. static ir_rvalue *
  1060. constant_one_for_inc_dec(void *ctx, const glsl_type *type)
  1061. {
  1062.    switch (type->base_type) {
  1063.    case GLSL_TYPE_UINT:
  1064.       return new(ctx) ir_constant((unsigned) 1);
  1065.    case GLSL_TYPE_INT:
  1066.       return new(ctx) ir_constant(1);
  1067.    default:
  1068.    case GLSL_TYPE_FLOAT:
  1069.       return new(ctx) ir_constant(1.0f);
  1070.    }
  1071. }
  1072.  
  1073. ir_rvalue *
  1074. ast_expression::hir(exec_list *instructions,
  1075.                     struct _mesa_glsl_parse_state *state)
  1076. {
  1077.    return do_hir(instructions, state, true);
  1078. }
  1079.  
  1080. void
  1081. ast_expression::hir_no_rvalue(exec_list *instructions,
  1082.                               struct _mesa_glsl_parse_state *state)
  1083. {
  1084.    do_hir(instructions, state, false);
  1085. }
  1086.  
  1087. ir_rvalue *
  1088. ast_expression::do_hir(exec_list *instructions,
  1089.                        struct _mesa_glsl_parse_state *state,
  1090.                        bool needs_rvalue)
  1091. {
  1092.    void *ctx = state;
  1093.    static const int operations[AST_NUM_OPERATORS] = {
  1094.       -1,               /* ast_assign doesn't convert to ir_expression. */
  1095.       -1,               /* ast_plus doesn't convert to ir_expression. */
  1096.       ir_unop_neg,
  1097.       ir_binop_add,
  1098.       ir_binop_sub,
  1099.       ir_binop_mul,
  1100.       ir_binop_div,
  1101.       ir_binop_mod,
  1102.       ir_binop_lshift,
  1103.       ir_binop_rshift,
  1104.       ir_binop_less,
  1105.       ir_binop_greater,
  1106.       ir_binop_lequal,
  1107.       ir_binop_gequal,
  1108.       ir_binop_all_equal,
  1109.       ir_binop_any_nequal,
  1110.       ir_binop_bit_and,
  1111.       ir_binop_bit_xor,
  1112.       ir_binop_bit_or,
  1113.       ir_unop_bit_not,
  1114.       ir_binop_logic_and,
  1115.       ir_binop_logic_xor,
  1116.       ir_binop_logic_or,
  1117.       ir_unop_logic_not,
  1118.  
  1119.       /* Note: The following block of expression types actually convert
  1120.        * to multiple IR instructions.
  1121.        */
  1122.       ir_binop_mul,     /* ast_mul_assign */
  1123.       ir_binop_div,     /* ast_div_assign */
  1124.       ir_binop_mod,     /* ast_mod_assign */
  1125.       ir_binop_add,     /* ast_add_assign */
  1126.       ir_binop_sub,     /* ast_sub_assign */
  1127.       ir_binop_lshift,  /* ast_ls_assign */
  1128.       ir_binop_rshift,  /* ast_rs_assign */
  1129.       ir_binop_bit_and, /* ast_and_assign */
  1130.       ir_binop_bit_xor, /* ast_xor_assign */
  1131.       ir_binop_bit_or,  /* ast_or_assign */
  1132.  
  1133.       -1,               /* ast_conditional doesn't convert to ir_expression. */
  1134.       ir_binop_add,     /* ast_pre_inc. */
  1135.       ir_binop_sub,     /* ast_pre_dec. */
  1136.       ir_binop_add,     /* ast_post_inc. */
  1137.       ir_binop_sub,     /* ast_post_dec. */
  1138.       -1,               /* ast_field_selection doesn't conv to ir_expression. */
  1139.       -1,               /* ast_array_index doesn't convert to ir_expression. */
  1140.       -1,               /* ast_function_call doesn't conv to ir_expression. */
  1141.       -1,               /* ast_identifier doesn't convert to ir_expression. */
  1142.       -1,               /* ast_int_constant doesn't convert to ir_expression. */
  1143.       -1,               /* ast_uint_constant doesn't conv to ir_expression. */
  1144.       -1,               /* ast_float_constant doesn't conv to ir_expression. */
  1145.       -1,               /* ast_bool_constant doesn't conv to ir_expression. */
  1146.       -1,               /* ast_sequence doesn't convert to ir_expression. */
  1147.    };
  1148.    ir_rvalue *result = NULL;
  1149.    ir_rvalue *op[3];
  1150.    const struct glsl_type *type; /* a temporary variable for switch cases */
  1151.    bool error_emitted = false;
  1152.    YYLTYPE loc;
  1153.  
  1154.    loc = this->get_location();
  1155.  
  1156.    switch (this->oper) {
  1157.    case ast_aggregate:
  1158.       assert(!"ast_aggregate: Should never get here.");
  1159.       break;
  1160.  
  1161.    case ast_assign: {
  1162.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1163.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1164.  
  1165.       error_emitted =
  1166.          do_assignment(instructions, state,
  1167.                        this->subexpressions[0]->non_lvalue_description,
  1168.                        op[0], op[1], &result, needs_rvalue, false,
  1169.                        this->subexpressions[0]->get_location());
  1170.       break;
  1171.    }
  1172.  
  1173.    case ast_plus:
  1174.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1175.  
  1176.       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
  1177.  
  1178.       error_emitted = type->is_error();
  1179.  
  1180.       result = op[0];
  1181.       break;
  1182.  
  1183.    case ast_neg:
  1184.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1185.  
  1186.       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
  1187.  
  1188.       error_emitted = type->is_error();
  1189.  
  1190.       result = new(ctx) ir_expression(operations[this->oper], type,
  1191.                                       op[0], NULL);
  1192.       break;
  1193.  
  1194.    case ast_add:
  1195.    case ast_sub:
  1196.    case ast_mul:
  1197.    case ast_div:
  1198.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1199.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1200.  
  1201.       type = arithmetic_result_type(op[0], op[1],
  1202.                                     (this->oper == ast_mul),
  1203.                                     state, & loc);
  1204.       error_emitted = type->is_error();
  1205.  
  1206.       result = new(ctx) ir_expression(operations[this->oper], type,
  1207.                                       op[0], op[1]);
  1208.       break;
  1209.  
  1210.    case ast_mod:
  1211.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1212.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1213.  
  1214.       type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
  1215.  
  1216.       assert(operations[this->oper] == ir_binop_mod);
  1217.  
  1218.       result = new(ctx) ir_expression(operations[this->oper], type,
  1219.                                       op[0], op[1]);
  1220.       error_emitted = type->is_error();
  1221.       break;
  1222.  
  1223.    case ast_lshift:
  1224.    case ast_rshift:
  1225.        if (!state->check_bitwise_operations_allowed(&loc)) {
  1226.           error_emitted = true;
  1227.        }
  1228.  
  1229.        op[0] = this->subexpressions[0]->hir(instructions, state);
  1230.        op[1] = this->subexpressions[1]->hir(instructions, state);
  1231.        type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
  1232.                                 &loc);
  1233.        result = new(ctx) ir_expression(operations[this->oper], type,
  1234.                                        op[0], op[1]);
  1235.        error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
  1236.        break;
  1237.  
  1238.    case ast_less:
  1239.    case ast_greater:
  1240.    case ast_lequal:
  1241.    case ast_gequal:
  1242.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1243.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1244.  
  1245.       type = relational_result_type(op[0], op[1], state, & loc);
  1246.  
  1247.       /* The relational operators must either generate an error or result
  1248.        * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.
  1249.        */
  1250.       assert(type->is_error()
  1251.              || ((type->base_type == GLSL_TYPE_BOOL)
  1252.                  && type->is_scalar()));
  1253.  
  1254.       result = new(ctx) ir_expression(operations[this->oper], type,
  1255.                                       op[0], op[1]);
  1256.       error_emitted = type->is_error();
  1257.       break;
  1258.  
  1259.    case ast_nequal:
  1260.    case ast_equal:
  1261.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1262.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1263.  
  1264.       /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
  1265.        *
  1266.        *    "The equality operators equal (==), and not equal (!=)
  1267.        *    operate on all types. They result in a scalar Boolean. If
  1268.        *    the operand types do not match, then there must be a
  1269.        *    conversion from Section 4.1.10 "Implicit Conversions"
  1270.        *    applied to one operand that can make them match, in which
  1271.        *    case this conversion is done."
  1272.        */
  1273.       if ((!apply_implicit_conversion(op[0]->type, op[1], state)
  1274.            && !apply_implicit_conversion(op[1]->type, op[0], state))
  1275.           || (op[0]->type != op[1]->type)) {
  1276.          _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
  1277.                           "type", (this->oper == ast_equal) ? "==" : "!=");
  1278.          error_emitted = true;
  1279.       } else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
  1280.                  !state->check_version(120, 300, &loc,
  1281.                                        "array comparisons forbidden")) {
  1282.          error_emitted = true;
  1283.       } else if ((op[0]->type->contains_opaque() ||
  1284.                   op[1]->type->contains_opaque())) {
  1285.          _mesa_glsl_error(&loc, state, "opaque type comparisons forbidden");
  1286.          error_emitted = true;
  1287.       }
  1288.  
  1289.       if (error_emitted) {
  1290.          result = new(ctx) ir_constant(false);
  1291.       } else {
  1292.          result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
  1293.          assert(result->type == glsl_type::bool_type);
  1294.       }
  1295.       break;
  1296.  
  1297.    case ast_bit_and:
  1298.    case ast_bit_xor:
  1299.    case ast_bit_or:
  1300.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1301.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1302.       type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
  1303.                                    state, &loc);
  1304.       result = new(ctx) ir_expression(operations[this->oper], type,
  1305.                                       op[0], op[1]);
  1306.       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
  1307.       break;
  1308.  
  1309.    case ast_bit_not:
  1310.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1311.  
  1312.       if (!state->check_bitwise_operations_allowed(&loc)) {
  1313.          error_emitted = true;
  1314.       }
  1315.  
  1316.       if (!op[0]->type->is_integer()) {
  1317.          _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
  1318.          error_emitted = true;
  1319.       }
  1320.  
  1321.       type = error_emitted ? glsl_type::error_type : op[0]->type;
  1322.       result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);
  1323.       break;
  1324.  
  1325.    case ast_logic_and: {
  1326.       exec_list rhs_instructions;
  1327.       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
  1328.                                          "LHS", &error_emitted);
  1329.       op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
  1330.                                          "RHS", &error_emitted);
  1331.  
  1332.       if (rhs_instructions.is_empty()) {
  1333.          result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
  1334.          type = result->type;
  1335.       } else {
  1336.          ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
  1337.                                                        "and_tmp",
  1338.                                                        ir_var_temporary);
  1339.          instructions->push_tail(tmp);
  1340.  
  1341.          ir_if *const stmt = new(ctx) ir_if(op[0]);
  1342.          instructions->push_tail(stmt);
  1343.  
  1344.          stmt->then_instructions.append_list(&rhs_instructions);
  1345.          ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
  1346.          ir_assignment *const then_assign =
  1347.             new(ctx) ir_assignment(then_deref, op[1]);
  1348.          stmt->then_instructions.push_tail(then_assign);
  1349.  
  1350.          ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
  1351.          ir_assignment *const else_assign =
  1352.             new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
  1353.          stmt->else_instructions.push_tail(else_assign);
  1354.  
  1355.          result = new(ctx) ir_dereference_variable(tmp);
  1356.          type = tmp->type;
  1357.       }
  1358.       break;
  1359.    }
  1360.  
  1361.    case ast_logic_or: {
  1362.       exec_list rhs_instructions;
  1363.       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
  1364.                                          "LHS", &error_emitted);
  1365.       op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
  1366.                                          "RHS", &error_emitted);
  1367.  
  1368.       if (rhs_instructions.is_empty()) {
  1369.          result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
  1370.          type = result->type;
  1371.       } else {
  1372.          ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
  1373.                                                        "or_tmp",
  1374.                                                        ir_var_temporary);
  1375.          instructions->push_tail(tmp);
  1376.  
  1377.          ir_if *const stmt = new(ctx) ir_if(op[0]);
  1378.          instructions->push_tail(stmt);
  1379.  
  1380.          ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
  1381.          ir_assignment *const then_assign =
  1382.             new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
  1383.          stmt->then_instructions.push_tail(then_assign);
  1384.  
  1385.          stmt->else_instructions.append_list(&rhs_instructions);
  1386.          ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
  1387.          ir_assignment *const else_assign =
  1388.             new(ctx) ir_assignment(else_deref, op[1]);
  1389.          stmt->else_instructions.push_tail(else_assign);
  1390.  
  1391.          result = new(ctx) ir_dereference_variable(tmp);
  1392.          type = tmp->type;
  1393.       }
  1394.       break;
  1395.    }
  1396.  
  1397.    case ast_logic_xor:
  1398.       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
  1399.        *
  1400.        *    "The logical binary operators and (&&), or ( | | ), and
  1401.        *     exclusive or (^^). They operate only on two Boolean
  1402.        *     expressions and result in a Boolean expression."
  1403.        */
  1404.       op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
  1405.                                          &error_emitted);
  1406.       op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
  1407.                                          &error_emitted);
  1408.  
  1409.       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
  1410.                                       op[0], op[1]);
  1411.       break;
  1412.  
  1413.    case ast_logic_not:
  1414.       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
  1415.                                          "operand", &error_emitted);
  1416.  
  1417.       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
  1418.                                       op[0], NULL);
  1419.       break;
  1420.  
  1421.    case ast_mul_assign:
  1422.    case ast_div_assign:
  1423.    case ast_add_assign:
  1424.    case ast_sub_assign: {
  1425.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1426.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1427.  
  1428.       type = arithmetic_result_type(op[0], op[1],
  1429.                                     (this->oper == ast_mul_assign),
  1430.                                     state, & loc);
  1431.  
  1432.       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
  1433.                                                    op[0], op[1]);
  1434.  
  1435.       error_emitted =
  1436.          do_assignment(instructions, state,
  1437.                        this->subexpressions[0]->non_lvalue_description,
  1438.                        op[0]->clone(ctx, NULL), temp_rhs,
  1439.                        &result, needs_rvalue, false,
  1440.                        this->subexpressions[0]->get_location());
  1441.  
  1442.       /* GLSL 1.10 does not allow array assignment.  However, we don't have to
  1443.        * explicitly test for this because none of the binary expression
  1444.        * operators allow array operands either.
  1445.        */
  1446.  
  1447.       break;
  1448.    }
  1449.  
  1450.    case ast_mod_assign: {
  1451.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1452.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1453.  
  1454.       type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
  1455.  
  1456.       assert(operations[this->oper] == ir_binop_mod);
  1457.  
  1458.       ir_rvalue *temp_rhs;
  1459.       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
  1460.                                         op[0], op[1]);
  1461.  
  1462.       error_emitted =
  1463.          do_assignment(instructions, state,
  1464.                        this->subexpressions[0]->non_lvalue_description,
  1465.                        op[0]->clone(ctx, NULL), temp_rhs,
  1466.                        &result, needs_rvalue, false,
  1467.                        this->subexpressions[0]->get_location());
  1468.       break;
  1469.    }
  1470.  
  1471.    case ast_ls_assign:
  1472.    case ast_rs_assign: {
  1473.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1474.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1475.       type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
  1476.                                &loc);
  1477.       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
  1478.                                                    type, op[0], op[1]);
  1479.       error_emitted =
  1480.          do_assignment(instructions, state,
  1481.                        this->subexpressions[0]->non_lvalue_description,
  1482.                        op[0]->clone(ctx, NULL), temp_rhs,
  1483.                        &result, needs_rvalue, false,
  1484.                        this->subexpressions[0]->get_location());
  1485.       break;
  1486.    }
  1487.  
  1488.    case ast_and_assign:
  1489.    case ast_xor_assign:
  1490.    case ast_or_assign: {
  1491.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1492.       op[1] = this->subexpressions[1]->hir(instructions, state);
  1493.       type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
  1494.                                    state, &loc);
  1495.       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
  1496.                                                    type, op[0], op[1]);
  1497.       error_emitted =
  1498.          do_assignment(instructions, state,
  1499.                        this->subexpressions[0]->non_lvalue_description,
  1500.                        op[0]->clone(ctx, NULL), temp_rhs,
  1501.                        &result, needs_rvalue, false,
  1502.                        this->subexpressions[0]->get_location());
  1503.       break;
  1504.    }
  1505.  
  1506.    case ast_conditional: {
  1507.       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
  1508.        *
  1509.        *    "The ternary selection operator (?:). It operates on three
  1510.        *    expressions (exp1 ? exp2 : exp3). This operator evaluates the
  1511.        *    first expression, which must result in a scalar Boolean."
  1512.        */
  1513.       op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
  1514.                                          "condition", &error_emitted);
  1515.  
  1516.       /* The :? operator is implemented by generating an anonymous temporary
  1517.        * followed by an if-statement.  The last instruction in each branch of
  1518.        * the if-statement assigns a value to the anonymous temporary.  This
  1519.        * temporary is the r-value of the expression.
  1520.        */
  1521.       exec_list then_instructions;
  1522.       exec_list else_instructions;
  1523.  
  1524.       op[1] = this->subexpressions[1]->hir(&then_instructions, state);
  1525.       op[2] = this->subexpressions[2]->hir(&else_instructions, state);
  1526.  
  1527.       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
  1528.        *
  1529.        *     "The second and third expressions can be any type, as
  1530.        *     long their types match, or there is a conversion in
  1531.        *     Section 4.1.10 "Implicit Conversions" that can be applied
  1532.        *     to one of the expressions to make their types match. This
  1533.        *     resulting matching type is the type of the entire
  1534.        *     expression."
  1535.        */
  1536.       if ((!apply_implicit_conversion(op[1]->type, op[2], state)
  1537.           && !apply_implicit_conversion(op[2]->type, op[1], state))
  1538.           || (op[1]->type != op[2]->type)) {
  1539.          YYLTYPE loc = this->subexpressions[1]->get_location();
  1540.  
  1541.          _mesa_glsl_error(& loc, state, "second and third operands of ?: "
  1542.                           "operator must have matching types");
  1543.          error_emitted = true;
  1544.          type = glsl_type::error_type;
  1545.       } else {
  1546.          type = op[1]->type;
  1547.       }
  1548.  
  1549.       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
  1550.        *
  1551.        *    "The second and third expressions must be the same type, but can
  1552.        *    be of any type other than an array."
  1553.        */
  1554.       if (type->is_array() &&
  1555.           !state->check_version(120, 300, &loc,
  1556.                                 "second and third operands of ?: operator "
  1557.                                 "cannot be arrays")) {
  1558.          error_emitted = true;
  1559.       }
  1560.  
  1561.       /* From section 4.1.7 of the GLSL 4.50 spec (Opaque Types):
  1562.        *
  1563.        *  "Except for array indexing, structure member selection, and
  1564.        *   parentheses, opaque variables are not allowed to be operands in
  1565.        *   expressions; such use results in a compile-time error."
  1566.        */
  1567.       if (type->contains_opaque()) {
  1568.          _mesa_glsl_error(&loc, state, "opaque variables cannot be operands "
  1569.                           "of the ?: operator");
  1570.          error_emitted = true;
  1571.       }
  1572.  
  1573.       ir_constant *cond_val = op[0]->constant_expression_value();
  1574.  
  1575.       if (then_instructions.is_empty()
  1576.           && else_instructions.is_empty()
  1577.           && cond_val != NULL) {
  1578.          result = cond_val->value.b[0] ? op[1] : op[2];
  1579.       } else {
  1580.          /* The copy to conditional_tmp reads the whole array. */
  1581.          if (type->is_array()) {
  1582.             mark_whole_array_access(op[1]);
  1583.             mark_whole_array_access(op[2]);
  1584.          }
  1585.  
  1586.          ir_variable *const tmp =
  1587.             new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
  1588.          instructions->push_tail(tmp);
  1589.  
  1590.          ir_if *const stmt = new(ctx) ir_if(op[0]);
  1591.          instructions->push_tail(stmt);
  1592.  
  1593.          then_instructions.move_nodes_to(& stmt->then_instructions);
  1594.          ir_dereference *const then_deref =
  1595.             new(ctx) ir_dereference_variable(tmp);
  1596.          ir_assignment *const then_assign =
  1597.             new(ctx) ir_assignment(then_deref, op[1]);
  1598.          stmt->then_instructions.push_tail(then_assign);
  1599.  
  1600.          else_instructions.move_nodes_to(& stmt->else_instructions);
  1601.          ir_dereference *const else_deref =
  1602.             new(ctx) ir_dereference_variable(tmp);
  1603.          ir_assignment *const else_assign =
  1604.             new(ctx) ir_assignment(else_deref, op[2]);
  1605.          stmt->else_instructions.push_tail(else_assign);
  1606.  
  1607.          result = new(ctx) ir_dereference_variable(tmp);
  1608.       }
  1609.       break;
  1610.    }
  1611.  
  1612.    case ast_pre_inc:
  1613.    case ast_pre_dec: {
  1614.       this->non_lvalue_description = (this->oper == ast_pre_inc)
  1615.          ? "pre-increment operation" : "pre-decrement operation";
  1616.  
  1617.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1618.       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
  1619.  
  1620.       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
  1621.  
  1622.       ir_rvalue *temp_rhs;
  1623.       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
  1624.                                         op[0], op[1]);
  1625.  
  1626.       error_emitted =
  1627.          do_assignment(instructions, state,
  1628.                        this->subexpressions[0]->non_lvalue_description,
  1629.                        op[0]->clone(ctx, NULL), temp_rhs,
  1630.                        &result, needs_rvalue, false,
  1631.                        this->subexpressions[0]->get_location());
  1632.       break;
  1633.    }
  1634.  
  1635.    case ast_post_inc:
  1636.    case ast_post_dec: {
  1637.       this->non_lvalue_description = (this->oper == ast_post_inc)
  1638.          ? "post-increment operation" : "post-decrement operation";
  1639.       op[0] = this->subexpressions[0]->hir(instructions, state);
  1640.       op[1] = constant_one_for_inc_dec(ctx, op[0]->type);
  1641.  
  1642.       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
  1643.  
  1644.       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
  1645.  
  1646.       ir_rvalue *temp_rhs;
  1647.       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
  1648.                                         op[0], op[1]);
  1649.  
  1650.       /* Get a temporary of a copy of the lvalue before it's modified.
  1651.        * This may get thrown away later.
  1652.        */
  1653.       result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
  1654.  
  1655.       ir_rvalue *junk_rvalue;
  1656.       error_emitted =
  1657.          do_assignment(instructions, state,
  1658.                        this->subexpressions[0]->non_lvalue_description,
  1659.                        op[0]->clone(ctx, NULL), temp_rhs,
  1660.                        &junk_rvalue, false, false,
  1661.                        this->subexpressions[0]->get_location());
  1662.  
  1663.       break;
  1664.    }
  1665.  
  1666.    case ast_field_selection:
  1667.       result = _mesa_ast_field_selection_to_hir(this, instructions, state);
  1668.       break;
  1669.  
  1670.    case ast_array_index: {
  1671.       YYLTYPE index_loc = subexpressions[1]->get_location();
  1672.  
  1673.       op[0] = subexpressions[0]->hir(instructions, state);
  1674.       op[1] = subexpressions[1]->hir(instructions, state);
  1675.  
  1676.       result = _mesa_ast_array_index_to_hir(ctx, state, op[0], op[1],
  1677.                                             loc, index_loc);
  1678.  
  1679.       if (result->type->is_error())
  1680.          error_emitted = true;
  1681.  
  1682.       break;
  1683.    }
  1684.  
  1685.    case ast_function_call:
  1686.       /* Should *NEVER* get here.  ast_function_call should always be handled
  1687.        * by ast_function_expression::hir.
  1688.        */
  1689.       assert(0);
  1690.       break;
  1691.  
  1692.    case ast_identifier: {
  1693.       /* ast_identifier can appear several places in a full abstract syntax
  1694.        * tree.  This particular use must be at location specified in the grammar
  1695.        * as 'variable_identifier'.
  1696.        */
  1697.       ir_variable *var =
  1698.          state->symbols->get_variable(this->primary_expression.identifier);
  1699.  
  1700.       if (var != NULL) {
  1701.          var->data.used = true;
  1702.          result = new(ctx) ir_dereference_variable(var);
  1703.       } else {
  1704.          _mesa_glsl_error(& loc, state, "`%s' undeclared",
  1705.                           this->primary_expression.identifier);
  1706.  
  1707.          result = ir_rvalue::error_value(ctx);
  1708.          error_emitted = true;
  1709.       }
  1710.       break;
  1711.    }
  1712.  
  1713.    case ast_int_constant:
  1714.       result = new(ctx) ir_constant(this->primary_expression.int_constant);
  1715.       break;
  1716.  
  1717.    case ast_uint_constant:
  1718.       result = new(ctx) ir_constant(this->primary_expression.uint_constant);
  1719.       break;
  1720.  
  1721.    case ast_float_constant:
  1722.       result = new(ctx) ir_constant(this->primary_expression.float_constant);
  1723.       break;
  1724.  
  1725.    case ast_bool_constant:
  1726.       result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
  1727.       break;
  1728.  
  1729.    case ast_double_constant:
  1730.       result = new(ctx) ir_constant(this->primary_expression.double_constant);
  1731.       break;
  1732.  
  1733.    case ast_sequence: {
  1734.       /* It should not be possible to generate a sequence in the AST without
  1735.        * any expressions in it.
  1736.        */
  1737.       assert(!this->expressions.is_empty());
  1738.  
  1739.       /* The r-value of a sequence is the last expression in the sequence.  If
  1740.        * the other expressions in the sequence do not have side-effects (and
  1741.        * therefore add instructions to the instruction list), they get dropped
  1742.        * on the floor.
  1743.        */
  1744.       exec_node *previous_tail_pred = NULL;
  1745.       YYLTYPE previous_operand_loc = loc;
  1746.  
  1747.       foreach_list_typed (ast_node, ast, link, &this->expressions) {
  1748.          /* If one of the operands of comma operator does not generate any
  1749.           * code, we want to emit a warning.  At each pass through the loop
  1750.           * previous_tail_pred will point to the last instruction in the
  1751.           * stream *before* processing the previous operand.  Naturally,
  1752.           * instructions->tail_pred will point to the last instruction in the
  1753.           * stream *after* processing the previous operand.  If the two
  1754.           * pointers match, then the previous operand had no effect.
  1755.           *
  1756.           * The warning behavior here differs slightly from GCC.  GCC will
  1757.           * only emit a warning if none of the left-hand operands have an
  1758.           * effect.  However, it will emit a warning for each.  I believe that
  1759.           * there are some cases in C (especially with GCC extensions) where
  1760.           * it is useful to have an intermediate step in a sequence have no
  1761.           * effect, but I don't think these cases exist in GLSL.  Either way,
  1762.           * it would be a giant hassle to replicate that behavior.
  1763.           */
  1764.          if (previous_tail_pred == instructions->tail_pred) {
  1765.             _mesa_glsl_warning(&previous_operand_loc, state,
  1766.                                "left-hand operand of comma expression has "
  1767.                                "no effect");
  1768.          }
  1769.  
  1770.          /* tail_pred is directly accessed instead of using the get_tail()
  1771.           * method for performance reasons.  get_tail() has extra code to
  1772.           * return NULL when the list is empty.  We don't care about that
  1773.           * here, so using tail_pred directly is fine.
  1774.           */
  1775.          previous_tail_pred = instructions->tail_pred;
  1776.          previous_operand_loc = ast->get_location();
  1777.  
  1778.          result = ast->hir(instructions, state);
  1779.       }
  1780.  
  1781.       /* Any errors should have already been emitted in the loop above.
  1782.        */
  1783.       error_emitted = true;
  1784.       break;
  1785.    }
  1786.    }
  1787.    type = NULL; /* use result->type, not type. */
  1788.    assert(result != NULL || !needs_rvalue);
  1789.  
  1790.    if (result && result->type->is_error() && !error_emitted)
  1791.       _mesa_glsl_error(& loc, state, "type mismatch");
  1792.  
  1793.    return result;
  1794. }
  1795.  
  1796.  
  1797. ir_rvalue *
  1798. ast_expression_statement::hir(exec_list *instructions,
  1799.                               struct _mesa_glsl_parse_state *state)
  1800. {
  1801.    /* It is possible to have expression statements that don't have an
  1802.     * expression.  This is the solitary semicolon:
  1803.     *
  1804.     * for (i = 0; i < 5; i++)
  1805.     *     ;
  1806.     *
  1807.     * In this case the expression will be NULL.  Test for NULL and don't do
  1808.     * anything in that case.
  1809.     */
  1810.    if (expression != NULL)
  1811.       expression->hir_no_rvalue(instructions, state);
  1812.  
  1813.    /* Statements do not have r-values.
  1814.     */
  1815.    return NULL;
  1816. }
  1817.  
  1818.  
  1819. ir_rvalue *
  1820. ast_compound_statement::hir(exec_list *instructions,
  1821.                             struct _mesa_glsl_parse_state *state)
  1822. {
  1823.    if (new_scope)
  1824.       state->symbols->push_scope();
  1825.  
  1826.    foreach_list_typed (ast_node, ast, link, &this->statements)
  1827.       ast->hir(instructions, state);
  1828.  
  1829.    if (new_scope)
  1830.       state->symbols->pop_scope();
  1831.  
  1832.    /* Compound statements do not have r-values.
  1833.     */
  1834.    return NULL;
  1835. }
  1836.  
  1837. /**
  1838.  * Evaluate the given exec_node (which should be an ast_node representing
  1839.  * a single array dimension) and return its integer value.
  1840.  */
  1841. static unsigned
  1842. process_array_size(exec_node *node,
  1843.                    struct _mesa_glsl_parse_state *state)
  1844. {
  1845.    exec_list dummy_instructions;
  1846.  
  1847.    ast_node *array_size = exec_node_data(ast_node, node, link);
  1848.    ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
  1849.    YYLTYPE loc = array_size->get_location();
  1850.  
  1851.    if (ir == NULL) {
  1852.       _mesa_glsl_error(& loc, state,
  1853.                        "array size could not be resolved");
  1854.       return 0;
  1855.    }
  1856.  
  1857.    if (!ir->type->is_integer()) {
  1858.       _mesa_glsl_error(& loc, state,
  1859.                        "array size must be integer type");
  1860.       return 0;
  1861.    }
  1862.  
  1863.    if (!ir->type->is_scalar()) {
  1864.       _mesa_glsl_error(& loc, state,
  1865.                        "array size must be scalar type");
  1866.       return 0;
  1867.    }
  1868.  
  1869.    ir_constant *const size = ir->constant_expression_value();
  1870.    if (size == NULL) {
  1871.       _mesa_glsl_error(& loc, state, "array size must be a "
  1872.                        "constant valued expression");
  1873.       return 0;
  1874.    }
  1875.  
  1876.    if (size->value.i[0] <= 0) {
  1877.       _mesa_glsl_error(& loc, state, "array size must be > 0");
  1878.       return 0;
  1879.    }
  1880.  
  1881.    assert(size->type == ir->type);
  1882.  
  1883.    /* If the array size is const (and we've verified that
  1884.     * it is) then no instructions should have been emitted
  1885.     * when we converted it to HIR. If they were emitted,
  1886.     * then either the array size isn't const after all, or
  1887.     * we are emitting unnecessary instructions.
  1888.     */
  1889.    assert(dummy_instructions.is_empty());
  1890.  
  1891.    return size->value.u[0];
  1892. }
  1893.  
  1894. static const glsl_type *
  1895. process_array_type(YYLTYPE *loc, const glsl_type *base,
  1896.                    ast_array_specifier *array_specifier,
  1897.                    struct _mesa_glsl_parse_state *state)
  1898. {
  1899.    const glsl_type *array_type = base;
  1900.  
  1901.    if (array_specifier != NULL) {
  1902.       if (base->is_array()) {
  1903.  
  1904.          /* From page 19 (page 25) of the GLSL 1.20 spec:
  1905.           *
  1906.           * "Only one-dimensional arrays may be declared."
  1907.           */
  1908.          if (!state->ARB_arrays_of_arrays_enable) {
  1909.             _mesa_glsl_error(loc, state,
  1910.                              "invalid array of `%s'"
  1911.                              "GL_ARB_arrays_of_arrays "
  1912.                              "required for defining arrays of arrays",
  1913.                              base->name);
  1914.             return glsl_type::error_type;
  1915.          }
  1916.  
  1917.          if (base->length == 0) {
  1918.             _mesa_glsl_error(loc, state,
  1919.                              "only the outermost array dimension can "
  1920.                              "be unsized",
  1921.                              base->name);
  1922.             return glsl_type::error_type;
  1923.          }
  1924.       }
  1925.  
  1926.       for (exec_node *node = array_specifier->array_dimensions.tail_pred;
  1927.            !node->is_head_sentinel(); node = node->prev) {
  1928.          unsigned array_size = process_array_size(node, state);
  1929.          array_type = glsl_type::get_array_instance(array_type, array_size);
  1930.       }
  1931.  
  1932.       if (array_specifier->is_unsized_array)
  1933.          array_type = glsl_type::get_array_instance(array_type, 0);
  1934.    }
  1935.  
  1936.    return array_type;
  1937. }
  1938.  
  1939.  
  1940. const glsl_type *
  1941. ast_type_specifier::glsl_type(const char **name,
  1942.                               struct _mesa_glsl_parse_state *state) const
  1943. {
  1944.    const struct glsl_type *type;
  1945.  
  1946.    type = state->symbols->get_type(this->type_name);
  1947.    *name = this->type_name;
  1948.  
  1949.    YYLTYPE loc = this->get_location();
  1950.    type = process_array_type(&loc, type, this->array_specifier, state);
  1951.  
  1952.    return type;
  1953. }
  1954.  
  1955. const glsl_type *
  1956. ast_fully_specified_type::glsl_type(const char **name,
  1957.                                     struct _mesa_glsl_parse_state *state) const
  1958. {
  1959.    const struct glsl_type *type = this->specifier->glsl_type(name, state);
  1960.  
  1961.    if (type == NULL)
  1962.       return NULL;
  1963.  
  1964.    if (type->base_type == GLSL_TYPE_FLOAT
  1965.        && state->es_shader
  1966.        && state->stage == MESA_SHADER_FRAGMENT
  1967.        && this->qualifier.precision == ast_precision_none
  1968.        && state->symbols->get_variable("#default precision") == NULL) {
  1969.       YYLTYPE loc = this->get_location();
  1970.       _mesa_glsl_error(&loc, state,
  1971.                        "no precision specified this scope for type `%s'",
  1972.                        type->name);
  1973.    }
  1974.  
  1975.    return type;
  1976. }
  1977.  
  1978. /**
  1979.  * Determine whether a toplevel variable declaration declares a varying.  This
  1980.  * function operates by examining the variable's mode and the shader target,
  1981.  * so it correctly identifies linkage variables regardless of whether they are
  1982.  * declared using the deprecated "varying" syntax or the new "in/out" syntax.
  1983.  *
  1984.  * Passing a non-toplevel variable declaration (e.g. a function parameter) to
  1985.  * this function will produce undefined results.
  1986.  */
  1987. static bool
  1988. is_varying_var(ir_variable *var, gl_shader_stage target)
  1989. {
  1990.    switch (target) {
  1991.    case MESA_SHADER_VERTEX:
  1992.       return var->data.mode == ir_var_shader_out;
  1993.    case MESA_SHADER_FRAGMENT:
  1994.       return var->data.mode == ir_var_shader_in;
  1995.    default:
  1996.       return var->data.mode == ir_var_shader_out || var->data.mode == ir_var_shader_in;
  1997.    }
  1998. }
  1999.  
  2000.  
  2001. /**
  2002.  * Matrix layout qualifiers are only allowed on certain types
  2003.  */
  2004. static void
  2005. validate_matrix_layout_for_type(struct _mesa_glsl_parse_state *state,
  2006.                                 YYLTYPE *loc,
  2007.                                 const glsl_type *type,
  2008.                                 ir_variable *var)
  2009. {
  2010.    if (var && !var->is_in_uniform_block()) {
  2011.       /* Layout qualifiers may only apply to interface blocks and fields in
  2012.        * them.
  2013.        */
  2014.       _mesa_glsl_error(loc, state,
  2015.                        "uniform block layout qualifiers row_major and "
  2016.                        "column_major may not be applied to variables "
  2017.                        "outside of uniform blocks");
  2018.    } else if (!type->is_matrix()) {
  2019.       /* The OpenGL ES 3.0 conformance tests did not originally allow
  2020.        * matrix layout qualifiers on non-matrices.  However, the OpenGL
  2021.        * 4.4 and OpenGL ES 3.0 (revision TBD) specifications were
  2022.        * amended to specifically allow these layouts on all types.  Emit
  2023.        * a warning so that people know their code may not be portable.
  2024.        */
  2025.       _mesa_glsl_warning(loc, state,
  2026.                          "uniform block layout qualifiers row_major and "
  2027.                          "column_major applied to non-matrix types may "
  2028.                          "be rejected by older compilers");
  2029.    } else if (type->is_record()) {
  2030.       /* We allow 'layout(row_major)' on structure types because it's the only
  2031.        * way to get row-major layouts on matrices contained in structures.
  2032.        */
  2033.       _mesa_glsl_warning(loc, state,
  2034.                          "uniform block layout qualifiers row_major and "
  2035.                          "column_major applied to structure types is not "
  2036.                          "strictly conformant and may be rejected by other "
  2037.                          "compilers");
  2038.    }
  2039. }
  2040.  
  2041. static bool
  2042. validate_binding_qualifier(struct _mesa_glsl_parse_state *state,
  2043.                            YYLTYPE *loc,
  2044.                            ir_variable *var,
  2045.                            const ast_type_qualifier *qual)
  2046. {
  2047.    if (var->data.mode != ir_var_uniform) {
  2048.       _mesa_glsl_error(loc, state,
  2049.                        "the \"binding\" qualifier only applies to uniforms");
  2050.       return false;
  2051.    }
  2052.  
  2053.    if (qual->binding < 0) {
  2054.       _mesa_glsl_error(loc, state, "binding values must be >= 0");
  2055.       return false;
  2056.    }
  2057.  
  2058.    const struct gl_context *const ctx = state->ctx;
  2059.    unsigned elements = var->type->is_array() ? var->type->length : 1;
  2060.    unsigned max_index = qual->binding + elements - 1;
  2061.  
  2062.    if (var->type->is_interface()) {
  2063.       /* UBOs.  From page 60 of the GLSL 4.20 specification:
  2064.        * "If the binding point for any uniform block instance is less than zero,
  2065.        *  or greater than or equal to the implementation-dependent maximum
  2066.        *  number of uniform buffer bindings, a compilation error will occur.
  2067.        *  When the binding identifier is used with a uniform block instanced as
  2068.        *  an array of size N, all elements of the array from binding through
  2069.        *  binding + N – 1 must be within this range."
  2070.        *
  2071.        * The implementation-dependent maximum is GL_MAX_UNIFORM_BUFFER_BINDINGS.
  2072.        */
  2073.       if (max_index >= ctx->Const.MaxUniformBufferBindings) {
  2074.          _mesa_glsl_error(loc, state, "layout(binding = %d) for %d UBOs exceeds "
  2075.                           "the maximum number of UBO binding points (%d)",
  2076.                           qual->binding, elements,
  2077.                           ctx->Const.MaxUniformBufferBindings);
  2078.          return false;
  2079.       }
  2080.    } else if (var->type->is_sampler() ||
  2081.               (var->type->is_array() && var->type->fields.array->is_sampler())) {
  2082.       /* Samplers.  From page 63 of the GLSL 4.20 specification:
  2083.        * "If the binding is less than zero, or greater than or equal to the
  2084.        *  implementation-dependent maximum supported number of units, a
  2085.        *  compilation error will occur. When the binding identifier is used
  2086.        *  with an array of size N, all elements of the array from binding
  2087.        *  through binding + N - 1 must be within this range."
  2088.        */
  2089.       unsigned limit = ctx->Const.Program[state->stage].MaxTextureImageUnits;
  2090.  
  2091.       if (max_index >= limit) {
  2092.          _mesa_glsl_error(loc, state, "layout(binding = %d) for %d samplers "
  2093.                           "exceeds the maximum number of texture image units "
  2094.                           "(%d)", qual->binding, elements, limit);
  2095.  
  2096.          return false;
  2097.       }
  2098.    } else if (var->type->contains_atomic()) {
  2099.       assert(ctx->Const.MaxAtomicBufferBindings <= MAX_COMBINED_ATOMIC_BUFFERS);
  2100.       if (unsigned(qual->binding) >= ctx->Const.MaxAtomicBufferBindings) {
  2101.          _mesa_glsl_error(loc, state, "layout(binding = %d) exceeds the "
  2102.                           " maximum number of atomic counter buffer bindings"
  2103.                           "(%d)", qual->binding,
  2104.                           ctx->Const.MaxAtomicBufferBindings);
  2105.  
  2106.          return false;
  2107.       }
  2108.    } else {
  2109.       _mesa_glsl_error(loc, state,
  2110.                        "the \"binding\" qualifier only applies to uniform "
  2111.                        "blocks, samplers, atomic counters, or arrays thereof");
  2112.       return false;
  2113.    }
  2114.  
  2115.    return true;
  2116. }
  2117.  
  2118.  
  2119. static glsl_interp_qualifier
  2120. interpret_interpolation_qualifier(const struct ast_type_qualifier *qual,
  2121.                                   ir_variable_mode mode,
  2122.                                   struct _mesa_glsl_parse_state *state,
  2123.                                   YYLTYPE *loc)
  2124. {
  2125.    glsl_interp_qualifier interpolation;
  2126.    if (qual->flags.q.flat)
  2127.       interpolation = INTERP_QUALIFIER_FLAT;
  2128.    else if (qual->flags.q.noperspective)
  2129.       interpolation = INTERP_QUALIFIER_NOPERSPECTIVE;
  2130.    else if (qual->flags.q.smooth)
  2131.       interpolation = INTERP_QUALIFIER_SMOOTH;
  2132.    else
  2133.       interpolation = INTERP_QUALIFIER_NONE;
  2134.  
  2135.    if (interpolation != INTERP_QUALIFIER_NONE) {
  2136.       if (mode != ir_var_shader_in && mode != ir_var_shader_out) {
  2137.          _mesa_glsl_error(loc, state,
  2138.                           "interpolation qualifier `%s' can only be applied to "
  2139.                           "shader inputs or outputs.",
  2140.                           interpolation_string(interpolation));
  2141.  
  2142.       }
  2143.  
  2144.       if ((state->stage == MESA_SHADER_VERTEX && mode == ir_var_shader_in) ||
  2145.           (state->stage == MESA_SHADER_FRAGMENT && mode == ir_var_shader_out)) {
  2146.          _mesa_glsl_error(loc, state,
  2147.                           "interpolation qualifier `%s' cannot be applied to "
  2148.                           "vertex shader inputs or fragment shader outputs",
  2149.                           interpolation_string(interpolation));
  2150.       }
  2151.    }
  2152.  
  2153.    return interpolation;
  2154. }
  2155.  
  2156.  
  2157. static void
  2158. validate_explicit_location(const struct ast_type_qualifier *qual,
  2159.                            ir_variable *var,
  2160.                            struct _mesa_glsl_parse_state *state,
  2161.                            YYLTYPE *loc)
  2162. {
  2163.    bool fail = false;
  2164.  
  2165.    /* Checks for GL_ARB_explicit_uniform_location. */
  2166.    if (qual->flags.q.uniform) {
  2167.       if (!state->check_explicit_uniform_location_allowed(loc, var))
  2168.          return;
  2169.  
  2170.       const struct gl_context *const ctx = state->ctx;
  2171.       unsigned max_loc = qual->location + var->type->uniform_locations() - 1;
  2172.  
  2173.       /* ARB_explicit_uniform_location specification states:
  2174.        *
  2175.        *     "The explicitly defined locations and the generated locations
  2176.        *     must be in the range of 0 to MAX_UNIFORM_LOCATIONS minus one."
  2177.        *
  2178.        *     "Valid locations for default-block uniform variable locations
  2179.        *     are in the range of 0 to the implementation-defined maximum
  2180.        *     number of uniform locations."
  2181.        */
  2182.       if (qual->location < 0) {
  2183.          _mesa_glsl_error(loc, state,
  2184.                           "explicit location < 0 for uniform %s", var->name);
  2185.          return;
  2186.       }
  2187.  
  2188.       if (max_loc >= ctx->Const.MaxUserAssignableUniformLocations) {
  2189.          _mesa_glsl_error(loc, state, "location(s) consumed by uniform %s "
  2190.                           ">= MAX_UNIFORM_LOCATIONS (%u)", var->name,
  2191.                           ctx->Const.MaxUserAssignableUniformLocations);
  2192.          return;
  2193.       }
  2194.  
  2195.       var->data.explicit_location = true;
  2196.       var->data.location = qual->location;
  2197.       return;
  2198.    }
  2199.  
  2200.    /* Between GL_ARB_explicit_attrib_location an
  2201.     * GL_ARB_separate_shader_objects, the inputs and outputs of any shader
  2202.     * stage can be assigned explicit locations.  The checking here associates
  2203.     * the correct extension with the correct stage's input / output:
  2204.     *
  2205.     *                     input            output
  2206.     *                     -----            ------
  2207.     * vertex              explicit_loc     sso
  2208.     * geometry            sso              sso
  2209.     * fragment            sso              explicit_loc
  2210.     */
  2211.    switch (state->stage) {
  2212.    case MESA_SHADER_VERTEX:
  2213.       if (var->data.mode == ir_var_shader_in) {
  2214.          if (!state->check_explicit_attrib_location_allowed(loc, var))
  2215.             return;
  2216.  
  2217.          break;
  2218.       }
  2219.  
  2220.       if (var->data.mode == ir_var_shader_out) {
  2221.          if (!state->check_separate_shader_objects_allowed(loc, var))
  2222.             return;
  2223.  
  2224.          break;
  2225.       }
  2226.  
  2227.       fail = true;
  2228.       break;
  2229.  
  2230.    case MESA_SHADER_GEOMETRY:
  2231.       if (var->data.mode == ir_var_shader_in || var->data.mode == ir_var_shader_out) {
  2232.          if (!state->check_separate_shader_objects_allowed(loc, var))
  2233.             return;
  2234.  
  2235.          break;
  2236.       }
  2237.  
  2238.       fail = true;
  2239.       break;
  2240.  
  2241.    case MESA_SHADER_FRAGMENT:
  2242.       if (var->data.mode == ir_var_shader_in) {
  2243.          if (!state->check_separate_shader_objects_allowed(loc, var))
  2244.             return;
  2245.  
  2246.          break;
  2247.       }
  2248.  
  2249.       if (var->data.mode == ir_var_shader_out) {
  2250.          if (!state->check_explicit_attrib_location_allowed(loc, var))
  2251.             return;
  2252.  
  2253.          break;
  2254.       }
  2255.  
  2256.       fail = true;
  2257.       break;
  2258.  
  2259.    case MESA_SHADER_COMPUTE:
  2260.       _mesa_glsl_error(loc, state,
  2261.                        "compute shader variables cannot be given "
  2262.                        "explicit locations");
  2263.       return;
  2264.    };
  2265.  
  2266.    if (fail) {
  2267.       _mesa_glsl_error(loc, state,
  2268.                        "%s cannot be given an explicit location in %s shader",
  2269.                        mode_string(var),
  2270.       _mesa_shader_stage_to_string(state->stage));
  2271.    } else {
  2272.       var->data.explicit_location = true;
  2273.  
  2274.       /* This bit of silliness is needed because invalid explicit locations
  2275.        * are supposed to be flagged during linking.  Small negative values
  2276.        * biased by VERT_ATTRIB_GENERIC0 or FRAG_RESULT_DATA0 could alias
  2277.        * built-in values (e.g., -16+VERT_ATTRIB_GENERIC0 = VERT_ATTRIB_POS).
  2278.        * The linker needs to be able to differentiate these cases.  This
  2279.        * ensures that negative values stay negative.
  2280.        */
  2281.       if (qual->location >= 0) {
  2282.          switch (state->stage) {
  2283.          case MESA_SHADER_VERTEX:
  2284.             var->data.location = (var->data.mode == ir_var_shader_in)
  2285.                ? (qual->location + VERT_ATTRIB_GENERIC0)
  2286.                : (qual->location + VARYING_SLOT_VAR0);
  2287.             break;
  2288.  
  2289.          case MESA_SHADER_GEOMETRY:
  2290.             var->data.location = qual->location + VARYING_SLOT_VAR0;
  2291.             break;
  2292.  
  2293.          case MESA_SHADER_FRAGMENT:
  2294.             var->data.location = (var->data.mode == ir_var_shader_out)
  2295.                ? (qual->location + FRAG_RESULT_DATA0)
  2296.                : (qual->location + VARYING_SLOT_VAR0);
  2297.             break;
  2298.          case MESA_SHADER_COMPUTE:
  2299.             assert(!"Unexpected shader type");
  2300.             break;
  2301.          }
  2302.       } else {
  2303.          var->data.location = qual->location;
  2304.       }
  2305.  
  2306.       if (qual->flags.q.explicit_index) {
  2307.          /* From the GLSL 4.30 specification, section 4.4.2 (Output
  2308.           * Layout Qualifiers):
  2309.           *
  2310.           * "It is also a compile-time error if a fragment shader
  2311.           *  sets a layout index to less than 0 or greater than 1."
  2312.           *
  2313.           * Older specifications don't mandate a behavior; we take
  2314.           * this as a clarification and always generate the error.
  2315.           */
  2316.          if (qual->index < 0 || qual->index > 1) {
  2317.             _mesa_glsl_error(loc, state,
  2318.                              "explicit index may only be 0 or 1");
  2319.          } else {
  2320.             var->data.explicit_index = true;
  2321.             var->data.index = qual->index;
  2322.          }
  2323.       }
  2324.    }
  2325. }
  2326.  
  2327. static void
  2328. apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
  2329.                                   ir_variable *var,
  2330.                                   struct _mesa_glsl_parse_state *state,
  2331.                                   YYLTYPE *loc)
  2332. {
  2333.    const glsl_type *base_type =
  2334.       (var->type->is_array() ? var->type->element_type() : var->type);
  2335.  
  2336.    if (base_type->is_image()) {
  2337.       if (var->data.mode != ir_var_uniform &&
  2338.           var->data.mode != ir_var_function_in) {
  2339.          _mesa_glsl_error(loc, state, "image variables may only be declared as "
  2340.                           "function parameters or uniform-qualified "
  2341.                           "global variables");
  2342.       }
  2343.  
  2344.       var->data.image_read_only |= qual->flags.q.read_only;
  2345.       var->data.image_write_only |= qual->flags.q.write_only;
  2346.       var->data.image_coherent |= qual->flags.q.coherent;
  2347.       var->data.image_volatile |= qual->flags.q._volatile;
  2348.       var->data.image_restrict |= qual->flags.q.restrict_flag;
  2349.       var->data.read_only = true;
  2350.  
  2351.       if (qual->flags.q.explicit_image_format) {
  2352.          if (var->data.mode == ir_var_function_in) {
  2353.             _mesa_glsl_error(loc, state, "format qualifiers cannot be "
  2354.                              "used on image function parameters");
  2355.          }
  2356.  
  2357.          if (qual->image_base_type != base_type->sampler_type) {
  2358.             _mesa_glsl_error(loc, state, "format qualifier doesn't match the "
  2359.                              "base data type of the image");
  2360.          }
  2361.  
  2362.          var->data.image_format = qual->image_format;
  2363.       } else {
  2364.          if (var->data.mode == ir_var_uniform && !qual->flags.q.write_only) {
  2365.             _mesa_glsl_error(loc, state, "uniforms not qualified with "
  2366.                              "`writeonly' must have a format layout "
  2367.                              "qualifier");
  2368.          }
  2369.  
  2370.          var->data.image_format = GL_NONE;
  2371.       }
  2372.    } else if (qual->flags.q.read_only ||
  2373.               qual->flags.q.write_only ||
  2374.               qual->flags.q.coherent ||
  2375.               qual->flags.q._volatile ||
  2376.               qual->flags.q.restrict_flag ||
  2377.               qual->flags.q.explicit_image_format) {
  2378.       _mesa_glsl_error(loc, state, "memory qualifiers may only be applied to "
  2379.                        "images");
  2380.    }
  2381. }
  2382.  
  2383. static inline const char*
  2384. get_layout_qualifier_string(bool origin_upper_left, bool pixel_center_integer)
  2385. {
  2386.    if (origin_upper_left && pixel_center_integer)
  2387.       return "origin_upper_left, pixel_center_integer";
  2388.    else if (origin_upper_left)
  2389.       return "origin_upper_left";
  2390.    else if (pixel_center_integer)
  2391.       return "pixel_center_integer";
  2392.    else
  2393.       return " ";
  2394. }
  2395.  
  2396. static inline bool
  2397. is_conflicting_fragcoord_redeclaration(struct _mesa_glsl_parse_state *state,
  2398.                                        const struct ast_type_qualifier *qual)
  2399. {
  2400.    /* If gl_FragCoord was previously declared, and the qualifiers were
  2401.     * different in any way, return true.
  2402.     */
  2403.    if (state->fs_redeclares_gl_fragcoord) {
  2404.       return (state->fs_pixel_center_integer != qual->flags.q.pixel_center_integer
  2405.          || state->fs_origin_upper_left != qual->flags.q.origin_upper_left);
  2406.    }
  2407.  
  2408.    return false;
  2409. }
  2410.  
  2411. static void
  2412. apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
  2413.                                  ir_variable *var,
  2414.                                  struct _mesa_glsl_parse_state *state,
  2415.                                  YYLTYPE *loc,
  2416.                                  bool is_parameter)
  2417. {
  2418.    STATIC_ASSERT(sizeof(qual->flags.q) <= sizeof(qual->flags.i));
  2419.  
  2420.    if (qual->flags.q.invariant) {
  2421.       if (var->data.used) {
  2422.          _mesa_glsl_error(loc, state,
  2423.                           "variable `%s' may not be redeclared "
  2424.                           "`invariant' after being used",
  2425.                           var->name);
  2426.       } else {
  2427.          var->data.invariant = 1;
  2428.       }
  2429.    }
  2430.  
  2431.    if (qual->flags.q.precise) {
  2432.       if (var->data.used) {
  2433.          _mesa_glsl_error(loc, state,
  2434.                           "variable `%s' may not be redeclared "
  2435.                           "`precise' after being used",
  2436.                           var->name);
  2437.       } else {
  2438.          var->data.precise = 1;
  2439.       }
  2440.    }
  2441.  
  2442.    if (qual->flags.q.constant || qual->flags.q.attribute
  2443.        || qual->flags.q.uniform
  2444.        || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
  2445.       var->data.read_only = 1;
  2446.  
  2447.    if (qual->flags.q.centroid)
  2448.       var->data.centroid = 1;
  2449.  
  2450.    if (qual->flags.q.sample)
  2451.       var->data.sample = 1;
  2452.  
  2453.    if (state->stage == MESA_SHADER_GEOMETRY &&
  2454.        qual->flags.q.out && qual->flags.q.stream) {
  2455.       var->data.stream = qual->stream;
  2456.    }
  2457.  
  2458.    if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) {
  2459.       var->type = glsl_type::error_type;
  2460.       _mesa_glsl_error(loc, state,
  2461.                        "`attribute' variables may not be declared in the "
  2462.                        "%s shader",
  2463.                        _mesa_shader_stage_to_string(state->stage));
  2464.    }
  2465.  
  2466.    /* Disallow layout qualifiers which may only appear on layout declarations. */
  2467.    if (qual->flags.q.prim_type) {
  2468.       _mesa_glsl_error(loc, state,
  2469.                        "Primitive type may only be specified on GS input or output "
  2470.                        "layout declaration, not on variables.");
  2471.    }
  2472.  
  2473.    /* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says:
  2474.     *
  2475.     *     "However, the const qualifier cannot be used with out or inout."
  2476.     *
  2477.     * The same section of the GLSL 4.40 spec further clarifies this saying:
  2478.     *
  2479.     *     "The const qualifier cannot be used with out or inout, or a
  2480.     *     compile-time error results."
  2481.     */
  2482.    if (is_parameter && qual->flags.q.constant && qual->flags.q.out) {
  2483.       _mesa_glsl_error(loc, state,
  2484.                        "`const' may not be applied to `out' or `inout' "
  2485.                        "function parameters");
  2486.    }
  2487.  
  2488.    /* If there is no qualifier that changes the mode of the variable, leave
  2489.     * the setting alone.
  2490.     */
  2491.    assert(var->data.mode != ir_var_temporary);
  2492.    if (qual->flags.q.in && qual->flags.q.out)
  2493.       var->data.mode = ir_var_function_inout;
  2494.    else if (qual->flags.q.in)
  2495.       var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in;
  2496.    else if (qual->flags.q.attribute
  2497.             || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT)))
  2498.       var->data.mode = ir_var_shader_in;
  2499.    else if (qual->flags.q.out)
  2500.       var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out;
  2501.    else if (qual->flags.q.varying && (state->stage == MESA_SHADER_VERTEX))
  2502.       var->data.mode = ir_var_shader_out;
  2503.    else if (qual->flags.q.uniform)
  2504.       var->data.mode = ir_var_uniform;
  2505.  
  2506.    if (!is_parameter && is_varying_var(var, state->stage)) {
  2507.       /* User-defined ins/outs are not permitted in compute shaders. */
  2508.       if (state->stage == MESA_SHADER_COMPUTE) {
  2509.          _mesa_glsl_error(loc, state,
  2510.                           "user-defined input and output variables are not "
  2511.                           "permitted in compute shaders");
  2512.       }
  2513.  
  2514.       /* This variable is being used to link data between shader stages (in
  2515.        * pre-glsl-1.30 parlance, it's a "varying").  Check that it has a type
  2516.        * that is allowed for such purposes.
  2517.        *
  2518.        * From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:
  2519.        *
  2520.        *     "The varying qualifier can be used only with the data types
  2521.        *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of
  2522.        *     these."
  2523.        *
  2524.        * This was relaxed in GLSL version 1.30 and GLSL ES version 3.00.  From
  2525.        * page 31 (page 37 of the PDF) of the GLSL 1.30 spec:
  2526.        *
  2527.        *     "Fragment inputs can only be signed and unsigned integers and
  2528.        *     integer vectors, float, floating-point vectors, matrices, or
  2529.        *     arrays of these. Structures cannot be input.
  2530.        *
  2531.        * Similar text exists in the section on vertex shader outputs.
  2532.        *
  2533.        * Similar text exists in the GLSL ES 3.00 spec, except that the GLSL ES
  2534.        * 3.00 spec allows structs as well.  Varying structs are also allowed
  2535.        * in GLSL 1.50.
  2536.        */
  2537.       switch (var->type->get_scalar_type()->base_type) {
  2538.       case GLSL_TYPE_FLOAT:
  2539.          /* Ok in all GLSL versions */
  2540.          break;
  2541.       case GLSL_TYPE_UINT:
  2542.       case GLSL_TYPE_INT:
  2543.          if (state->is_version(130, 300))
  2544.             break;
  2545.          _mesa_glsl_error(loc, state,
  2546.                           "varying variables must be of base type float in %s",
  2547.                           state->get_version_string());
  2548.          break;
  2549.       case GLSL_TYPE_STRUCT:
  2550.          if (state->is_version(150, 300))
  2551.             break;
  2552.          _mesa_glsl_error(loc, state,
  2553.                           "varying variables may not be of type struct");
  2554.          break;
  2555.       case GLSL_TYPE_DOUBLE:
  2556.          break;
  2557.       default:
  2558.          _mesa_glsl_error(loc, state, "illegal type for a varying variable");
  2559.          break;
  2560.       }
  2561.    }
  2562.  
  2563.    if (state->all_invariant && (state->current_function == NULL)) {
  2564.       switch (state->stage) {
  2565.       case MESA_SHADER_VERTEX:
  2566.          if (var->data.mode == ir_var_shader_out)
  2567.             var->data.invariant = true;
  2568.               break;
  2569.       case MESA_SHADER_GEOMETRY:
  2570.          if ((var->data.mode == ir_var_shader_in)
  2571.              || (var->data.mode == ir_var_shader_out))
  2572.             var->data.invariant = true;
  2573.          break;
  2574.       case MESA_SHADER_FRAGMENT:
  2575.          if (var->data.mode == ir_var_shader_in)
  2576.             var->data.invariant = true;
  2577.          break;
  2578.       case MESA_SHADER_COMPUTE:
  2579.          /* Invariance isn't meaningful in compute shaders. */
  2580.          break;
  2581.       }
  2582.    }
  2583.  
  2584.    var->data.interpolation =
  2585.       interpret_interpolation_qualifier(qual, (ir_variable_mode) var->data.mode,
  2586.                                         state, loc);
  2587.  
  2588.    var->data.pixel_center_integer = qual->flags.q.pixel_center_integer;
  2589.    var->data.origin_upper_left = qual->flags.q.origin_upper_left;
  2590.    if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
  2591.        && (strcmp(var->name, "gl_FragCoord") != 0)) {
  2592.       const char *const qual_string = (qual->flags.q.origin_upper_left)
  2593.          ? "origin_upper_left" : "pixel_center_integer";
  2594.  
  2595.       _mesa_glsl_error(loc, state,
  2596.                        "layout qualifier `%s' can only be applied to "
  2597.                        "fragment shader input `gl_FragCoord'",
  2598.                        qual_string);
  2599.    }
  2600.  
  2601.    if (var->name != NULL && strcmp(var->name, "gl_FragCoord") == 0) {
  2602.  
  2603.       /* Section 4.3.8.1, page 39 of GLSL 1.50 spec says:
  2604.        *
  2605.        *    "Within any shader, the first redeclarations of gl_FragCoord
  2606.        *     must appear before any use of gl_FragCoord."
  2607.        *
  2608.        * Generate a compiler error if above condition is not met by the
  2609.        * fragment shader.
  2610.        */
  2611.       ir_variable *earlier = state->symbols->get_variable("gl_FragCoord");
  2612.       if (earlier != NULL &&
  2613.           earlier->data.used &&
  2614.           !state->fs_redeclares_gl_fragcoord) {
  2615.          _mesa_glsl_error(loc, state,
  2616.                           "gl_FragCoord used before its first redeclaration "
  2617.                           "in fragment shader");
  2618.       }
  2619.  
  2620.       /* Make sure all gl_FragCoord redeclarations specify the same layout
  2621.        * qualifiers.
  2622.        */
  2623.       if (is_conflicting_fragcoord_redeclaration(state, qual)) {
  2624.          const char *const qual_string =
  2625.             get_layout_qualifier_string(qual->flags.q.origin_upper_left,
  2626.                                         qual->flags.q.pixel_center_integer);
  2627.  
  2628.          const char *const state_string =
  2629.             get_layout_qualifier_string(state->fs_origin_upper_left,
  2630.                                         state->fs_pixel_center_integer);
  2631.  
  2632.          _mesa_glsl_error(loc, state,
  2633.                           "gl_FragCoord redeclared with different layout "
  2634.                           "qualifiers (%s) and (%s) ",
  2635.                           state_string,
  2636.                           qual_string);
  2637.       }
  2638.       state->fs_origin_upper_left = qual->flags.q.origin_upper_left;
  2639.       state->fs_pixel_center_integer = qual->flags.q.pixel_center_integer;
  2640.       state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers =
  2641.          !qual->flags.q.origin_upper_left && !qual->flags.q.pixel_center_integer;
  2642.       state->fs_redeclares_gl_fragcoord =
  2643.          state->fs_origin_upper_left ||
  2644.          state->fs_pixel_center_integer ||
  2645.          state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
  2646.    }
  2647.  
  2648.    if (qual->flags.q.explicit_location) {
  2649.       validate_explicit_location(qual, var, state, loc);
  2650.    } else if (qual->flags.q.explicit_index) {
  2651.       _mesa_glsl_error(loc, state, "explicit index requires explicit location");
  2652.    }
  2653.  
  2654.    if (qual->flags.q.explicit_binding &&
  2655.        validate_binding_qualifier(state, loc, var, qual)) {
  2656.       var->data.explicit_binding = true;
  2657.       var->data.binding = qual->binding;
  2658.    }
  2659.  
  2660.    if (var->type->contains_atomic()) {
  2661.       if (var->data.mode == ir_var_uniform) {
  2662.          if (var->data.explicit_binding) {
  2663.             unsigned *offset =
  2664.                &state->atomic_counter_offsets[var->data.binding];
  2665.  
  2666.             if (*offset % ATOMIC_COUNTER_SIZE)
  2667.                _mesa_glsl_error(loc, state,
  2668.                                 "misaligned atomic counter offset");
  2669.  
  2670.             var->data.atomic.offset = *offset;
  2671.             *offset += var->type->atomic_size();
  2672.  
  2673.          } else {
  2674.             _mesa_glsl_error(loc, state,
  2675.                              "atomic counters require explicit binding point");
  2676.          }
  2677.       } else if (var->data.mode != ir_var_function_in) {
  2678.          _mesa_glsl_error(loc, state, "atomic counters may only be declared as "
  2679.                           "function parameters or uniform-qualified "
  2680.                           "global variables");
  2681.       }
  2682.    }
  2683.  
  2684.    /* Does the declaration use the deprecated 'attribute' or 'varying'
  2685.     * keywords?
  2686.     */
  2687.    const bool uses_deprecated_qualifier = qual->flags.q.attribute
  2688.       || qual->flags.q.varying;
  2689.  
  2690.  
  2691.    /* Validate auxiliary storage qualifiers */
  2692.  
  2693.    /* From section 4.3.4 of the GLSL 1.30 spec:
  2694.     *    "It is an error to use centroid in in a vertex shader."
  2695.     *
  2696.     * From section 4.3.4 of the GLSL ES 3.00 spec:
  2697.     *    "It is an error to use centroid in or interpolation qualifiers in
  2698.     *    a vertex shader input."
  2699.     */
  2700.  
  2701.    /* Section 4.3.6 of the GLSL 1.30 specification states:
  2702.     * "It is an error to use centroid out in a fragment shader."
  2703.     *
  2704.     * The GL_ARB_shading_language_420pack extension specification states:
  2705.     * "It is an error to use auxiliary storage qualifiers or interpolation
  2706.     *  qualifiers on an output in a fragment shader."
  2707.     */
  2708.    if (qual->flags.q.sample && (!is_varying_var(var, state->stage) || uses_deprecated_qualifier)) {
  2709.       _mesa_glsl_error(loc, state,
  2710.                        "sample qualifier may only be used on `in` or `out` "
  2711.                        "variables between shader stages");
  2712.    }
  2713.    if (qual->flags.q.centroid && !is_varying_var(var, state->stage)) {
  2714.       _mesa_glsl_error(loc, state,
  2715.                        "centroid qualifier may only be used with `in', "
  2716.                        "`out' or `varying' variables between shader stages");
  2717.    }
  2718.  
  2719.  
  2720.    /* Is the 'layout' keyword used with parameters that allow relaxed checking.
  2721.     * Many implementations of GL_ARB_fragment_coord_conventions_enable and some
  2722.     * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable
  2723.     * allowed the layout qualifier to be used with 'varying' and 'attribute'.
  2724.     * These extensions and all following extensions that add the 'layout'
  2725.     * keyword have been modified to require the use of 'in' or 'out'.
  2726.     *
  2727.     * The following extension do not allow the deprecated keywords:
  2728.     *
  2729.     *    GL_AMD_conservative_depth
  2730.     *    GL_ARB_conservative_depth
  2731.     *    GL_ARB_gpu_shader5
  2732.     *    GL_ARB_separate_shader_objects
  2733.     *    GL_ARB_tesselation_shader
  2734.     *    GL_ARB_transform_feedback3
  2735.     *    GL_ARB_uniform_buffer_object
  2736.     *
  2737.     * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5
  2738.     * allow layout with the deprecated keywords.
  2739.     */
  2740.    const bool relaxed_layout_qualifier_checking =
  2741.       state->ARB_fragment_coord_conventions_enable;
  2742.  
  2743.    if (qual->has_layout() && uses_deprecated_qualifier) {
  2744.       if (relaxed_layout_qualifier_checking) {
  2745.          _mesa_glsl_warning(loc, state,
  2746.                             "`layout' qualifier may not be used with "
  2747.                             "`attribute' or `varying'");
  2748.       } else {
  2749.          _mesa_glsl_error(loc, state,
  2750.                           "`layout' qualifier may not be used with "
  2751.                           "`attribute' or `varying'");
  2752.       }
  2753.    }
  2754.  
  2755.    /* Layout qualifiers for gl_FragDepth, which are enabled by extension
  2756.     * AMD_conservative_depth.
  2757.     */
  2758.    int depth_layout_count = qual->flags.q.depth_any
  2759.       + qual->flags.q.depth_greater
  2760.       + qual->flags.q.depth_less
  2761.       + qual->flags.q.depth_unchanged;
  2762.    if (depth_layout_count > 0
  2763.        && !state->AMD_conservative_depth_enable
  2764.        && !state->ARB_conservative_depth_enable) {
  2765.        _mesa_glsl_error(loc, state,
  2766.                         "extension GL_AMD_conservative_depth or "
  2767.                         "GL_ARB_conservative_depth must be enabled "
  2768.                         "to use depth layout qualifiers");
  2769.    } else if (depth_layout_count > 0
  2770.               && strcmp(var->name, "gl_FragDepth") != 0) {
  2771.        _mesa_glsl_error(loc, state,
  2772.                         "depth layout qualifiers can be applied only to "
  2773.                         "gl_FragDepth");
  2774.    } else if (depth_layout_count > 1
  2775.               && strcmp(var->name, "gl_FragDepth") == 0) {
  2776.       _mesa_glsl_error(loc, state,
  2777.                        "at most one depth layout qualifier can be applied to "
  2778.                        "gl_FragDepth");
  2779.    }
  2780.    if (qual->flags.q.depth_any)
  2781.       var->data.depth_layout = ir_depth_layout_any;
  2782.    else if (qual->flags.q.depth_greater)
  2783.       var->data.depth_layout = ir_depth_layout_greater;
  2784.    else if (qual->flags.q.depth_less)
  2785.       var->data.depth_layout = ir_depth_layout_less;
  2786.    else if (qual->flags.q.depth_unchanged)
  2787.        var->data.depth_layout = ir_depth_layout_unchanged;
  2788.    else
  2789.        var->data.depth_layout = ir_depth_layout_none;
  2790.  
  2791.    if (qual->flags.q.std140 ||
  2792.        qual->flags.q.packed ||
  2793.        qual->flags.q.shared) {
  2794.       _mesa_glsl_error(loc, state,
  2795.                        "uniform block layout qualifiers std140, packed, and "
  2796.                        "shared can only be applied to uniform blocks, not "
  2797.                        "members");
  2798.    }
  2799.  
  2800.    if (qual->flags.q.row_major || qual->flags.q.column_major) {
  2801.       validate_matrix_layout_for_type(state, loc, var->type, var);
  2802.    }
  2803.  
  2804.    apply_image_qualifier_to_variable(qual, var, state, loc);
  2805.  
  2806.    /* From section 4.4.1.3 of the GLSL 4.50 specification (Fragment Shader
  2807.     * Inputs):
  2808.     *
  2809.     *  "Fragment shaders also allow the following layout qualifier on in only
  2810.     *   (not with variable declarations)
  2811.     *     layout-qualifier-id
  2812.     *        early_fragment_tests
  2813.     *   [...]"
  2814.     */
  2815.    if (qual->flags.q.early_fragment_tests) {
  2816.       _mesa_glsl_error(loc, state, "early_fragment_tests layout qualifier only "
  2817.                        "valid in fragment shader input layout declaration.");
  2818.    }
  2819. }
  2820.  
  2821. /**
  2822.  * Get the variable that is being redeclared by this declaration
  2823.  *
  2824.  * Semantic checks to verify the validity of the redeclaration are also
  2825.  * performed.  If semantic checks fail, compilation error will be emitted via
  2826.  * \c _mesa_glsl_error, but a non-\c NULL pointer will still be returned.
  2827.  *
  2828.  * \returns
  2829.  * A pointer to an existing variable in the current scope if the declaration
  2830.  * is a redeclaration, \c NULL otherwise.
  2831.  */
  2832. static ir_variable *
  2833. get_variable_being_redeclared(ir_variable *var, YYLTYPE loc,
  2834.                               struct _mesa_glsl_parse_state *state,
  2835.                               bool allow_all_redeclarations)
  2836. {
  2837.    /* Check if this declaration is actually a re-declaration, either to
  2838.     * resize an array or add qualifiers to an existing variable.
  2839.     *
  2840.     * This is allowed for variables in the current scope, or when at
  2841.     * global scope (for built-ins in the implicit outer scope).
  2842.     */
  2843.    ir_variable *earlier = state->symbols->get_variable(var->name);
  2844.    if (earlier == NULL ||
  2845.        (state->current_function != NULL &&
  2846.        !state->symbols->name_declared_this_scope(var->name))) {
  2847.       return NULL;
  2848.    }
  2849.  
  2850.  
  2851.    /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec,
  2852.     *
  2853.     * "It is legal to declare an array without a size and then
  2854.     *  later re-declare the same name as an array of the same
  2855.     *  type and specify a size."
  2856.     */
  2857.    if (earlier->type->is_unsized_array() && var->type->is_array()
  2858.        && (var->type->element_type() == earlier->type->element_type())) {
  2859.       /* FINISHME: This doesn't match the qualifiers on the two
  2860.        * FINISHME: declarations.  It's not 100% clear whether this is
  2861.        * FINISHME: required or not.
  2862.        */
  2863.  
  2864.       const unsigned size = unsigned(var->type->array_size());
  2865.       check_builtin_array_max_size(var->name, size, loc, state);
  2866.       if ((size > 0) && (size <= earlier->data.max_array_access)) {
  2867.          _mesa_glsl_error(& loc, state, "array size must be > %u due to "
  2868.                           "previous access",
  2869.                           earlier->data.max_array_access);
  2870.       }
  2871.  
  2872.       earlier->type = var->type;
  2873.       delete var;
  2874.       var = NULL;
  2875.    } else if ((state->ARB_fragment_coord_conventions_enable ||
  2876.               state->is_version(150, 0))
  2877.               && strcmp(var->name, "gl_FragCoord") == 0
  2878.               && earlier->type == var->type
  2879.               && earlier->data.mode == var->data.mode) {
  2880.       /* Allow redeclaration of gl_FragCoord for ARB_fcc layout
  2881.        * qualifiers.
  2882.        */
  2883.       earlier->data.origin_upper_left = var->data.origin_upper_left;
  2884.       earlier->data.pixel_center_integer = var->data.pixel_center_integer;
  2885.  
  2886.       /* According to section 4.3.7 of the GLSL 1.30 spec,
  2887.        * the following built-in varaibles can be redeclared with an
  2888.        * interpolation qualifier:
  2889.        *    * gl_FrontColor
  2890.        *    * gl_BackColor
  2891.        *    * gl_FrontSecondaryColor
  2892.        *    * gl_BackSecondaryColor
  2893.        *    * gl_Color
  2894.        *    * gl_SecondaryColor
  2895.        */
  2896.    } else if (state->is_version(130, 0)
  2897.               && (strcmp(var->name, "gl_FrontColor") == 0
  2898.                   || strcmp(var->name, "gl_BackColor") == 0
  2899.                   || strcmp(var->name, "gl_FrontSecondaryColor") == 0
  2900.                   || strcmp(var->name, "gl_BackSecondaryColor") == 0
  2901.                   || strcmp(var->name, "gl_Color") == 0
  2902.                   || strcmp(var->name, "gl_SecondaryColor") == 0)
  2903.               && earlier->type == var->type
  2904.               && earlier->data.mode == var->data.mode) {
  2905.       earlier->data.interpolation = var->data.interpolation;
  2906.  
  2907.       /* Layout qualifiers for gl_FragDepth. */
  2908.    } else if ((state->AMD_conservative_depth_enable ||
  2909.                state->ARB_conservative_depth_enable)
  2910.               && strcmp(var->name, "gl_FragDepth") == 0
  2911.               && earlier->type == var->type
  2912.               && earlier->data.mode == var->data.mode) {
  2913.  
  2914.       /** From the AMD_conservative_depth spec:
  2915.        *     Within any shader, the first redeclarations of gl_FragDepth
  2916.        *     must appear before any use of gl_FragDepth.
  2917.        */
  2918.       if (earlier->data.used) {
  2919.          _mesa_glsl_error(&loc, state,
  2920.                           "the first redeclaration of gl_FragDepth "
  2921.                           "must appear before any use of gl_FragDepth");
  2922.       }
  2923.  
  2924.       /* Prevent inconsistent redeclaration of depth layout qualifier. */
  2925.       if (earlier->data.depth_layout != ir_depth_layout_none
  2926.           && earlier->data.depth_layout != var->data.depth_layout) {
  2927.             _mesa_glsl_error(&loc, state,
  2928.                              "gl_FragDepth: depth layout is declared here "
  2929.                              "as '%s, but it was previously declared as "
  2930.                              "'%s'",
  2931.                              depth_layout_string(var->data.depth_layout),
  2932.                              depth_layout_string(earlier->data.depth_layout));
  2933.       }
  2934.  
  2935.       earlier->data.depth_layout = var->data.depth_layout;
  2936.  
  2937.    } else if (allow_all_redeclarations) {
  2938.       if (earlier->data.mode != var->data.mode) {
  2939.          _mesa_glsl_error(&loc, state,
  2940.                           "redeclaration of `%s' with incorrect qualifiers",
  2941.                           var->name);
  2942.       } else if (earlier->type != var->type) {
  2943.          _mesa_glsl_error(&loc, state,
  2944.                           "redeclaration of `%s' has incorrect type",
  2945.                           var->name);
  2946.       }
  2947.    } else {
  2948.       _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name);
  2949.    }
  2950.  
  2951.    return earlier;
  2952. }
  2953.  
  2954. /**
  2955.  * Generate the IR for an initializer in a variable declaration
  2956.  */
  2957. ir_rvalue *
  2958. process_initializer(ir_variable *var, ast_declaration *decl,
  2959.                     ast_fully_specified_type *type,
  2960.                     exec_list *initializer_instructions,
  2961.                     struct _mesa_glsl_parse_state *state)
  2962. {
  2963.    ir_rvalue *result = NULL;
  2964.  
  2965.    YYLTYPE initializer_loc = decl->initializer->get_location();
  2966.  
  2967.    /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:
  2968.     *
  2969.     *    "All uniform variables are read-only and are initialized either
  2970.     *    directly by an application via API commands, or indirectly by
  2971.     *    OpenGL."
  2972.     */
  2973.    if (var->data.mode == ir_var_uniform) {
  2974.       state->check_version(120, 0, &initializer_loc,
  2975.                            "cannot initialize uniforms");
  2976.    }
  2977.  
  2978.    /* From section 4.1.7 of the GLSL 4.40 spec:
  2979.     *
  2980.     *    "Opaque variables [...] are initialized only through the
  2981.     *     OpenGL API; they cannot be declared with an initializer in a
  2982.     *     shader."
  2983.     */
  2984.    if (var->type->contains_opaque()) {
  2985.       _mesa_glsl_error(& initializer_loc, state,
  2986.                        "cannot initialize opaque variable");
  2987.    }
  2988.  
  2989.    if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL)) {
  2990.       _mesa_glsl_error(& initializer_loc, state,
  2991.                        "cannot initialize %s shader input / %s",
  2992.                        _mesa_shader_stage_to_string(state->stage),
  2993.                        (state->stage == MESA_SHADER_VERTEX)
  2994.                        ? "attribute" : "varying");
  2995.    }
  2996.  
  2997.    /* If the initializer is an ast_aggregate_initializer, recursively store
  2998.     * type information from the LHS into it, so that its hir() function can do
  2999.     * type checking.
  3000.     */
  3001.    if (decl->initializer->oper == ast_aggregate)
  3002.       _mesa_ast_set_aggregate_type(var->type, decl->initializer);
  3003.  
  3004.    ir_dereference *const lhs = new(state) ir_dereference_variable(var);
  3005.    ir_rvalue *rhs = decl->initializer->hir(initializer_instructions, state);
  3006.  
  3007.    /* Calculate the constant value if this is a const or uniform
  3008.     * declaration.
  3009.     */
  3010.    if (type->qualifier.flags.q.constant
  3011.        || type->qualifier.flags.q.uniform) {
  3012.       ir_rvalue *new_rhs = validate_assignment(state, initializer_loc,
  3013.                                                var->type, rhs, true);
  3014.       if (new_rhs != NULL) {
  3015.          rhs = new_rhs;
  3016.  
  3017.          ir_constant *constant_value = rhs->constant_expression_value();
  3018.          if (!constant_value) {
  3019.             /* If ARB_shading_language_420pack is enabled, initializers of
  3020.              * const-qualified local variables do not have to be constant
  3021.              * expressions. Const-qualified global variables must still be
  3022.              * initialized with constant expressions.
  3023.              */
  3024.             if (!state->ARB_shading_language_420pack_enable
  3025.                 || state->current_function == NULL) {
  3026.                _mesa_glsl_error(& initializer_loc, state,
  3027.                                 "initializer of %s variable `%s' must be a "
  3028.                                 "constant expression",
  3029.                                 (type->qualifier.flags.q.constant)
  3030.                                 ? "const" : "uniform",
  3031.                                 decl->identifier);
  3032.                if (var->type->is_numeric()) {
  3033.                   /* Reduce cascading errors. */
  3034.                   var->constant_value = ir_constant::zero(state, var->type);
  3035.                }
  3036.             }
  3037.          } else {
  3038.             rhs = constant_value;
  3039.             var->constant_value = constant_value;
  3040.          }
  3041.       } else {
  3042.          if (var->type->is_numeric()) {
  3043.             /* Reduce cascading errors. */
  3044.             var->constant_value = ir_constant::zero(state, var->type);
  3045.          }
  3046.       }
  3047.    }
  3048.  
  3049.    if (rhs && !rhs->type->is_error()) {
  3050.       bool temp = var->data.read_only;
  3051.       if (type->qualifier.flags.q.constant)
  3052.          var->data.read_only = false;
  3053.  
  3054.       /* Never emit code to initialize a uniform.
  3055.        */
  3056.       const glsl_type *initializer_type;
  3057.       if (!type->qualifier.flags.q.uniform) {
  3058.          do_assignment(initializer_instructions, state,
  3059.                        NULL,
  3060.                        lhs, rhs,
  3061.                        &result, true,
  3062.                        true,
  3063.                        type->get_location());
  3064.          initializer_type = result->type;
  3065.       } else
  3066.          initializer_type = rhs->type;
  3067.  
  3068.       var->constant_initializer = rhs->constant_expression_value();
  3069.       var->data.has_initializer = true;
  3070.  
  3071.       /* If the declared variable is an unsized array, it must inherrit
  3072.        * its full type from the initializer.  A declaration such as
  3073.        *
  3074.        *     uniform float a[] = float[](1.0, 2.0, 3.0, 3.0);
  3075.        *
  3076.        * becomes
  3077.        *
  3078.        *     uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0);
  3079.        *
  3080.        * The assignment generated in the if-statement (below) will also
  3081.        * automatically handle this case for non-uniforms.
  3082.        *
  3083.        * If the declared variable is not an array, the types must
  3084.        * already match exactly.  As a result, the type assignment
  3085.        * here can be done unconditionally.  For non-uniforms the call
  3086.        * to do_assignment can change the type of the initializer (via
  3087.        * the implicit conversion rules).  For uniforms the initializer
  3088.        * must be a constant expression, and the type of that expression
  3089.        * was validated above.
  3090.        */
  3091.       var->type = initializer_type;
  3092.  
  3093.       var->data.read_only = temp;
  3094.    }
  3095.  
  3096.    return result;
  3097. }
  3098.  
  3099.  
  3100. /**
  3101.  * Do additional processing necessary for geometry shader input declarations
  3102.  * (this covers both interface blocks arrays and bare input variables).
  3103.  */
  3104. static void
  3105. handle_geometry_shader_input_decl(struct _mesa_glsl_parse_state *state,
  3106.                                   YYLTYPE loc, ir_variable *var)
  3107. {
  3108.    unsigned num_vertices = 0;
  3109.    if (state->gs_input_prim_type_specified) {
  3110.       num_vertices = vertices_per_prim(state->in_qualifier->prim_type);
  3111.    }
  3112.  
  3113.    /* Geometry shader input variables must be arrays.  Caller should have
  3114.     * reported an error for this.
  3115.     */
  3116.    if (!var->type->is_array()) {
  3117.       assert(state->error);
  3118.  
  3119.       /* To avoid cascading failures, short circuit the checks below. */
  3120.       return;
  3121.    }
  3122.  
  3123.    if (var->type->is_unsized_array()) {
  3124.       /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec says:
  3125.        *
  3126.        *   All geometry shader input unsized array declarations will be
  3127.        *   sized by an earlier input layout qualifier, when present, as per
  3128.        *   the following table.
  3129.        *
  3130.        * Followed by a table mapping each allowed input layout qualifier to
  3131.        * the corresponding input length.
  3132.        */
  3133.       if (num_vertices != 0)
  3134.          var->type = glsl_type::get_array_instance(var->type->fields.array,
  3135.                                                    num_vertices);
  3136.    } else {
  3137.       /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec
  3138.        * includes the following examples of compile-time errors:
  3139.        *
  3140.        *   // code sequence within one shader...
  3141.        *   in vec4 Color1[];    // size unknown
  3142.        *   ...Color1.length()...// illegal, length() unknown
  3143.        *   in vec4 Color2[2];   // size is 2
  3144.        *   ...Color1.length()...// illegal, Color1 still has no size
  3145.        *   in vec4 Color3[3];   // illegal, input sizes are inconsistent
  3146.        *   layout(lines) in;    // legal, input size is 2, matching
  3147.        *   in vec4 Color4[3];   // illegal, contradicts layout
  3148.        *   ...
  3149.        *
  3150.        * To detect the case illustrated by Color3, we verify that the size of
  3151.        * an explicitly-sized array matches the size of any previously declared
  3152.        * explicitly-sized array.  To detect the case illustrated by Color4, we
  3153.        * verify that the size of an explicitly-sized array is consistent with
  3154.        * any previously declared input layout.
  3155.        */
  3156.       if (num_vertices != 0 && var->type->length != num_vertices) {
  3157.          _mesa_glsl_error(&loc, state,
  3158.                           "geometry shader input size contradicts previously"
  3159.                           " declared layout (size is %u, but layout requires a"
  3160.                           " size of %u)", var->type->length, num_vertices);
  3161.       } else if (state->gs_input_size != 0 &&
  3162.                  var->type->length != state->gs_input_size) {
  3163.          _mesa_glsl_error(&loc, state,
  3164.                           "geometry shader input sizes are "
  3165.                           "inconsistent (size is %u, but a previous "
  3166.                           "declaration has size %u)",
  3167.                           var->type->length, state->gs_input_size);
  3168.       } else {
  3169.          state->gs_input_size = var->type->length;
  3170.       }
  3171.    }
  3172. }
  3173.  
  3174.  
  3175. void
  3176. validate_identifier(const char *identifier, YYLTYPE loc,
  3177.                     struct _mesa_glsl_parse_state *state)
  3178. {
  3179.    /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
  3180.     *
  3181.     *   "Identifiers starting with "gl_" are reserved for use by
  3182.     *   OpenGL, and may not be declared in a shader as either a
  3183.     *   variable or a function."
  3184.     */
  3185.    if (is_gl_identifier(identifier)) {
  3186.       _mesa_glsl_error(&loc, state,
  3187.                        "identifier `%s' uses reserved `gl_' prefix",
  3188.                        identifier);
  3189.    } else if (strstr(identifier, "__")) {
  3190.       /* From page 14 (page 20 of the PDF) of the GLSL 1.10
  3191.        * spec:
  3192.        *
  3193.        *     "In addition, all identifiers containing two
  3194.        *      consecutive underscores (__) are reserved as
  3195.        *      possible future keywords."
  3196.        *
  3197.        * The intention is that names containing __ are reserved for internal
  3198.        * use by the implementation, and names prefixed with GL_ are reserved
  3199.        * for use by Khronos.  Names simply containing __ are dangerous to use,
  3200.        * but should be allowed.
  3201.        *
  3202.        * A future version of the GLSL specification will clarify this.
  3203.        */
  3204.       _mesa_glsl_warning(&loc, state,
  3205.                          "identifier `%s' uses reserved `__' string",
  3206.                          identifier);
  3207.    }
  3208. }
  3209.  
  3210. static bool
  3211. precision_qualifier_allowed(const glsl_type *type)
  3212. {
  3213.    /* Precision qualifiers apply to floating point, integer and sampler
  3214.     * types.
  3215.     *
  3216.     * Section 4.5.2 (Precision Qualifiers) of the GLSL 1.30 spec says:
  3217.     *    "Any floating point or any integer declaration can have the type
  3218.     *    preceded by one of these precision qualifiers [...] Literal
  3219.     *    constants do not have precision qualifiers. Neither do Boolean
  3220.     *    variables.
  3221.     *
  3222.     * Section 4.5 (Precision and Precision Qualifiers) of the GLSL 1.30
  3223.     * spec also says:
  3224.     *
  3225.     *     "Precision qualifiers are added for code portability with OpenGL
  3226.     *     ES, not for functionality. They have the same syntax as in OpenGL
  3227.     *     ES."
  3228.     *
  3229.     * Section 8 (Built-In Functions) of the GLSL ES 1.00 spec says:
  3230.     *
  3231.     *     "uniform lowp sampler2D sampler;
  3232.     *     highp vec2 coord;
  3233.     *     ...
  3234.     *     lowp vec4 col = texture2D (sampler, coord);
  3235.     *                                            // texture2D returns lowp"
  3236.     *
  3237.     * From this, we infer that GLSL 1.30 (and later) should allow precision
  3238.     * qualifiers on sampler types just like float and integer types.
  3239.     */
  3240.    return type->is_float()
  3241.        || type->is_integer()
  3242.        || type->is_record()
  3243.        || type->is_sampler();
  3244. }
  3245.  
  3246. ir_rvalue *
  3247. ast_declarator_list::hir(exec_list *instructions,
  3248.                          struct _mesa_glsl_parse_state *state)
  3249. {
  3250.    void *ctx = state;
  3251.    const struct glsl_type *decl_type;
  3252.    const char *type_name = NULL;
  3253.    ir_rvalue *result = NULL;
  3254.    YYLTYPE loc = this->get_location();
  3255.  
  3256.    /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec:
  3257.     *
  3258.     *     "To ensure that a particular output variable is invariant, it is
  3259.     *     necessary to use the invariant qualifier. It can either be used to
  3260.     *     qualify a previously declared variable as being invariant
  3261.     *
  3262.     *         invariant gl_Position; // make existing gl_Position be invariant"
  3263.     *
  3264.     * In these cases the parser will set the 'invariant' flag in the declarator
  3265.     * list, and the type will be NULL.
  3266.     */
  3267.    if (this->invariant) {
  3268.       assert(this->type == NULL);
  3269.  
  3270.       if (state->current_function != NULL) {
  3271.          _mesa_glsl_error(& loc, state,
  3272.                           "all uses of `invariant' keyword must be at global "
  3273.                           "scope");
  3274.       }
  3275.  
  3276.       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
  3277.          assert(decl->array_specifier == NULL);
  3278.          assert(decl->initializer == NULL);
  3279.  
  3280.          ir_variable *const earlier =
  3281.             state->symbols->get_variable(decl->identifier);
  3282.          if (earlier == NULL) {
  3283.             _mesa_glsl_error(& loc, state,
  3284.                              "undeclared variable `%s' cannot be marked "
  3285.                              "invariant", decl->identifier);
  3286.          } else if (!is_varying_var(earlier, state->stage)) {
  3287.             _mesa_glsl_error(&loc, state,
  3288.                              "`%s' cannot be marked invariant; interfaces between "
  3289.                              "shader stages only.", decl->identifier);
  3290.          } else if (earlier->data.used) {
  3291.             _mesa_glsl_error(& loc, state,
  3292.                             "variable `%s' may not be redeclared "
  3293.                             "`invariant' after being used",
  3294.                             earlier->name);
  3295.          } else {
  3296.             earlier->data.invariant = true;
  3297.          }
  3298.       }
  3299.  
  3300.       /* Invariant redeclarations do not have r-values.
  3301.        */
  3302.       return NULL;
  3303.    }
  3304.  
  3305.    if (this->precise) {
  3306.       assert(this->type == NULL);
  3307.  
  3308.       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
  3309.          assert(decl->array_specifier == NULL);
  3310.          assert(decl->initializer == NULL);
  3311.  
  3312.          ir_variable *const earlier =
  3313.             state->symbols->get_variable(decl->identifier);
  3314.          if (earlier == NULL) {
  3315.             _mesa_glsl_error(& loc, state,
  3316.                              "undeclared variable `%s' cannot be marked "
  3317.                              "precise", decl->identifier);
  3318.          } else if (state->current_function != NULL &&
  3319.                     !state->symbols->name_declared_this_scope(decl->identifier)) {
  3320.             /* Note: we have to check if we're in a function, since
  3321.              * builtins are treated as having come from another scope.
  3322.              */
  3323.             _mesa_glsl_error(& loc, state,
  3324.                              "variable `%s' from an outer scope may not be "
  3325.                              "redeclared `precise' in this scope",
  3326.                              earlier->name);
  3327.          } else if (earlier->data.used) {
  3328.             _mesa_glsl_error(& loc, state,
  3329.                              "variable `%s' may not be redeclared "
  3330.                              "`precise' after being used",
  3331.                              earlier->name);
  3332.          } else {
  3333.             earlier->data.precise = true;
  3334.          }
  3335.       }
  3336.  
  3337.       /* Precise redeclarations do not have r-values either. */
  3338.       return NULL;
  3339.    }
  3340.  
  3341.    assert(this->type != NULL);
  3342.    assert(!this->invariant);
  3343.    assert(!this->precise);
  3344.  
  3345.    /* The type specifier may contain a structure definition.  Process that
  3346.     * before any of the variable declarations.
  3347.     */
  3348.    (void) this->type->specifier->hir(instructions, state);
  3349.  
  3350.    decl_type = this->type->glsl_type(& type_name, state);
  3351.  
  3352.    /* An offset-qualified atomic counter declaration sets the default
  3353.     * offset for the next declaration within the same atomic counter
  3354.     * buffer.
  3355.     */
  3356.    if (decl_type && decl_type->contains_atomic()) {
  3357.       if (type->qualifier.flags.q.explicit_binding &&
  3358.           type->qualifier.flags.q.explicit_offset)
  3359.          state->atomic_counter_offsets[type->qualifier.binding] =
  3360.             type->qualifier.offset;
  3361.    }
  3362.  
  3363.    if (this->declarations.is_empty()) {
  3364.       /* If there is no structure involved in the program text, there are two
  3365.        * possible scenarios:
  3366.        *
  3367.        * - The program text contained something like 'vec4;'.  This is an
  3368.        *   empty declaration.  It is valid but weird.  Emit a warning.
  3369.        *
  3370.        * - The program text contained something like 'S;' and 'S' is not the
  3371.        *   name of a known structure type.  This is both invalid and weird.
  3372.        *   Emit an error.
  3373.        *
  3374.        * - The program text contained something like 'mediump float;'
  3375.        *   when the programmer probably meant 'precision mediump
  3376.        *   float;' Emit a warning with a description of what they
  3377.        *   probably meant to do.
  3378.        *
  3379.        * Note that if decl_type is NULL and there is a structure involved,
  3380.        * there must have been some sort of error with the structure.  In this
  3381.        * case we assume that an error was already generated on this line of
  3382.        * code for the structure.  There is no need to generate an additional,
  3383.        * confusing error.
  3384.        */
  3385.       assert(this->type->specifier->structure == NULL || decl_type != NULL
  3386.              || state->error);
  3387.  
  3388.       if (decl_type == NULL) {
  3389.          _mesa_glsl_error(&loc, state,
  3390.                           "invalid type `%s' in empty declaration",
  3391.                           type_name);
  3392.       } else if (decl_type->base_type == GLSL_TYPE_ATOMIC_UINT) {
  3393.          /* Empty atomic counter declarations are allowed and useful
  3394.           * to set the default offset qualifier.
  3395.           */
  3396.          return NULL;
  3397.       } else if (this->type->qualifier.precision != ast_precision_none) {
  3398.          if (this->type->specifier->structure != NULL) {
  3399.             _mesa_glsl_error(&loc, state,
  3400.                              "precision qualifiers can't be applied "
  3401.                              "to structures");
  3402.          } else {
  3403.             static const char *const precision_names[] = {
  3404.                "highp",
  3405.                "highp",
  3406.                "mediump",
  3407.                "lowp"
  3408.             };
  3409.  
  3410.             _mesa_glsl_warning(&loc, state,
  3411.                                "empty declaration with precision qualifier, "
  3412.                                "to set the default precision, use "
  3413.                                "`precision %s %s;'",
  3414.                                precision_names[this->type->qualifier.precision],
  3415.                                type_name);
  3416.          }
  3417.       } else if (this->type->specifier->structure == NULL) {
  3418.          _mesa_glsl_warning(&loc, state, "empty declaration");
  3419.       }
  3420.    }
  3421.  
  3422.    foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
  3423.       const struct glsl_type *var_type;
  3424.       ir_variable *var;
  3425.  
  3426.       /* FINISHME: Emit a warning if a variable declaration shadows a
  3427.        * FINISHME: declaration at a higher scope.
  3428.        */
  3429.  
  3430.       if ((decl_type == NULL) || decl_type->is_void()) {
  3431.          if (type_name != NULL) {
  3432.             _mesa_glsl_error(& loc, state,
  3433.                              "invalid type `%s' in declaration of `%s'",
  3434.                              type_name, decl->identifier);
  3435.          } else {
  3436.             _mesa_glsl_error(& loc, state,
  3437.                              "invalid type in declaration of `%s'",
  3438.                              decl->identifier);
  3439.          }
  3440.          continue;
  3441.       }
  3442.  
  3443.       var_type = process_array_type(&loc, decl_type, decl->array_specifier,
  3444.                                     state);
  3445.  
  3446.       var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto);
  3447.  
  3448.       /* The 'varying in' and 'varying out' qualifiers can only be used with
  3449.        * ARB_geometry_shader4 and EXT_geometry_shader4, which we don't support
  3450.        * yet.
  3451.        */
  3452.       if (this->type->qualifier.flags.q.varying) {
  3453.          if (this->type->qualifier.flags.q.in) {
  3454.             _mesa_glsl_error(& loc, state,
  3455.                              "`varying in' qualifier in declaration of "
  3456.                              "`%s' only valid for geometry shaders using "
  3457.                              "ARB_geometry_shader4 or EXT_geometry_shader4",
  3458.                              decl->identifier);
  3459.          } else if (this->type->qualifier.flags.q.out) {
  3460.             _mesa_glsl_error(& loc, state,
  3461.                              "`varying out' qualifier in declaration of "
  3462.                              "`%s' only valid for geometry shaders using "
  3463.                              "ARB_geometry_shader4 or EXT_geometry_shader4",
  3464.                              decl->identifier);
  3465.          }
  3466.       }
  3467.  
  3468.       /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
  3469.        *
  3470.        *     "Global variables can only use the qualifiers const,
  3471.        *     attribute, uniform, or varying. Only one may be
  3472.        *     specified.
  3473.        *
  3474.        *     Local variables can only use the qualifier const."
  3475.        *
  3476.        * This is relaxed in GLSL 1.30 and GLSL ES 3.00.  It is also relaxed by
  3477.        * any extension that adds the 'layout' keyword.
  3478.        */
  3479.       if (!state->is_version(130, 300)
  3480.           && !state->has_explicit_attrib_location()
  3481.           && !state->has_separate_shader_objects()
  3482.           && !state->ARB_fragment_coord_conventions_enable) {
  3483.          if (this->type->qualifier.flags.q.out) {
  3484.             _mesa_glsl_error(& loc, state,
  3485.                              "`out' qualifier in declaration of `%s' "
  3486.                              "only valid for function parameters in %s",
  3487.                              decl->identifier, state->get_version_string());
  3488.          }
  3489.          if (this->type->qualifier.flags.q.in) {
  3490.             _mesa_glsl_error(& loc, state,
  3491.                              "`in' qualifier in declaration of `%s' "
  3492.                              "only valid for function parameters in %s",
  3493.                              decl->identifier, state->get_version_string());
  3494.          }
  3495.          /* FINISHME: Test for other invalid qualifiers. */
  3496.       }
  3497.  
  3498.       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
  3499.                                        & loc, false);
  3500.  
  3501.       if (this->type->qualifier.flags.q.invariant) {
  3502.          if (!is_varying_var(var, state->stage)) {
  3503.             _mesa_glsl_error(&loc, state,
  3504.                              "`%s' cannot be marked invariant; interfaces between "
  3505.                              "shader stages only", var->name);
  3506.          }
  3507.       }
  3508.  
  3509.       if (state->current_function != NULL) {
  3510.          const char *mode = NULL;
  3511.          const char *extra = "";
  3512.  
  3513.          /* There is no need to check for 'inout' here because the parser will
  3514.           * only allow that in function parameter lists.
  3515.           */
  3516.          if (this->type->qualifier.flags.q.attribute) {
  3517.             mode = "attribute";
  3518.          } else if (this->type->qualifier.flags.q.uniform) {
  3519.             mode = "uniform";
  3520.          } else if (this->type->qualifier.flags.q.varying) {
  3521.             mode = "varying";
  3522.          } else if (this->type->qualifier.flags.q.in) {
  3523.             mode = "in";
  3524.             extra = " or in function parameter list";
  3525.          } else if (this->type->qualifier.flags.q.out) {
  3526.             mode = "out";
  3527.             extra = " or in function parameter list";
  3528.          }
  3529.  
  3530.          if (mode) {
  3531.             _mesa_glsl_error(& loc, state,
  3532.                              "%s variable `%s' must be declared at "
  3533.                              "global scope%s",
  3534.                              mode, var->name, extra);
  3535.          }
  3536.       } else if (var->data.mode == ir_var_shader_in) {
  3537.          var->data.read_only = true;
  3538.  
  3539.          if (state->stage == MESA_SHADER_VERTEX) {
  3540.             bool error_emitted = false;
  3541.  
  3542.             /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
  3543.              *
  3544.              *    "Vertex shader inputs can only be float, floating-point
  3545.              *    vectors, matrices, signed and unsigned integers and integer
  3546.              *    vectors. Vertex shader inputs can also form arrays of these
  3547.              *    types, but not structures."
  3548.              *
  3549.              * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
  3550.              *
  3551.              *    "Vertex shader inputs can only be float, floating-point
  3552.              *    vectors, matrices, signed and unsigned integers and integer
  3553.              *    vectors. They cannot be arrays or structures."
  3554.              *
  3555.              * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
  3556.              *
  3557.              *    "The attribute qualifier can be used only with float,
  3558.              *    floating-point vectors, and matrices. Attribute variables
  3559.              *    cannot be declared as arrays or structures."
  3560.              *
  3561.              * From page 33 (page 39 of the PDF) of the GLSL ES 3.00 spec:
  3562.              *
  3563.              *    "Vertex shader inputs can only be float, floating-point
  3564.              *    vectors, matrices, signed and unsigned integers and integer
  3565.              *    vectors. Vertex shader inputs cannot be arrays or
  3566.              *    structures."
  3567.              */
  3568.             const glsl_type *check_type = var->type->without_array();
  3569.  
  3570.             switch (check_type->base_type) {
  3571.             case GLSL_TYPE_FLOAT:
  3572.             break;
  3573.             case GLSL_TYPE_UINT:
  3574.             case GLSL_TYPE_INT:
  3575.                if (state->is_version(120, 300))
  3576.                   break;
  3577.             case GLSL_TYPE_DOUBLE:
  3578.                if (check_type->base_type == GLSL_TYPE_DOUBLE && (state->is_version(410, 0) || state->ARB_vertex_attrib_64bit_enable))
  3579.                   break;
  3580.             /* FALLTHROUGH */
  3581.             default:
  3582.                _mesa_glsl_error(& loc, state,
  3583.                                 "vertex shader input / attribute cannot have "
  3584.                                 "type %s`%s'",
  3585.                                 var->type->is_array() ? "array of " : "",
  3586.                                 check_type->name);
  3587.                error_emitted = true;
  3588.             }
  3589.  
  3590.             if (!error_emitted && var->type->is_array() &&
  3591.                 !state->check_version(150, 0, &loc,
  3592.                                       "vertex shader input / attribute "
  3593.                                       "cannot have array type")) {
  3594.                error_emitted = true;
  3595.             }
  3596.          } else if (state->stage == MESA_SHADER_GEOMETRY) {
  3597.             /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
  3598.              *
  3599.              *     Geometry shader input variables get the per-vertex values
  3600.              *     written out by vertex shader output variables of the same
  3601.              *     names. Since a geometry shader operates on a set of
  3602.              *     vertices, each input varying variable (or input block, see
  3603.              *     interface blocks below) needs to be declared as an array.
  3604.              */
  3605.             if (!var->type->is_array()) {
  3606.                _mesa_glsl_error(&loc, state,
  3607.                                 "geometry shader inputs must be arrays");
  3608.             }
  3609.  
  3610.             handle_geometry_shader_input_decl(state, loc, var);
  3611.          }
  3612.       } else if (var->data.mode == ir_var_shader_out) {
  3613.          const glsl_type *check_type = var->type->without_array();
  3614.  
  3615.          /* From section 4.3.6 (Output variables) of the GLSL 4.40 spec:
  3616.           *
  3617.           *     It is a compile-time error to declare a vertex, tessellation
  3618.           *     evaluation, tessellation control, or geometry shader output
  3619.           *     that contains any of the following:
  3620.           *
  3621.           *     * A Boolean type (bool, bvec2 ...)
  3622.           *     * An opaque type
  3623.           */
  3624.          if (check_type->is_boolean() || check_type->contains_opaque())
  3625.             _mesa_glsl_error(&loc, state,
  3626.                              "%s shader output cannot have type %s",
  3627.                              _mesa_shader_stage_to_string(state->stage),
  3628.                              check_type->name);
  3629.  
  3630.          /* From section 4.3.6 (Output variables) of the GLSL 4.40 spec:
  3631.           *
  3632.           *     It is a compile-time error to declare a fragment shader output
  3633.           *     that contains any of the following:
  3634.           *
  3635.           *     * A Boolean type (bool, bvec2 ...)
  3636.           *     * A double-precision scalar or vector (double, dvec2 ...)
  3637.           *     * An opaque type
  3638.           *     * Any matrix type
  3639.           *     * A structure
  3640.           */
  3641.          if (state->stage == MESA_SHADER_FRAGMENT) {
  3642.             if (check_type->is_record() || check_type->is_matrix())
  3643.                _mesa_glsl_error(&loc, state,
  3644.                                 "fragment shader output "
  3645.                                 "cannot have struct or array type");
  3646.             switch (check_type->base_type) {
  3647.             case GLSL_TYPE_UINT:
  3648.             case GLSL_TYPE_INT:
  3649.             case GLSL_TYPE_FLOAT:
  3650.                break;
  3651.             default:
  3652.                _mesa_glsl_error(&loc, state,
  3653.                                 "fragment shader output cannot have "
  3654.                                 "type %s", check_type->name);
  3655.             }
  3656.          }
  3657.       }
  3658.  
  3659.       /* Integer fragment inputs must be qualified with 'flat'.  In GLSL ES,
  3660.        * so must integer vertex outputs.
  3661.        *
  3662.        * From section 4.3.4 ("Inputs") of the GLSL 1.50 spec:
  3663.        *    "Fragment shader inputs that are signed or unsigned integers or
  3664.        *    integer vectors must be qualified with the interpolation qualifier
  3665.        *    flat."
  3666.        *
  3667.        * From section 4.3.4 ("Input Variables") of the GLSL 3.00 ES spec:
  3668.        *    "Fragment shader inputs that are, or contain, signed or unsigned
  3669.        *    integers or integer vectors must be qualified with the
  3670.        *    interpolation qualifier flat."
  3671.        *
  3672.        * From section 4.3.6 ("Output Variables") of the GLSL 3.00 ES spec:
  3673.        *    "Vertex shader outputs that are, or contain, signed or unsigned
  3674.        *    integers or integer vectors must be qualified with the
  3675.        *    interpolation qualifier flat."
  3676.        *
  3677.        * Note that prior to GLSL 1.50, this requirement applied to vertex
  3678.        * outputs rather than fragment inputs.  That creates problems in the
  3679.        * presence of geometry shaders, so we adopt the GLSL 1.50 rule for all
  3680.        * desktop GL shaders.  For GLSL ES shaders, we follow the spec and
  3681.        * apply the restriction to both vertex outputs and fragment inputs.
  3682.        *
  3683.        * Note also that the desktop GLSL specs are missing the text "or
  3684.        * contain"; this is presumably an oversight, since there is no
  3685.        * reasonable way to interpolate a fragment shader input that contains
  3686.        * an integer.
  3687.        */
  3688.       if (state->is_version(130, 300) &&
  3689.           var->type->contains_integer() &&
  3690.           var->data.interpolation != INTERP_QUALIFIER_FLAT &&
  3691.           ((state->stage == MESA_SHADER_FRAGMENT && var->data.mode == ir_var_shader_in)
  3692.            || (state->stage == MESA_SHADER_VERTEX && var->data.mode == ir_var_shader_out
  3693.                && state->es_shader))) {
  3694.          const char *var_type = (state->stage == MESA_SHADER_VERTEX) ?
  3695.             "vertex output" : "fragment input";
  3696.          _mesa_glsl_error(&loc, state, "if a %s is (or contains) "
  3697.                           "an integer, then it must be qualified with 'flat'",
  3698.                           var_type);
  3699.       }
  3700.  
  3701.       /* Double fragment inputs must be qualified with 'flat'. */
  3702.       if (var->type->contains_double() &&
  3703.           var->data.interpolation != INTERP_QUALIFIER_FLAT &&
  3704.           state->stage == MESA_SHADER_FRAGMENT &&
  3705.           var->data.mode == ir_var_shader_in) {
  3706.          _mesa_glsl_error(&loc, state, "if a fragment input is (or contains) "
  3707.                           "a double, then it must be qualified with 'flat'",
  3708.                           var_type);
  3709.       }
  3710.  
  3711.       /* Interpolation qualifiers cannot be applied to 'centroid' and
  3712.        * 'centroid varying'.
  3713.        *
  3714.        * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:
  3715.        *    "interpolation qualifiers may only precede the qualifiers in,
  3716.        *    centroid in, out, or centroid out in a declaration. They do not apply
  3717.        *    to the deprecated storage qualifiers varying or centroid varying."
  3718.        *
  3719.        * These deprecated storage qualifiers do not exist in GLSL ES 3.00.
  3720.        */
  3721.       if (state->is_version(130, 0)
  3722.           && this->type->qualifier.has_interpolation()
  3723.           && this->type->qualifier.flags.q.varying) {
  3724.  
  3725.          const char *i = this->type->qualifier.interpolation_string();
  3726.          assert(i != NULL);
  3727.          const char *s;
  3728.          if (this->type->qualifier.flags.q.centroid)
  3729.             s = "centroid varying";
  3730.          else
  3731.             s = "varying";
  3732.  
  3733.          _mesa_glsl_error(&loc, state,
  3734.                           "qualifier '%s' cannot be applied to the "
  3735.                           "deprecated storage qualifier '%s'", i, s);
  3736.       }
  3737.  
  3738.  
  3739.       /* Interpolation qualifiers can only apply to vertex shader outputs and
  3740.        * fragment shader inputs.
  3741.        *
  3742.        * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec:
  3743.        *    "Outputs from a vertex shader (out) and inputs to a fragment
  3744.        *    shader (in) can be further qualified with one or more of these
  3745.        *    interpolation qualifiers"
  3746.        *
  3747.        * From page 31 (page 37 of the PDF) of the GLSL ES 3.00 spec:
  3748.        *    "These interpolation qualifiers may only precede the qualifiers
  3749.        *    in, centroid in, out, or centroid out in a declaration. They do
  3750.        *    not apply to inputs into a vertex shader or outputs from a
  3751.        *    fragment shader."
  3752.        */
  3753.       if (state->is_version(130, 300)
  3754.           && this->type->qualifier.has_interpolation()) {
  3755.  
  3756.          const char *i = this->type->qualifier.interpolation_string();
  3757.          assert(i != NULL);
  3758.  
  3759.          switch (state->stage) {
  3760.          case MESA_SHADER_VERTEX:
  3761.             if (this->type->qualifier.flags.q.in) {
  3762.                _mesa_glsl_error(&loc, state,
  3763.                                 "qualifier '%s' cannot be applied to vertex "
  3764.                                 "shader inputs", i);
  3765.             }
  3766.             break;
  3767.          case MESA_SHADER_FRAGMENT:
  3768.             if (this->type->qualifier.flags.q.out) {
  3769.                _mesa_glsl_error(&loc, state,
  3770.                                 "qualifier '%s' cannot be applied to fragment "
  3771.                                 "shader outputs", i);
  3772.             }
  3773.             break;
  3774.          default:
  3775.             break;
  3776.          }
  3777.       }
  3778.  
  3779.  
  3780.       /* Precision qualifiers exists only in GLSL versions 1.00 and >= 1.30.
  3781.        */
  3782.       if (this->type->qualifier.precision != ast_precision_none) {
  3783.          state->check_precision_qualifiers_allowed(&loc);
  3784.       }
  3785.  
  3786.  
  3787.       /* If a precision qualifier is allowed on a type, it is allowed on
  3788.        * an array of that type.
  3789.        */
  3790.       if (!(this->type->qualifier.precision == ast_precision_none
  3791.           || precision_qualifier_allowed(var->type)
  3792.           || (var->type->is_array()
  3793.               && precision_qualifier_allowed(var->type->fields.array)))) {
  3794.  
  3795.          _mesa_glsl_error(&loc, state,
  3796.                           "precision qualifiers apply only to floating point"
  3797.                           ", integer and sampler types");
  3798.       }
  3799.  
  3800.       /* From section 4.1.7 of the GLSL 4.40 spec:
  3801.        *
  3802.        *    "[Opaque types] can only be declared as function
  3803.        *     parameters or uniform-qualified variables."
  3804.        */
  3805.       if (var_type->contains_opaque() &&
  3806.           !this->type->qualifier.flags.q.uniform) {
  3807.          _mesa_glsl_error(&loc, state,
  3808.                           "opaque variables must be declared uniform");
  3809.       }
  3810.  
  3811.       /* Process the initializer and add its instructions to a temporary
  3812.        * list.  This list will be added to the instruction stream (below) after
  3813.        * the declaration is added.  This is done because in some cases (such as
  3814.        * redeclarations) the declaration may not actually be added to the
  3815.        * instruction stream.
  3816.        */
  3817.       exec_list initializer_instructions;
  3818.  
  3819.       /* Examine var name here since var may get deleted in the next call */
  3820.       bool var_is_gl_id = is_gl_identifier(var->name);
  3821.  
  3822.       ir_variable *earlier =
  3823.          get_variable_being_redeclared(var, decl->get_location(), state,
  3824.                                        false /* allow_all_redeclarations */);
  3825.       if (earlier != NULL) {
  3826.          if (var_is_gl_id &&
  3827.              earlier->data.how_declared == ir_var_declared_in_block) {
  3828.             _mesa_glsl_error(&loc, state,
  3829.                              "`%s' has already been redeclared using "
  3830.                              "gl_PerVertex", earlier->name);
  3831.          }
  3832.          earlier->data.how_declared = ir_var_declared_normally;
  3833.       }
  3834.  
  3835.       if (decl->initializer != NULL) {
  3836.          result = process_initializer((earlier == NULL) ? var : earlier,
  3837.                                       decl, this->type,
  3838.                                       &initializer_instructions, state);
  3839.       }
  3840.  
  3841.       /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:
  3842.        *
  3843.        *     "It is an error to write to a const variable outside of
  3844.        *      its declaration, so they must be initialized when
  3845.        *      declared."
  3846.        */
  3847.       if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {
  3848.          _mesa_glsl_error(& loc, state,
  3849.                           "const declaration of `%s' must be initialized",
  3850.                           decl->identifier);
  3851.       }
  3852.  
  3853.       if (state->es_shader) {
  3854.          const glsl_type *const t = (earlier == NULL)
  3855.             ? var->type : earlier->type;
  3856.  
  3857.          if (t->is_unsized_array())
  3858.             /* Section 10.17 of the GLSL ES 1.00 specification states that
  3859.              * unsized array declarations have been removed from the language.
  3860.              * Arrays that are sized using an initializer are still explicitly
  3861.              * sized.  However, GLSL ES 1.00 does not allow array
  3862.              * initializers.  That is only allowed in GLSL ES 3.00.
  3863.              *
  3864.              * Section 4.1.9 (Arrays) of the GLSL ES 3.00 spec says:
  3865.              *
  3866.              *     "An array type can also be formed without specifying a size
  3867.              *     if the definition includes an initializer:
  3868.              *
  3869.              *         float x[] = float[2] (1.0, 2.0);     // declares an array of size 2
  3870.              *         float y[] = float[] (1.0, 2.0, 3.0); // declares an array of size 3
  3871.              *
  3872.              *         float a[5];
  3873.              *         float b[] = a;"
  3874.              */
  3875.             _mesa_glsl_error(& loc, state,
  3876.                              "unsized array declarations are not allowed in "
  3877.                              "GLSL ES");
  3878.       }
  3879.  
  3880.       /* If the declaration is not a redeclaration, there are a few additional
  3881.        * semantic checks that must be applied.  In addition, variable that was
  3882.        * created for the declaration should be added to the IR stream.
  3883.        */
  3884.       if (earlier == NULL) {
  3885.          validate_identifier(decl->identifier, loc, state);
  3886.  
  3887.          /* Add the variable to the symbol table.  Note that the initializer's
  3888.           * IR was already processed earlier (though it hasn't been emitted
  3889.           * yet), without the variable in scope.
  3890.           *
  3891.           * This differs from most C-like languages, but it follows the GLSL
  3892.           * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50
  3893.           * spec:
  3894.           *
  3895.           *     "Within a declaration, the scope of a name starts immediately
  3896.           *     after the initializer if present or immediately after the name
  3897.           *     being declared if not."
  3898.           */
  3899.          if (!state->symbols->add_variable(var)) {
  3900.             YYLTYPE loc = this->get_location();
  3901.             _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
  3902.                              "current scope", decl->identifier);
  3903.             continue;
  3904.          }
  3905.  
  3906.          /* Push the variable declaration to the top.  It means that all the
  3907.           * variable declarations will appear in a funny last-to-first order,
  3908.           * but otherwise we run into trouble if a function is prototyped, a
  3909.           * global var is decled, then the function is defined with usage of
  3910.           * the global var.  See glslparsertest's CorrectModule.frag.
  3911.           */
  3912.          instructions->push_head(var);
  3913.       }
  3914.  
  3915.       instructions->append_list(&initializer_instructions);
  3916.    }
  3917.  
  3918.  
  3919.    /* Generally, variable declarations do not have r-values.  However,
  3920.     * one is used for the declaration in
  3921.     *
  3922.     * while (bool b = some_condition()) {
  3923.     *   ...
  3924.     * }
  3925.     *
  3926.     * so we return the rvalue from the last seen declaration here.
  3927.     */
  3928.    return result;
  3929. }
  3930.  
  3931.  
  3932. ir_rvalue *
  3933. ast_parameter_declarator::hir(exec_list *instructions,
  3934.                               struct _mesa_glsl_parse_state *state)
  3935. {
  3936.    void *ctx = state;
  3937.    const struct glsl_type *type;
  3938.    const char *name = NULL;
  3939.    YYLTYPE loc = this->get_location();
  3940.  
  3941.    type = this->type->glsl_type(& name, state);
  3942.  
  3943.    if (type == NULL) {
  3944.       if (name != NULL) {
  3945.          _mesa_glsl_error(& loc, state,
  3946.                           "invalid type `%s' in declaration of `%s'",
  3947.                           name, this->identifier);
  3948.       } else {
  3949.          _mesa_glsl_error(& loc, state,
  3950.                           "invalid type in declaration of `%s'",
  3951.                           this->identifier);
  3952.       }
  3953.  
  3954.       type = glsl_type::error_type;
  3955.    }
  3956.  
  3957.    /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec:
  3958.     *
  3959.     *    "Functions that accept no input arguments need not use void in the
  3960.     *    argument list because prototypes (or definitions) are required and
  3961.     *    therefore there is no ambiguity when an empty argument list "( )" is
  3962.     *    declared. The idiom "(void)" as a parameter list is provided for
  3963.     *    convenience."
  3964.     *
  3965.     * Placing this check here prevents a void parameter being set up
  3966.     * for a function, which avoids tripping up checks for main taking
  3967.     * parameters and lookups of an unnamed symbol.
  3968.     */
  3969.    if (type->is_void()) {
  3970.       if (this->identifier != NULL)
  3971.          _mesa_glsl_error(& loc, state,
  3972.                           "named parameter cannot have type `void'");
  3973.  
  3974.       is_void = true;
  3975.       return NULL;
  3976.    }
  3977.  
  3978.    if (formal_parameter && (this->identifier == NULL)) {
  3979.       _mesa_glsl_error(& loc, state, "formal parameter lacks a name");
  3980.       return NULL;
  3981.    }
  3982.  
  3983.    /* This only handles "vec4 foo[..]".  The earlier specifier->glsl_type(...)
  3984.     * call already handled the "vec4[..] foo" case.
  3985.     */
  3986.    type = process_array_type(&loc, type, this->array_specifier, state);
  3987.  
  3988.    if (!type->is_error() && type->is_unsized_array()) {
  3989.       _mesa_glsl_error(&loc, state, "arrays passed as parameters must have "
  3990.                        "a declared size");
  3991.       type = glsl_type::error_type;
  3992.    }
  3993.  
  3994.    is_void = false;
  3995.    ir_variable *var = new(ctx)
  3996.       ir_variable(type, this->identifier, ir_var_function_in);
  3997.  
  3998.    /* Apply any specified qualifiers to the parameter declaration.  Note that
  3999.     * for function parameters the default mode is 'in'.
  4000.     */
  4001.    apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc,
  4002.                                     true);
  4003.  
  4004.    /* From section 4.1.7 of the GLSL 4.40 spec:
  4005.     *
  4006.     *   "Opaque variables cannot be treated as l-values; hence cannot
  4007.     *    be used as out or inout function parameters, nor can they be
  4008.     *    assigned into."
  4009.     */
  4010.    if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out)
  4011.        && type->contains_opaque()) {
  4012.       _mesa_glsl_error(&loc, state, "out and inout parameters cannot "
  4013.                        "contain opaque variables");
  4014.       type = glsl_type::error_type;
  4015.    }
  4016.  
  4017.    /* From page 39 (page 45 of the PDF) of the GLSL 1.10 spec:
  4018.     *
  4019.     *    "When calling a function, expressions that do not evaluate to
  4020.     *     l-values cannot be passed to parameters declared as out or inout."
  4021.     *
  4022.     * From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
  4023.     *
  4024.     *    "Other binary or unary expressions, non-dereferenced arrays,
  4025.     *     function names, swizzles with repeated fields, and constants
  4026.     *     cannot be l-values."
  4027.     *
  4028.     * So for GLSL 1.10, passing an array as an out or inout parameter is not
  4029.     * allowed.  This restriction is removed in GLSL 1.20, and in GLSL ES.
  4030.     */
  4031.    if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out)
  4032.        && type->is_array()
  4033.        && !state->check_version(120, 100, &loc,
  4034.                                 "arrays cannot be out or inout parameters")) {
  4035.       type = glsl_type::error_type;
  4036.    }
  4037.  
  4038.    instructions->push_tail(var);
  4039.  
  4040.    /* Parameter declarations do not have r-values.
  4041.     */
  4042.    return NULL;
  4043. }
  4044.  
  4045.  
  4046. void
  4047. ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
  4048.                                             bool formal,
  4049.                                             exec_list *ir_parameters,
  4050.                                             _mesa_glsl_parse_state *state)
  4051. {
  4052.    ast_parameter_declarator *void_param = NULL;
  4053.    unsigned count = 0;
  4054.  
  4055.    foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters) {
  4056.       param->formal_parameter = formal;
  4057.       param->hir(ir_parameters, state);
  4058.  
  4059.       if (param->is_void)
  4060.          void_param = param;
  4061.  
  4062.       count++;
  4063.    }
  4064.  
  4065.    if ((void_param != NULL) && (count > 1)) {
  4066.       YYLTYPE loc = void_param->get_location();
  4067.  
  4068.       _mesa_glsl_error(& loc, state,
  4069.                        "`void' parameter must be only parameter");
  4070.    }
  4071. }
  4072.  
  4073.  
  4074. void
  4075. emit_function(_mesa_glsl_parse_state *state, ir_function *f)
  4076. {
  4077.    /* IR invariants disallow function declarations or definitions
  4078.     * nested within other function definitions.  But there is no
  4079.     * requirement about the relative order of function declarations
  4080.     * and definitions with respect to one another.  So simply insert
  4081.     * the new ir_function block at the end of the toplevel instruction
  4082.     * list.
  4083.     */
  4084.    state->toplevel_ir->push_tail(f);
  4085. }
  4086.  
  4087.  
  4088. ir_rvalue *
  4089. ast_function::hir(exec_list *instructions,
  4090.                   struct _mesa_glsl_parse_state *state)
  4091. {
  4092.    void *ctx = state;
  4093.    ir_function *f = NULL;
  4094.    ir_function_signature *sig = NULL;
  4095.    exec_list hir_parameters;
  4096.  
  4097.    const char *const name = identifier;
  4098.  
  4099.    /* New functions are always added to the top-level IR instruction stream,
  4100.     * so this instruction list pointer is ignored.  See also emit_function
  4101.     * (called below).
  4102.     */
  4103.    (void) instructions;
  4104.  
  4105.    /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec,
  4106.     *
  4107.     *   "Function declarations (prototypes) cannot occur inside of functions;
  4108.     *   they must be at global scope, or for the built-in functions, outside
  4109.     *   the global scope."
  4110.     *
  4111.     * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec,
  4112.     *
  4113.     *   "User defined functions may only be defined within the global scope."
  4114.     *
  4115.     * Note that this language does not appear in GLSL 1.10.
  4116.     */
  4117.    if ((state->current_function != NULL) &&
  4118.        state->is_version(120, 100)) {
  4119.       YYLTYPE loc = this->get_location();
  4120.       _mesa_glsl_error(&loc, state,
  4121.                        "declaration of function `%s' not allowed within "
  4122.                        "function body", name);
  4123.    }
  4124.  
  4125.    validate_identifier(name, this->get_location(), state);
  4126.  
  4127.    /* Convert the list of function parameters to HIR now so that they can be
  4128.     * used below to compare this function's signature with previously seen
  4129.     * signatures for functions with the same name.
  4130.     */
  4131.    ast_parameter_declarator::parameters_to_hir(& this->parameters,
  4132.                                                is_definition,
  4133.                                                & hir_parameters, state);
  4134.  
  4135.    const char *return_type_name;
  4136.    const glsl_type *return_type =
  4137.       this->return_type->glsl_type(& return_type_name, state);
  4138.  
  4139.    if (!return_type) {
  4140.       YYLTYPE loc = this->get_location();
  4141.       _mesa_glsl_error(&loc, state,
  4142.                        "function `%s' has undeclared return type `%s'",
  4143.                        name, return_type_name);
  4144.       return_type = glsl_type::error_type;
  4145.    }
  4146.  
  4147.    /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec:
  4148.     * "No qualifier is allowed on the return type of a function."
  4149.     */
  4150.    if (this->return_type->has_qualifiers()) {
  4151.       YYLTYPE loc = this->get_location();
  4152.       _mesa_glsl_error(& loc, state,
  4153.                        "function `%s' return type has qualifiers", name);
  4154.    }
  4155.  
  4156.    /* Section 6.1 (Function Definitions) of the GLSL 1.20 spec says:
  4157.     *
  4158.     *     "Arrays are allowed as arguments and as the return type. In both
  4159.     *     cases, the array must be explicitly sized."
  4160.     */
  4161.    if (return_type->is_unsized_array()) {
  4162.       YYLTYPE loc = this->get_location();
  4163.       _mesa_glsl_error(& loc, state,
  4164.                        "function `%s' return type array must be explicitly "
  4165.                        "sized", name);
  4166.    }
  4167.  
  4168.    /* From section 4.1.7 of the GLSL 4.40 spec:
  4169.     *
  4170.     *    "[Opaque types] can only be declared as function parameters
  4171.     *     or uniform-qualified variables."
  4172.     */
  4173.    if (return_type->contains_opaque()) {
  4174.       YYLTYPE loc = this->get_location();
  4175.       _mesa_glsl_error(&loc, state,
  4176.                        "function `%s' return type can't contain an opaque type",
  4177.                        name);
  4178.    }
  4179.  
  4180.    /* Create an ir_function if one doesn't already exist. */
  4181.    f = state->symbols->get_function(name);
  4182.    if (f == NULL) {
  4183.       f = new(ctx) ir_function(name);
  4184.       if (!state->symbols->add_function(f)) {
  4185.          /* This function name shadows a non-function use of the same name. */
  4186.          YYLTYPE loc = this->get_location();
  4187.  
  4188.          _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
  4189.                           "non-function", name);
  4190.          return NULL;
  4191.       }
  4192.  
  4193.       emit_function(state, f);
  4194.    }
  4195.  
  4196.    /* From GLSL ES 3.0 spec, chapter 6.1 "Function Definitions", page 71:
  4197.     *
  4198.     * "A shader cannot redefine or overload built-in functions."
  4199.     *
  4200.     * While in GLSL ES 1.0 specification, chapter 8 "Built-in Functions":
  4201.     *
  4202.     * "User code can overload the built-in functions but cannot redefine
  4203.     * them."
  4204.     */
  4205.    if (state->es_shader && state->language_version >= 300) {
  4206.       /* Local shader has no exact candidates; check the built-ins. */
  4207.       _mesa_glsl_initialize_builtin_functions();
  4208.       if (_mesa_glsl_find_builtin_function_by_name(state, name)) {
  4209.          YYLTYPE loc = this->get_location();
  4210.          _mesa_glsl_error(& loc, state,
  4211.                           "A shader cannot redefine or overload built-in "
  4212.                           "function `%s' in GLSL ES 3.00", name);
  4213.          return NULL;
  4214.       }
  4215.    }
  4216.  
  4217.    /* Verify that this function's signature either doesn't match a previously
  4218.     * seen signature for a function with the same name, or, if a match is found,
  4219.     * that the previously seen signature does not have an associated definition.
  4220.     */
  4221.    if (state->es_shader || f->has_user_signature()) {
  4222.       sig = f->exact_matching_signature(state, &hir_parameters);
  4223.       if (sig != NULL) {
  4224.          const char *badvar = sig->qualifiers_match(&hir_parameters);
  4225.          if (badvar != NULL) {
  4226.             YYLTYPE loc = this->get_location();
  4227.  
  4228.             _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
  4229.                              "qualifiers don't match prototype", name, badvar);
  4230.          }
  4231.  
  4232.          if (sig->return_type != return_type) {
  4233.             YYLTYPE loc = this->get_location();
  4234.  
  4235.             _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
  4236.                              "match prototype", name);
  4237.          }
  4238.  
  4239.          if (sig->is_defined) {
  4240.             if (is_definition) {
  4241.                YYLTYPE loc = this->get_location();
  4242.                _mesa_glsl_error(& loc, state, "function `%s' redefined", name);
  4243.             } else {
  4244.                /* We just encountered a prototype that exactly matches a
  4245.                 * function that's already been defined.  This is redundant,
  4246.                 * and we should ignore it.
  4247.                 */
  4248.                return NULL;
  4249.             }
  4250.          }
  4251.       }
  4252.    }
  4253.  
  4254.    /* Verify the return type of main() */
  4255.    if (strcmp(name, "main") == 0) {
  4256.       if (! return_type->is_void()) {
  4257.          YYLTYPE loc = this->get_location();
  4258.  
  4259.          _mesa_glsl_error(& loc, state, "main() must return void");
  4260.       }
  4261.  
  4262.       if (!hir_parameters.is_empty()) {
  4263.          YYLTYPE loc = this->get_location();
  4264.  
  4265.          _mesa_glsl_error(& loc, state, "main() must not take any parameters");
  4266.       }
  4267.    }
  4268.  
  4269.    /* Finish storing the information about this new function in its signature.
  4270.     */
  4271.    if (sig == NULL) {
  4272.       sig = new(ctx) ir_function_signature(return_type);
  4273.       f->add_signature(sig);
  4274.    }
  4275.  
  4276.    sig->replace_parameters(&hir_parameters);
  4277.    signature = sig;
  4278.  
  4279.    /* Function declarations (prototypes) do not have r-values.
  4280.     */
  4281.    return NULL;
  4282. }
  4283.  
  4284.  
  4285. ir_rvalue *
  4286. ast_function_definition::hir(exec_list *instructions,
  4287.                              struct _mesa_glsl_parse_state *state)
  4288. {
  4289.    prototype->is_definition = true;
  4290.    prototype->hir(instructions, state);
  4291.  
  4292.    ir_function_signature *signature = prototype->signature;
  4293.    if (signature == NULL)
  4294.       return NULL;
  4295.  
  4296.    assert(state->current_function == NULL);
  4297.    state->current_function = signature;
  4298.    state->found_return = false;
  4299.  
  4300.    /* Duplicate parameters declared in the prototype as concrete variables.
  4301.     * Add these to the symbol table.
  4302.     */
  4303.    state->symbols->push_scope();
  4304.    foreach_in_list(ir_variable, var, &signature->parameters) {
  4305.       assert(var->as_variable() != NULL);
  4306.  
  4307.       /* The only way a parameter would "exist" is if two parameters have
  4308.        * the same name.
  4309.        */
  4310.       if (state->symbols->name_declared_this_scope(var->name)) {
  4311.          YYLTYPE loc = this->get_location();
  4312.  
  4313.          _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
  4314.       } else {
  4315.          state->symbols->add_variable(var);
  4316.       }
  4317.    }
  4318.  
  4319.    /* Convert the body of the function to HIR. */
  4320.    this->body->hir(&signature->body, state);
  4321.    signature->is_defined = true;
  4322.  
  4323.    state->symbols->pop_scope();
  4324.  
  4325.    assert(state->current_function == signature);
  4326.    state->current_function = NULL;
  4327.  
  4328.    if (!signature->return_type->is_void() && !state->found_return) {
  4329.       YYLTYPE loc = this->get_location();
  4330.       _mesa_glsl_error(& loc, state, "function `%s' has non-void return type "
  4331.                        "%s, but no return statement",
  4332.                        signature->function_name(),
  4333.                        signature->return_type->name);
  4334.    }
  4335.  
  4336.    /* Function definitions do not have r-values.
  4337.     */
  4338.    return NULL;
  4339. }
  4340.  
  4341.  
  4342. ir_rvalue *
  4343. ast_jump_statement::hir(exec_list *instructions,
  4344.                         struct _mesa_glsl_parse_state *state)
  4345. {
  4346.    void *ctx = state;
  4347.  
  4348.    switch (mode) {
  4349.    case ast_return: {
  4350.       ir_return *inst;
  4351.       assert(state->current_function);
  4352.  
  4353.       if (opt_return_value) {
  4354.          ir_rvalue *ret = opt_return_value->hir(instructions, state);
  4355.  
  4356.          /* The value of the return type can be NULL if the shader says
  4357.           * 'return foo();' and foo() is a function that returns void.
  4358.           *
  4359.           * NOTE: The GLSL spec doesn't say that this is an error.  The type
  4360.           * of the return value is void.  If the return type of the function is
  4361.           * also void, then this should compile without error.  Seriously.
  4362.           */
  4363.          const glsl_type *const ret_type =
  4364.             (ret == NULL) ? glsl_type::void_type : ret->type;
  4365.  
  4366.          /* Implicit conversions are not allowed for return values prior to
  4367.           * ARB_shading_language_420pack.
  4368.           */
  4369.          if (state->current_function->return_type != ret_type) {
  4370.             YYLTYPE loc = this->get_location();
  4371.  
  4372.             if (state->ARB_shading_language_420pack_enable) {
  4373.                if (!apply_implicit_conversion(state->current_function->return_type,
  4374.                                               ret, state)) {
  4375.                   _mesa_glsl_error(& loc, state,
  4376.                                    "could not implicitly convert return value "
  4377.                                    "to %s, in function `%s'",
  4378.                                    state->current_function->return_type->name,
  4379.                                    state->current_function->function_name());
  4380.                }
  4381.             } else {
  4382.                _mesa_glsl_error(& loc, state,
  4383.                                 "`return' with wrong type %s, in function `%s' "
  4384.                                 "returning %s",
  4385.                                 ret_type->name,
  4386.                                 state->current_function->function_name(),
  4387.                                 state->current_function->return_type->name);
  4388.             }
  4389.          } else if (state->current_function->return_type->base_type ==
  4390.                     GLSL_TYPE_VOID) {
  4391.             YYLTYPE loc = this->get_location();
  4392.  
  4393.             /* The ARB_shading_language_420pack, GLSL ES 3.0, and GLSL 4.20
  4394.              * specs add a clarification:
  4395.              *
  4396.              *    "A void function can only use return without a return argument, even if
  4397.              *     the return argument has void type. Return statements only accept values:
  4398.              *
  4399.              *         void func1() { }
  4400.              *         void func2() { return func1(); } // illegal return statement"
  4401.              */
  4402.             _mesa_glsl_error(& loc, state,
  4403.                              "void functions can only use `return' without a "
  4404.                              "return argument");
  4405.          }
  4406.  
  4407.          inst = new(ctx) ir_return(ret);
  4408.       } else {
  4409.          if (state->current_function->return_type->base_type !=
  4410.              GLSL_TYPE_VOID) {
  4411.             YYLTYPE loc = this->get_location();
  4412.  
  4413.             _mesa_glsl_error(& loc, state,
  4414.                              "`return' with no value, in function %s returning "
  4415.                              "non-void",
  4416.             state->current_function->function_name());
  4417.          }
  4418.          inst = new(ctx) ir_return;
  4419.       }
  4420.  
  4421.       state->found_return = true;
  4422.       instructions->push_tail(inst);
  4423.       break;
  4424.    }
  4425.  
  4426.    case ast_discard:
  4427.       if (state->stage != MESA_SHADER_FRAGMENT) {
  4428.          YYLTYPE loc = this->get_location();
  4429.  
  4430.          _mesa_glsl_error(& loc, state,
  4431.                           "`discard' may only appear in a fragment shader");
  4432.       }
  4433.       instructions->push_tail(new(ctx) ir_discard);
  4434.       break;
  4435.  
  4436.    case ast_break:
  4437.    case ast_continue:
  4438.       if (mode == ast_continue &&
  4439.           state->loop_nesting_ast == NULL) {
  4440.          YYLTYPE loc = this->get_location();
  4441.  
  4442.          _mesa_glsl_error(& loc, state, "continue may only appear in a loop");
  4443.       } else if (mode == ast_break &&
  4444.          state->loop_nesting_ast == NULL &&
  4445.          state->switch_state.switch_nesting_ast == NULL) {
  4446.          YYLTYPE loc = this->get_location();
  4447.  
  4448.          _mesa_glsl_error(& loc, state,
  4449.                           "break may only appear in a loop or a switch");
  4450.       } else {
  4451.          /* For a loop, inline the for loop expression again, since we don't
  4452.           * know where near the end of the loop body the normal copy of it is
  4453.           * going to be placed.  Same goes for the condition for a do-while
  4454.           * loop.
  4455.           */
  4456.          if (state->loop_nesting_ast != NULL &&
  4457.              mode == ast_continue && !state->switch_state.is_switch_innermost) {
  4458.             if (state->loop_nesting_ast->rest_expression) {
  4459.                state->loop_nesting_ast->rest_expression->hir(instructions,
  4460.                                                              state);
  4461.             }
  4462.             if (state->loop_nesting_ast->mode ==
  4463.                 ast_iteration_statement::ast_do_while) {
  4464.                state->loop_nesting_ast->condition_to_hir(instructions, state);
  4465.             }
  4466.          }
  4467.  
  4468.          if (state->switch_state.is_switch_innermost &&
  4469.              mode == ast_continue) {
  4470.             /* Set 'continue_inside' to true. */
  4471.             ir_rvalue *const true_val = new (ctx) ir_constant(true);
  4472.             ir_dereference_variable *deref_continue_inside_var =
  4473.                new(ctx) ir_dereference_variable(state->switch_state.continue_inside);
  4474.             instructions->push_tail(new(ctx) ir_assignment(deref_continue_inside_var,
  4475.                                                            true_val));
  4476.  
  4477.             /* Break out from the switch, continue for the loop will
  4478.              * be called right after switch. */
  4479.             ir_loop_jump *const jump =
  4480.                new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
  4481.             instructions->push_tail(jump);
  4482.  
  4483.          } else if (state->switch_state.is_switch_innermost &&
  4484.              mode == ast_break) {
  4485.             /* Force break out of switch by inserting a break. */
  4486.             ir_loop_jump *const jump =
  4487.                new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
  4488.             instructions->push_tail(jump);
  4489.          } else {
  4490.             ir_loop_jump *const jump =
  4491.                new(ctx) ir_loop_jump((mode == ast_break)
  4492.                   ? ir_loop_jump::jump_break
  4493.                   : ir_loop_jump::jump_continue);
  4494.             instructions->push_tail(jump);
  4495.          }
  4496.       }
  4497.  
  4498.       break;
  4499.    }
  4500.  
  4501.    /* Jump instructions do not have r-values.
  4502.     */
  4503.    return NULL;
  4504. }
  4505.  
  4506.  
  4507. ir_rvalue *
  4508. ast_selection_statement::hir(exec_list *instructions,
  4509.                              struct _mesa_glsl_parse_state *state)
  4510. {
  4511.    void *ctx = state;
  4512.  
  4513.    ir_rvalue *const condition = this->condition->hir(instructions, state);
  4514.  
  4515.    /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec:
  4516.     *
  4517.     *    "Any expression whose type evaluates to a Boolean can be used as the
  4518.     *    conditional expression bool-expression. Vector types are not accepted
  4519.     *    as the expression to if."
  4520.     *
  4521.     * The checks are separated so that higher quality diagnostics can be
  4522.     * generated for cases where both rules are violated.
  4523.     */
  4524.    if (!condition->type->is_boolean() || !condition->type->is_scalar()) {
  4525.       YYLTYPE loc = this->condition->get_location();
  4526.  
  4527.       _mesa_glsl_error(& loc, state, "if-statement condition must be scalar "
  4528.                        "boolean");
  4529.    }
  4530.  
  4531.    ir_if *const stmt = new(ctx) ir_if(condition);
  4532.  
  4533.    if (then_statement != NULL) {
  4534.       state->symbols->push_scope();
  4535.       then_statement->hir(& stmt->then_instructions, state);
  4536.       state->symbols->pop_scope();
  4537.    }
  4538.  
  4539.    if (else_statement != NULL) {
  4540.       state->symbols->push_scope();
  4541.       else_statement->hir(& stmt->else_instructions, state);
  4542.       state->symbols->pop_scope();
  4543.    }
  4544.  
  4545.    instructions->push_tail(stmt);
  4546.  
  4547.    /* if-statements do not have r-values.
  4548.     */
  4549.    return NULL;
  4550. }
  4551.  
  4552.  
  4553. ir_rvalue *
  4554. ast_switch_statement::hir(exec_list *instructions,
  4555.                           struct _mesa_glsl_parse_state *state)
  4556. {
  4557.    void *ctx = state;
  4558.  
  4559.    ir_rvalue *const test_expression =
  4560.       this->test_expression->hir(instructions, state);
  4561.  
  4562.    /* From page 66 (page 55 of the PDF) of the GLSL 1.50 spec:
  4563.     *
  4564.     *    "The type of init-expression in a switch statement must be a
  4565.     *     scalar integer."
  4566.     */
  4567.    if (!test_expression->type->is_scalar() ||
  4568.        !test_expression->type->is_integer()) {
  4569.       YYLTYPE loc = this->test_expression->get_location();
  4570.  
  4571.       _mesa_glsl_error(& loc,
  4572.                        state,
  4573.                        "switch-statement expression must be scalar "
  4574.                        "integer");
  4575.    }
  4576.  
  4577.    /* Track the switch-statement nesting in a stack-like manner.
  4578.     */
  4579.    struct glsl_switch_state saved = state->switch_state;
  4580.  
  4581.    state->switch_state.is_switch_innermost = true;
  4582.    state->switch_state.switch_nesting_ast = this;
  4583.    state->switch_state.labels_ht = hash_table_ctor(0, hash_table_pointer_hash,
  4584.                                                    hash_table_pointer_compare);
  4585.    state->switch_state.previous_default = NULL;
  4586.  
  4587.    /* Initalize is_fallthru state to false.
  4588.     */
  4589.    ir_rvalue *const is_fallthru_val = new (ctx) ir_constant(false);
  4590.    state->switch_state.is_fallthru_var =
  4591.       new(ctx) ir_variable(glsl_type::bool_type,
  4592.                            "switch_is_fallthru_tmp",
  4593.                            ir_var_temporary);
  4594.    instructions->push_tail(state->switch_state.is_fallthru_var);
  4595.  
  4596.    ir_dereference_variable *deref_is_fallthru_var =
  4597.       new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var);
  4598.    instructions->push_tail(new(ctx) ir_assignment(deref_is_fallthru_var,
  4599.                                                   is_fallthru_val));
  4600.  
  4601.    /* Initialize continue_inside state to false.
  4602.     */
  4603.    state->switch_state.continue_inside =
  4604.       new(ctx) ir_variable(glsl_type::bool_type,
  4605.                            "continue_inside_tmp",
  4606.                            ir_var_temporary);
  4607.    instructions->push_tail(state->switch_state.continue_inside);
  4608.  
  4609.    ir_rvalue *const false_val = new (ctx) ir_constant(false);
  4610.    ir_dereference_variable *deref_continue_inside_var =
  4611.       new(ctx) ir_dereference_variable(state->switch_state.continue_inside);
  4612.    instructions->push_tail(new(ctx) ir_assignment(deref_continue_inside_var,
  4613.                                                   false_val));
  4614.  
  4615.    state->switch_state.run_default =
  4616.       new(ctx) ir_variable(glsl_type::bool_type,
  4617.                              "run_default_tmp",
  4618.                              ir_var_temporary);
  4619.    instructions->push_tail(state->switch_state.run_default);
  4620.  
  4621.    /* Loop around the switch is used for flow control. */
  4622.    ir_loop * loop = new(ctx) ir_loop();
  4623.    instructions->push_tail(loop);
  4624.  
  4625.    /* Cache test expression.
  4626.     */
  4627.    test_to_hir(&loop->body_instructions, state);
  4628.  
  4629.    /* Emit code for body of switch stmt.
  4630.     */
  4631.    body->hir(&loop->body_instructions, state);
  4632.  
  4633.    /* Insert a break at the end to exit loop. */
  4634.    ir_loop_jump *jump = new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
  4635.    loop->body_instructions.push_tail(jump);
  4636.  
  4637.    /* If we are inside loop, check if continue got called inside switch. */
  4638.    if (state->loop_nesting_ast != NULL) {
  4639.       ir_dereference_variable *deref_continue_inside =
  4640.          new(ctx) ir_dereference_variable(state->switch_state.continue_inside);
  4641.       ir_if *irif = new(ctx) ir_if(deref_continue_inside);
  4642.       ir_loop_jump *jump = new(ctx) ir_loop_jump(ir_loop_jump::jump_continue);
  4643.  
  4644.       if (state->loop_nesting_ast != NULL) {
  4645.          if (state->loop_nesting_ast->rest_expression) {
  4646.             state->loop_nesting_ast->rest_expression->hir(&irif->then_instructions,
  4647.                                                           state);
  4648.          }
  4649.          if (state->loop_nesting_ast->mode ==
  4650.              ast_iteration_statement::ast_do_while) {
  4651.             state->loop_nesting_ast->condition_to_hir(&irif->then_instructions, state);
  4652.          }
  4653.       }
  4654.       irif->then_instructions.push_tail(jump);
  4655.       instructions->push_tail(irif);
  4656.    }
  4657.  
  4658.    hash_table_dtor(state->switch_state.labels_ht);
  4659.  
  4660.    state->switch_state = saved;
  4661.  
  4662.    /* Switch statements do not have r-values. */
  4663.    return NULL;
  4664. }
  4665.  
  4666.  
  4667. void
  4668. ast_switch_statement::test_to_hir(exec_list *instructions,
  4669.                                   struct _mesa_glsl_parse_state *state)
  4670. {
  4671.    void *ctx = state;
  4672.  
  4673.    /* Cache value of test expression. */
  4674.    ir_rvalue *const test_val =
  4675.       test_expression->hir(instructions,
  4676.                            state);
  4677.  
  4678.    state->switch_state.test_var = new(ctx) ir_variable(test_val->type,
  4679.                                                        "switch_test_tmp",
  4680.                                                        ir_var_temporary);
  4681.    ir_dereference_variable *deref_test_var =
  4682.       new(ctx) ir_dereference_variable(state->switch_state.test_var);
  4683.  
  4684.    instructions->push_tail(state->switch_state.test_var);
  4685.    instructions->push_tail(new(ctx) ir_assignment(deref_test_var, test_val));
  4686. }
  4687.  
  4688.  
  4689. ir_rvalue *
  4690. ast_switch_body::hir(exec_list *instructions,
  4691.                      struct _mesa_glsl_parse_state *state)
  4692. {
  4693.    if (stmts != NULL)
  4694.       stmts->hir(instructions, state);
  4695.  
  4696.    /* Switch bodies do not have r-values. */
  4697.    return NULL;
  4698. }
  4699.  
  4700. ir_rvalue *
  4701. ast_case_statement_list::hir(exec_list *instructions,
  4702.                              struct _mesa_glsl_parse_state *state)
  4703. {
  4704.    exec_list default_case, after_default, tmp;
  4705.  
  4706.    foreach_list_typed (ast_case_statement, case_stmt, link, & this->cases) {
  4707.       case_stmt->hir(&tmp, state);
  4708.  
  4709.       /* Default case. */
  4710.       if (state->switch_state.previous_default && default_case.is_empty()) {
  4711.          default_case.append_list(&tmp);
  4712.          continue;
  4713.       }
  4714.  
  4715.       /* If default case found, append 'after_default' list. */
  4716.       if (!default_case.is_empty())
  4717.          after_default.append_list(&tmp);
  4718.       else
  4719.          instructions->append_list(&tmp);
  4720.    }
  4721.  
  4722.    /* Handle the default case. This is done here because default might not be
  4723.     * the last case. We need to add checks against following cases first to see
  4724.     * if default should be chosen or not.
  4725.     */
  4726.    if (!default_case.is_empty()) {
  4727.  
  4728.       ir_rvalue *const true_val = new (state) ir_constant(true);
  4729.       ir_dereference_variable *deref_run_default_var =
  4730.          new(state) ir_dereference_variable(state->switch_state.run_default);
  4731.  
  4732.       /* Choose to run default case initially, following conditional
  4733.        * assignments might change this.
  4734.        */
  4735.       ir_assignment *const init_var =
  4736.          new(state) ir_assignment(deref_run_default_var, true_val);
  4737.       instructions->push_tail(init_var);
  4738.  
  4739.       /* Default case was the last one, no checks required. */
  4740.       if (after_default.is_empty()) {
  4741.          instructions->append_list(&default_case);
  4742.          return NULL;
  4743.       }
  4744.  
  4745.       foreach_in_list(ir_instruction, ir, &after_default) {
  4746.          ir_assignment *assign = ir->as_assignment();
  4747.  
  4748.          if (!assign)
  4749.             continue;
  4750.  
  4751.          /* Clone the check between case label and init expression. */
  4752.          ir_expression *exp = (ir_expression*) assign->condition;
  4753.          ir_expression *clone = exp->clone(state, NULL);
  4754.  
  4755.          ir_dereference_variable *deref_var =
  4756.             new(state) ir_dereference_variable(state->switch_state.run_default);
  4757.          ir_rvalue *const false_val = new (state) ir_constant(false);
  4758.  
  4759.          ir_assignment *const set_false =
  4760.             new(state) ir_assignment(deref_var, false_val, clone);
  4761.  
  4762.          instructions->push_tail(set_false);
  4763.       }
  4764.  
  4765.       /* Append default case and all cases after it. */
  4766.       instructions->append_list(&default_case);
  4767.       instructions->append_list(&after_default);
  4768.    }
  4769.  
  4770.    /* Case statements do not have r-values. */
  4771.    return NULL;
  4772. }
  4773.  
  4774. ir_rvalue *
  4775. ast_case_statement::hir(exec_list *instructions,
  4776.                         struct _mesa_glsl_parse_state *state)
  4777. {
  4778.    labels->hir(instructions, state);
  4779.  
  4780.    /* Guard case statements depending on fallthru state. */
  4781.    ir_dereference_variable *const deref_fallthru_guard =
  4782.       new(state) ir_dereference_variable(state->switch_state.is_fallthru_var);
  4783.    ir_if *const test_fallthru = new(state) ir_if(deref_fallthru_guard);
  4784.  
  4785.    foreach_list_typed (ast_node, stmt, link, & this->stmts)
  4786.       stmt->hir(& test_fallthru->then_instructions, state);
  4787.  
  4788.    instructions->push_tail(test_fallthru);
  4789.  
  4790.    /* Case statements do not have r-values. */
  4791.    return NULL;
  4792. }
  4793.  
  4794.  
  4795. ir_rvalue *
  4796. ast_case_label_list::hir(exec_list *instructions,
  4797.                          struct _mesa_glsl_parse_state *state)
  4798. {
  4799.    foreach_list_typed (ast_case_label, label, link, & this->labels)
  4800.       label->hir(instructions, state);
  4801.  
  4802.    /* Case labels do not have r-values. */
  4803.    return NULL;
  4804. }
  4805.  
  4806. ir_rvalue *
  4807. ast_case_label::hir(exec_list *instructions,
  4808.                     struct _mesa_glsl_parse_state *state)
  4809. {
  4810.    void *ctx = state;
  4811.  
  4812.    ir_dereference_variable *deref_fallthru_var =
  4813.       new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var);
  4814.  
  4815.    ir_rvalue *const true_val = new(ctx) ir_constant(true);
  4816.  
  4817.    /* If not default case, ... */
  4818.    if (this->test_value != NULL) {
  4819.       /* Conditionally set fallthru state based on
  4820.        * comparison of cached test expression value to case label.
  4821.        */
  4822.       ir_rvalue *const label_rval = this->test_value->hir(instructions, state);
  4823.       ir_constant *label_const = label_rval->constant_expression_value();
  4824.  
  4825.       if (!label_const) {
  4826.          YYLTYPE loc = this->test_value->get_location();
  4827.  
  4828.          _mesa_glsl_error(& loc, state,
  4829.                           "switch statement case label must be a "
  4830.                           "constant expression");
  4831.  
  4832.          /* Stuff a dummy value in to allow processing to continue. */
  4833.          label_const = new(ctx) ir_constant(0);
  4834.       } else {
  4835.          ast_expression *previous_label = (ast_expression *)
  4836.          hash_table_find(state->switch_state.labels_ht,
  4837.                          (void *)(uintptr_t)label_const->value.u[0]);
  4838.  
  4839.          if (previous_label) {
  4840.             YYLTYPE loc = this->test_value->get_location();
  4841.             _mesa_glsl_error(& loc, state, "duplicate case value");
  4842.  
  4843.             loc = previous_label->get_location();
  4844.             _mesa_glsl_error(& loc, state, "this is the previous case label");
  4845.          } else {
  4846.             hash_table_insert(state->switch_state.labels_ht,
  4847.                               this->test_value,
  4848.                               (void *)(uintptr_t)label_const->value.u[0]);
  4849.          }
  4850.       }
  4851.  
  4852.       ir_dereference_variable *deref_test_var =
  4853.          new(ctx) ir_dereference_variable(state->switch_state.test_var);
  4854.  
  4855.       ir_expression *test_cond = new(ctx) ir_expression(ir_binop_all_equal,
  4856.                                                         label_const,
  4857.                                                         deref_test_var);
  4858.  
  4859.       /*
  4860.        * From GLSL 4.40 specification section 6.2 ("Selection"):
  4861.        *
  4862.        *     "The type of the init-expression value in a switch statement must
  4863.        *     be a scalar int or uint. The type of the constant-expression value
  4864.        *     in a case label also must be a scalar int or uint. When any pair
  4865.        *     of these values is tested for "equal value" and the types do not
  4866.        *     match, an implicit conversion will be done to convert the int to a
  4867.        *     uint (see section 4.1.10 “Implicit Conversions”) before the compare
  4868.        *     is done."
  4869.        */
  4870.       if (label_const->type != state->switch_state.test_var->type) {
  4871.          YYLTYPE loc = this->test_value->get_location();
  4872.  
  4873.          const glsl_type *type_a = label_const->type;
  4874.          const glsl_type *type_b = state->switch_state.test_var->type;
  4875.  
  4876.          /* Check if int->uint implicit conversion is supported. */
  4877.          bool integer_conversion_supported =
  4878.             glsl_type::int_type->can_implicitly_convert_to(glsl_type::uint_type,
  4879.                                                            state);
  4880.  
  4881.          if ((!type_a->is_integer() || !type_b->is_integer()) ||
  4882.               !integer_conversion_supported) {
  4883.             _mesa_glsl_error(&loc, state, "type mismatch with switch "
  4884.                              "init-expression and case label (%s != %s)",
  4885.                              type_a->name, type_b->name);
  4886.          } else {
  4887.             /* Conversion of the case label. */
  4888.             if (type_a->base_type == GLSL_TYPE_INT) {
  4889.                if (!apply_implicit_conversion(glsl_type::uint_type,
  4890.                                               test_cond->operands[0], state))
  4891.                   _mesa_glsl_error(&loc, state, "implicit type conversion error");
  4892.             } else {
  4893.                /* Conversion of the init-expression value. */
  4894.                if (!apply_implicit_conversion(glsl_type::uint_type,
  4895.                                               test_cond->operands[1], state))
  4896.                   _mesa_glsl_error(&loc, state, "implicit type conversion error");
  4897.             }
  4898.          }
  4899.       }
  4900.  
  4901.       ir_assignment *set_fallthru_on_test =
  4902.          new(ctx) ir_assignment(deref_fallthru_var, true_val, test_cond);
  4903.  
  4904.       instructions->push_tail(set_fallthru_on_test);
  4905.    } else { /* default case */
  4906.       if (state->switch_state.previous_default) {
  4907.          YYLTYPE loc = this->get_location();
  4908.          _mesa_glsl_error(& loc, state,
  4909.                           "multiple default labels in one switch");
  4910.  
  4911.          loc = state->switch_state.previous_default->get_location();
  4912.          _mesa_glsl_error(& loc, state, "this is the first default label");
  4913.       }
  4914.       state->switch_state.previous_default = this;
  4915.  
  4916.       /* Set fallthru condition on 'run_default' bool. */
  4917.       ir_dereference_variable *deref_run_default =
  4918.          new(ctx) ir_dereference_variable(state->switch_state.run_default);
  4919.       ir_rvalue *const cond_true = new(ctx) ir_constant(true);
  4920.       ir_expression *test_cond = new(ctx) ir_expression(ir_binop_all_equal,
  4921.                                                         cond_true,
  4922.                                                         deref_run_default);
  4923.  
  4924.       /* Set falltrhu state. */
  4925.       ir_assignment *set_fallthru =
  4926.          new(ctx) ir_assignment(deref_fallthru_var, true_val, test_cond);
  4927.  
  4928.       instructions->push_tail(set_fallthru);
  4929.    }
  4930.  
  4931.    /* Case statements do not have r-values. */
  4932.    return NULL;
  4933. }
  4934.  
  4935. void
  4936. ast_iteration_statement::condition_to_hir(exec_list *instructions,
  4937.                                           struct _mesa_glsl_parse_state *state)
  4938. {
  4939.    void *ctx = state;
  4940.  
  4941.    if (condition != NULL) {
  4942.       ir_rvalue *const cond =
  4943.          condition->hir(instructions, state);
  4944.  
  4945.       if ((cond == NULL)
  4946.           || !cond->type->is_boolean() || !cond->type->is_scalar()) {
  4947.          YYLTYPE loc = condition->get_location();
  4948.  
  4949.          _mesa_glsl_error(& loc, state,
  4950.                           "loop condition must be scalar boolean");
  4951.       } else {
  4952.          /* As the first code in the loop body, generate a block that looks
  4953.           * like 'if (!condition) break;' as the loop termination condition.
  4954.           */
  4955.          ir_rvalue *const not_cond =
  4956.             new(ctx) ir_expression(ir_unop_logic_not, cond);
  4957.  
  4958.          ir_if *const if_stmt = new(ctx) ir_if(not_cond);
  4959.  
  4960.          ir_jump *const break_stmt =
  4961.             new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
  4962.  
  4963.          if_stmt->then_instructions.push_tail(break_stmt);
  4964.          instructions->push_tail(if_stmt);
  4965.       }
  4966.    }
  4967. }
  4968.  
  4969.  
  4970. ir_rvalue *
  4971. ast_iteration_statement::hir(exec_list *instructions,
  4972.                              struct _mesa_glsl_parse_state *state)
  4973. {
  4974.    void *ctx = state;
  4975.  
  4976.    /* For-loops and while-loops start a new scope, but do-while loops do not.
  4977.     */
  4978.    if (mode != ast_do_while)
  4979.       state->symbols->push_scope();
  4980.  
  4981.    if (init_statement != NULL)
  4982.       init_statement->hir(instructions, state);
  4983.  
  4984.    ir_loop *const stmt = new(ctx) ir_loop();
  4985.    instructions->push_tail(stmt);
  4986.  
  4987.    /* Track the current loop nesting. */
  4988.    ast_iteration_statement *nesting_ast = state->loop_nesting_ast;
  4989.  
  4990.    state->loop_nesting_ast = this;
  4991.  
  4992.    /* Likewise, indicate that following code is closest to a loop,
  4993.     * NOT closest to a switch.
  4994.     */
  4995.    bool saved_is_switch_innermost = state->switch_state.is_switch_innermost;
  4996.    state->switch_state.is_switch_innermost = false;
  4997.  
  4998.    if (mode != ast_do_while)
  4999.       condition_to_hir(&stmt->body_instructions, state);
  5000.  
  5001.    if (body != NULL)
  5002.       body->hir(& stmt->body_instructions, state);
  5003.  
  5004.    if (rest_expression != NULL)
  5005.       rest_expression->hir(& stmt->body_instructions, state);
  5006.  
  5007.    if (mode == ast_do_while)
  5008.       condition_to_hir(&stmt->body_instructions, state);
  5009.  
  5010.    if (mode != ast_do_while)
  5011.       state->symbols->pop_scope();
  5012.  
  5013.    /* Restore previous nesting before returning. */
  5014.    state->loop_nesting_ast = nesting_ast;
  5015.    state->switch_state.is_switch_innermost = saved_is_switch_innermost;
  5016.  
  5017.    /* Loops do not have r-values.
  5018.     */
  5019.    return NULL;
  5020. }
  5021.  
  5022.  
  5023. /**
  5024.  * Determine if the given type is valid for establishing a default precision
  5025.  * qualifier.
  5026.  *
  5027.  * From GLSL ES 3.00 section 4.5.4 ("Default Precision Qualifiers"):
  5028.  *
  5029.  *     "The precision statement
  5030.  *
  5031.  *         precision precision-qualifier type;
  5032.  *
  5033.  *     can be used to establish a default precision qualifier. The type field
  5034.  *     can be either int or float or any of the sampler types, and the
  5035.  *     precision-qualifier can be lowp, mediump, or highp."
  5036.  *
  5037.  * GLSL ES 1.00 has similar language.  GLSL 1.30 doesn't allow precision
  5038.  * qualifiers on sampler types, but this seems like an oversight (since the
  5039.  * intention of including these in GLSL 1.30 is to allow compatibility with ES
  5040.  * shaders).  So we allow int, float, and all sampler types regardless of GLSL
  5041.  * version.
  5042.  */
  5043. static bool
  5044. is_valid_default_precision_type(const struct glsl_type *const type)
  5045. {
  5046.    if (type == NULL)
  5047.       return false;
  5048.  
  5049.    switch (type->base_type) {
  5050.    case GLSL_TYPE_INT:
  5051.    case GLSL_TYPE_FLOAT:
  5052.       /* "int" and "float" are valid, but vectors and matrices are not. */
  5053.       return type->vector_elements == 1 && type->matrix_columns == 1;
  5054.    case GLSL_TYPE_SAMPLER:
  5055.       return true;
  5056.    default:
  5057.       return false;
  5058.    }
  5059. }
  5060.  
  5061.  
  5062. ir_rvalue *
  5063. ast_type_specifier::hir(exec_list *instructions,
  5064.                         struct _mesa_glsl_parse_state *state)
  5065. {
  5066.    if (this->default_precision == ast_precision_none && this->structure == NULL)
  5067.       return NULL;
  5068.  
  5069.    YYLTYPE loc = this->get_location();
  5070.  
  5071.    /* If this is a precision statement, check that the type to which it is
  5072.     * applied is either float or int.
  5073.     *
  5074.     * From section 4.5.3 of the GLSL 1.30 spec:
  5075.     *    "The precision statement
  5076.     *       precision precision-qualifier type;
  5077.     *    can be used to establish a default precision qualifier. The type
  5078.     *    field can be either int or float [...].  Any other types or
  5079.     *    qualifiers will result in an error.
  5080.     */
  5081.    if (this->default_precision != ast_precision_none) {
  5082.       if (!state->check_precision_qualifiers_allowed(&loc))
  5083.          return NULL;
  5084.  
  5085.       if (this->structure != NULL) {
  5086.          _mesa_glsl_error(&loc, state,
  5087.                           "precision qualifiers do not apply to structures");
  5088.          return NULL;
  5089.       }
  5090.  
  5091.       if (this->array_specifier != NULL) {
  5092.          _mesa_glsl_error(&loc, state,
  5093.                           "default precision statements do not apply to "
  5094.                           "arrays");
  5095.          return NULL;
  5096.       }
  5097.  
  5098.       const struct glsl_type *const type =
  5099.          state->symbols->get_type(this->type_name);
  5100.       if (!is_valid_default_precision_type(type)) {
  5101.          _mesa_glsl_error(&loc, state,
  5102.                           "default precision statements apply only to "
  5103.                           "float, int, and sampler types");
  5104.          return NULL;
  5105.       }
  5106.  
  5107.       if (type->base_type == GLSL_TYPE_FLOAT
  5108.           && state->es_shader
  5109.           && state->stage == MESA_SHADER_FRAGMENT) {
  5110.          /* Section 4.5.3 (Default Precision Qualifiers) of the GLSL ES 1.00
  5111.           * spec says:
  5112.           *
  5113.           *     "The fragment language has no default precision qualifier for
  5114.           *     floating point types."
  5115.           *
  5116.           * As a result, we have to track whether or not default precision has
  5117.           * been specified for float in GLSL ES fragment shaders.
  5118.           *
  5119.           * Earlier in that same section, the spec says:
  5120.           *
  5121.           *     "Non-precision qualified declarations will use the precision
  5122.           *     qualifier specified in the most recent precision statement
  5123.           *     that is still in scope. The precision statement has the same
  5124.           *     scoping rules as variable declarations. If it is declared
  5125.           *     inside a compound statement, its effect stops at the end of
  5126.           *     the innermost statement it was declared in. Precision
  5127.           *     statements in nested scopes override precision statements in
  5128.           *     outer scopes. Multiple precision statements for the same basic
  5129.           *     type can appear inside the same scope, with later statements
  5130.           *     overriding earlier statements within that scope."
  5131.           *
  5132.           * Default precision specifications follow the same scope rules as
  5133.           * variables.  So, we can track the state of the default float
  5134.           * precision in the symbol table, and the rules will just work.  This
  5135.           * is a slight abuse of the symbol table, but it has the semantics
  5136.           * that we want.
  5137.           */
  5138.          ir_variable *const junk =
  5139.             new(state) ir_variable(type, "#default precision",
  5140.                                    ir_var_auto);
  5141.  
  5142.          state->symbols->add_variable(junk);
  5143.       }
  5144.  
  5145.       /* FINISHME: Translate precision statements into IR. */
  5146.       return NULL;
  5147.    }
  5148.  
  5149.    /* _mesa_ast_set_aggregate_type() sets the <structure> field so that
  5150.     * process_record_constructor() can do type-checking on C-style initializer
  5151.     * expressions of structs, but ast_struct_specifier should only be translated
  5152.     * to HIR if it is declaring the type of a structure.
  5153.     *
  5154.     * The ->is_declaration field is false for initializers of variables
  5155.     * declared separately from the struct's type definition.
  5156.     *
  5157.     *    struct S { ... };              (is_declaration = true)
  5158.     *    struct T { ... } t = { ... };  (is_declaration = true)
  5159.     *    S s = { ... };                 (is_declaration = false)
  5160.     */
  5161.    if (this->structure != NULL && this->structure->is_declaration)
  5162.       return this->structure->hir(instructions, state);
  5163.  
  5164.    return NULL;
  5165. }
  5166.  
  5167.  
  5168. /**
  5169.  * Process a structure or interface block tree into an array of structure fields
  5170.  *
  5171.  * After parsing, where there are some syntax differnces, structures and
  5172.  * interface blocks are almost identical.  They are similar enough that the
  5173.  * AST for each can be processed the same way into a set of
  5174.  * \c glsl_struct_field to describe the members.
  5175.  *
  5176.  * If we're processing an interface block, var_mode should be the type of the
  5177.  * interface block (ir_var_shader_in, ir_var_shader_out, or ir_var_uniform).
  5178.  * If we're processing a structure, var_mode should be ir_var_auto.
  5179.  *
  5180.  * \return
  5181.  * The number of fields processed.  A pointer to the array structure fields is
  5182.  * stored in \c *fields_ret.
  5183.  */
  5184. unsigned
  5185. ast_process_structure_or_interface_block(exec_list *instructions,
  5186.                                          struct _mesa_glsl_parse_state *state,
  5187.                                          exec_list *declarations,
  5188.                                          YYLTYPE &loc,
  5189.                                          glsl_struct_field **fields_ret,
  5190.                                          bool is_interface,
  5191.                                          enum glsl_matrix_layout matrix_layout,
  5192.                                          bool allow_reserved_names,
  5193.                                          ir_variable_mode var_mode)
  5194. {
  5195.    unsigned decl_count = 0;
  5196.  
  5197.    /* Make an initial pass over the list of fields to determine how
  5198.     * many there are.  Each element in this list is an ast_declarator_list.
  5199.     * This means that we actually need to count the number of elements in the
  5200.     * 'declarations' list in each of the elements.
  5201.     */
  5202.    foreach_list_typed (ast_declarator_list, decl_list, link, declarations) {
  5203.       decl_count += decl_list->declarations.length();
  5204.    }
  5205.  
  5206.    /* Allocate storage for the fields and process the field
  5207.     * declarations.  As the declarations are processed, try to also convert
  5208.     * the types to HIR.  This ensures that structure definitions embedded in
  5209.     * other structure definitions or in interface blocks are processed.
  5210.     */
  5211.    glsl_struct_field *const fields = ralloc_array(state, glsl_struct_field,
  5212.                                                   decl_count);
  5213.  
  5214.    unsigned i = 0;
  5215.    foreach_list_typed (ast_declarator_list, decl_list, link, declarations) {
  5216.       const char *type_name;
  5217.  
  5218.       decl_list->type->specifier->hir(instructions, state);
  5219.  
  5220.       /* Section 10.9 of the GLSL ES 1.00 specification states that
  5221.        * embedded structure definitions have been removed from the language.
  5222.        */
  5223.       if (state->es_shader && decl_list->type->specifier->structure != NULL) {
  5224.          _mesa_glsl_error(&loc, state, "embedded structure definitions are "
  5225.                           "not allowed in GLSL ES 1.00");
  5226.       }
  5227.  
  5228.       const glsl_type *decl_type =
  5229.          decl_list->type->glsl_type(& type_name, state);
  5230.  
  5231.       foreach_list_typed (ast_declaration, decl, link,
  5232.                           &decl_list->declarations) {
  5233.          if (!allow_reserved_names)
  5234.             validate_identifier(decl->identifier, loc, state);
  5235.  
  5236.          /* From section 4.3.9 of the GLSL 4.40 spec:
  5237.           *
  5238.           *    "[In interface blocks] opaque types are not allowed."
  5239.           *
  5240.           * It should be impossible for decl_type to be NULL here.  Cases that
  5241.           * might naturally lead to decl_type being NULL, especially for the
  5242.           * is_interface case, will have resulted in compilation having
  5243.           * already halted due to a syntax error.
  5244.           */
  5245.          const struct glsl_type *field_type =
  5246.             decl_type != NULL ? decl_type : glsl_type::error_type;
  5247.  
  5248.          if (is_interface && field_type->contains_opaque()) {
  5249.             YYLTYPE loc = decl_list->get_location();
  5250.             _mesa_glsl_error(&loc, state,
  5251.                              "uniform in non-default uniform block contains "
  5252.                              "opaque variable");
  5253.          }
  5254.  
  5255.          if (field_type->contains_atomic()) {
  5256.             /* FINISHME: Add a spec quotation here once updated spec
  5257.              * FINISHME: language is available.  See Khronos bug #10903
  5258.              * FINISHME: on whether atomic counters are allowed in
  5259.              * FINISHME: structures.
  5260.              */
  5261.             YYLTYPE loc = decl_list->get_location();
  5262.             _mesa_glsl_error(&loc, state, "atomic counter in structure or "
  5263.                              "uniform block");
  5264.          }
  5265.  
  5266.          if (field_type->contains_image()) {
  5267.             /* FINISHME: Same problem as with atomic counters.
  5268.              * FINISHME: Request clarification from Khronos and add
  5269.              * FINISHME: spec quotation here.
  5270.              */
  5271.             YYLTYPE loc = decl_list->get_location();
  5272.             _mesa_glsl_error(&loc, state,
  5273.                              "image in structure or uniform block");
  5274.          }
  5275.  
  5276.          const struct ast_type_qualifier *const qual =
  5277.             & decl_list->type->qualifier;
  5278.          if (qual->flags.q.std140 ||
  5279.              qual->flags.q.packed ||
  5280.              qual->flags.q.shared) {
  5281.             _mesa_glsl_error(&loc, state,
  5282.                              "uniform block layout qualifiers std140, packed, and "
  5283.                              "shared can only be applied to uniform blocks, not "
  5284.                              "members");
  5285.          }
  5286.  
  5287.          if (qual->flags.q.constant) {
  5288.             YYLTYPE loc = decl_list->get_location();
  5289.             _mesa_glsl_error(&loc, state,
  5290.                              "const storage qualifier cannot be applied "
  5291.                              "to struct or interface block members");
  5292.          }
  5293.  
  5294.          field_type = process_array_type(&loc, decl_type,
  5295.                                          decl->array_specifier, state);
  5296.          fields[i].type = field_type;
  5297.          fields[i].name = decl->identifier;
  5298.          fields[i].location = -1;
  5299.          fields[i].interpolation =
  5300.             interpret_interpolation_qualifier(qual, var_mode, state, &loc);
  5301.          fields[i].centroid = qual->flags.q.centroid ? 1 : 0;
  5302.          fields[i].sample = qual->flags.q.sample ? 1 : 0;
  5303.  
  5304.          /* Only save explicitly defined streams in block's field */
  5305.          fields[i].stream = qual->flags.q.explicit_stream ? qual->stream : -1;
  5306.  
  5307.          if (qual->flags.q.row_major || qual->flags.q.column_major) {
  5308.             if (!qual->flags.q.uniform) {
  5309.                _mesa_glsl_error(&loc, state,
  5310.                                 "row_major and column_major can only be "
  5311.                                 "applied to uniform interface blocks");
  5312.             } else
  5313.                validate_matrix_layout_for_type(state, &loc, field_type, NULL);
  5314.          }
  5315.  
  5316.          if (qual->flags.q.uniform && qual->has_interpolation()) {
  5317.             _mesa_glsl_error(&loc, state,
  5318.                              "interpolation qualifiers cannot be used "
  5319.                              "with uniform interface blocks");
  5320.          }
  5321.  
  5322.          if ((qual->flags.q.uniform || !is_interface) &&
  5323.              qual->has_auxiliary_storage()) {
  5324.             _mesa_glsl_error(&loc, state,
  5325.                              "auxiliary storage qualifiers cannot be used "
  5326.                              "in uniform blocks or structures.");
  5327.          }
  5328.  
  5329.          /* Propogate row- / column-major information down the fields of the
  5330.           * structure or interface block.  Structures need this data because
  5331.           * the structure may contain a structure that contains ... a matrix
  5332.           * that need the proper layout.
  5333.           */
  5334.          if (field_type->without_array()->is_matrix()
  5335.              || field_type->without_array()->is_record()) {
  5336.             /* If no layout is specified for the field, inherit the layout
  5337.              * from the block.
  5338.              */
  5339.             fields[i].matrix_layout = matrix_layout;
  5340.  
  5341.             if (qual->flags.q.row_major)
  5342.                fields[i].matrix_layout = GLSL_MATRIX_LAYOUT_ROW_MAJOR;
  5343.             else if (qual->flags.q.column_major)
  5344.                fields[i].matrix_layout = GLSL_MATRIX_LAYOUT_COLUMN_MAJOR;
  5345.  
  5346.             /* If we're processing an interface block, the matrix layout must
  5347.              * be decided by this point.
  5348.              */
  5349.             assert(!is_interface
  5350.                    || fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR
  5351.                    || fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR);
  5352.          }
  5353.  
  5354.          i++;
  5355.       }
  5356.    }
  5357.  
  5358.    assert(i == decl_count);
  5359.  
  5360.    *fields_ret = fields;
  5361.    return decl_count;
  5362. }
  5363.  
  5364.  
  5365. ir_rvalue *
  5366. ast_struct_specifier::hir(exec_list *instructions,
  5367.                           struct _mesa_glsl_parse_state *state)
  5368. {
  5369.    YYLTYPE loc = this->get_location();
  5370.  
  5371.    /* Section 4.1.8 (Structures) of the GLSL 1.10 spec says:
  5372.     *
  5373.     *     "Anonymous structures are not supported; so embedded structures must
  5374.     *     have a declarator. A name given to an embedded struct is scoped at
  5375.     *     the same level as the struct it is embedded in."
  5376.     *
  5377.     * The same section of the  GLSL 1.20 spec says:
  5378.     *
  5379.     *     "Anonymous structures are not supported. Embedded structures are not
  5380.     *     supported.
  5381.     *
  5382.     *         struct S { float f; };
  5383.     *         struct T {
  5384.     *             S;              // Error: anonymous structures disallowed
  5385.     *             struct { ... }; // Error: embedded structures disallowed
  5386.     *             S s;            // Okay: nested structures with name are allowed
  5387.     *         };"
  5388.     *
  5389.     * The GLSL ES 1.00 and 3.00 specs have similar langauge and examples.  So,
  5390.     * we allow embedded structures in 1.10 only.
  5391.     */
  5392.    if (state->language_version != 110 && state->struct_specifier_depth != 0)
  5393.       _mesa_glsl_error(&loc, state,
  5394.                        "embedded structure declarations are not allowed");
  5395.  
  5396.    state->struct_specifier_depth++;
  5397.  
  5398.    glsl_struct_field *fields;
  5399.    unsigned decl_count =
  5400.       ast_process_structure_or_interface_block(instructions,
  5401.                                                state,
  5402.                                                &this->declarations,
  5403.                                                loc,
  5404.                                                &fields,
  5405.                                                false,
  5406.                                                GLSL_MATRIX_LAYOUT_INHERITED,
  5407.                                                false /* allow_reserved_names */,
  5408.                                                ir_var_auto);
  5409.  
  5410.    validate_identifier(this->name, loc, state);
  5411.  
  5412.    const glsl_type *t =
  5413.       glsl_type::get_record_instance(fields, decl_count, this->name);
  5414.  
  5415.    if (!state->symbols->add_type(name, t)) {
  5416.       _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name);
  5417.    } else {
  5418.       const glsl_type **s = reralloc(state, state->user_structures,
  5419.                                      const glsl_type *,
  5420.                                      state->num_user_structures + 1);
  5421.       if (s != NULL) {
  5422.          s[state->num_user_structures] = t;
  5423.          state->user_structures = s;
  5424.          state->num_user_structures++;
  5425.       }
  5426.    }
  5427.  
  5428.    state->struct_specifier_depth--;
  5429.  
  5430.    /* Structure type definitions do not have r-values.
  5431.     */
  5432.    return NULL;
  5433. }
  5434.  
  5435.  
  5436. /**
  5437.  * Visitor class which detects whether a given interface block has been used.
  5438.  */
  5439. class interface_block_usage_visitor : public ir_hierarchical_visitor
  5440. {
  5441. public:
  5442.    interface_block_usage_visitor(ir_variable_mode mode, const glsl_type *block)
  5443.       : mode(mode), block(block), found(false)
  5444.    {
  5445.    }
  5446.  
  5447.    virtual ir_visitor_status visit(ir_dereference_variable *ir)
  5448.    {
  5449.       if (ir->var->data.mode == mode && ir->var->get_interface_type() == block) {
  5450.          found = true;
  5451.          return visit_stop;
  5452.       }
  5453.       return visit_continue;
  5454.    }
  5455.  
  5456.    bool usage_found() const
  5457.    {
  5458.       return this->found;
  5459.    }
  5460.  
  5461. private:
  5462.    ir_variable_mode mode;
  5463.    const glsl_type *block;
  5464.    bool found;
  5465. };
  5466.  
  5467.  
  5468. ir_rvalue *
  5469. ast_interface_block::hir(exec_list *instructions,
  5470.                          struct _mesa_glsl_parse_state *state)
  5471. {
  5472.    YYLTYPE loc = this->get_location();
  5473.  
  5474.    /* Interface blocks must be declared at global scope */
  5475.    if (state->current_function != NULL) {
  5476.       _mesa_glsl_error(&loc, state,
  5477.                        "Interface block `%s' must be declared "
  5478.                        "at global scope",
  5479.                        this->block_name);
  5480.    }
  5481.  
  5482.    /* The ast_interface_block has a list of ast_declarator_lists.  We
  5483.     * need to turn those into ir_variables with an association
  5484.     * with this uniform block.
  5485.     */
  5486.    enum glsl_interface_packing packing;
  5487.    if (this->layout.flags.q.shared) {
  5488.       packing = GLSL_INTERFACE_PACKING_SHARED;
  5489.    } else if (this->layout.flags.q.packed) {
  5490.       packing = GLSL_INTERFACE_PACKING_PACKED;
  5491.    } else {
  5492.       /* The default layout is std140.
  5493.        */
  5494.       packing = GLSL_INTERFACE_PACKING_STD140;
  5495.    }
  5496.  
  5497.    ir_variable_mode var_mode;
  5498.    const char *iface_type_name;
  5499.    if (this->layout.flags.q.in) {
  5500.       var_mode = ir_var_shader_in;
  5501.       iface_type_name = "in";
  5502.    } else if (this->layout.flags.q.out) {
  5503.       var_mode = ir_var_shader_out;
  5504.       iface_type_name = "out";
  5505.    } else if (this->layout.flags.q.uniform) {
  5506.       var_mode = ir_var_uniform;
  5507.       iface_type_name = "uniform";
  5508.    } else {
  5509.       var_mode = ir_var_auto;
  5510.       iface_type_name = "UNKNOWN";
  5511.       assert(!"interface block layout qualifier not found!");
  5512.    }
  5513.  
  5514.    enum glsl_matrix_layout matrix_layout = GLSL_MATRIX_LAYOUT_INHERITED;
  5515.    if (this->layout.flags.q.row_major)
  5516.       matrix_layout = GLSL_MATRIX_LAYOUT_ROW_MAJOR;
  5517.    else if (this->layout.flags.q.column_major)
  5518.       matrix_layout = GLSL_MATRIX_LAYOUT_COLUMN_MAJOR;
  5519.  
  5520.    bool redeclaring_per_vertex = strcmp(this->block_name, "gl_PerVertex") == 0;
  5521.    exec_list declared_variables;
  5522.    glsl_struct_field *fields;
  5523.  
  5524.    /* Treat an interface block as one level of nesting, so that embedded struct
  5525.     * specifiers will be disallowed.
  5526.     */
  5527.    state->struct_specifier_depth++;
  5528.  
  5529.    unsigned int num_variables =
  5530.       ast_process_structure_or_interface_block(&declared_variables,
  5531.                                                state,
  5532.                                                &this->declarations,
  5533.                                                loc,
  5534.                                                &fields,
  5535.                                                true,
  5536.                                                matrix_layout,
  5537.                                                redeclaring_per_vertex,
  5538.                                                var_mode);
  5539.  
  5540.    state->struct_specifier_depth--;
  5541.  
  5542.    if (!redeclaring_per_vertex) {
  5543.       validate_identifier(this->block_name, loc, state);
  5544.  
  5545.       /* From section 4.3.9 ("Interface Blocks") of the GLSL 4.50 spec:
  5546.        *
  5547.        *     "Block names have no other use within a shader beyond interface
  5548.        *     matching; it is a compile-time error to use a block name at global
  5549.        *     scope for anything other than as a block name."
  5550.        */
  5551.       ir_variable *var = state->symbols->get_variable(this->block_name);
  5552.       if (var && !var->type->is_interface()) {
  5553.          _mesa_glsl_error(&loc, state, "Block name `%s' is "
  5554.                           "already used in the scope.",
  5555.                           this->block_name);
  5556.       }
  5557.    }
  5558.  
  5559.    const glsl_type *earlier_per_vertex = NULL;
  5560.    if (redeclaring_per_vertex) {
  5561.       /* Find the previous declaration of gl_PerVertex.  If we're redeclaring
  5562.        * the named interface block gl_in, we can find it by looking at the
  5563.        * previous declaration of gl_in.  Otherwise we can find it by looking
  5564.        * at the previous decalartion of any of the built-in outputs,
  5565.        * e.g. gl_Position.
  5566.        *
  5567.        * Also check that the instance name and array-ness of the redeclaration
  5568.        * are correct.
  5569.        */
  5570.       switch (var_mode) {
  5571.       case ir_var_shader_in:
  5572.          if (ir_variable *earlier_gl_in =
  5573.              state->symbols->get_variable("gl_in")) {
  5574.             earlier_per_vertex = earlier_gl_in->get_interface_type();
  5575.          } else {
  5576.             _mesa_glsl_error(&loc, state,
  5577.                              "redeclaration of gl_PerVertex input not allowed "
  5578.                              "in the %s shader",
  5579.                              _mesa_shader_stage_to_string(state->stage));
  5580.          }
  5581.          if (this->instance_name == NULL ||
  5582.              strcmp(this->instance_name, "gl_in") != 0 || this->array_specifier == NULL) {
  5583.             _mesa_glsl_error(&loc, state,
  5584.                              "gl_PerVertex input must be redeclared as "
  5585.                              "gl_in[]");
  5586.          }
  5587.          break;
  5588.       case ir_var_shader_out:
  5589.          if (ir_variable *earlier_gl_Position =
  5590.              state->symbols->get_variable("gl_Position")) {
  5591.             earlier_per_vertex = earlier_gl_Position->get_interface_type();
  5592.          } else {
  5593.             _mesa_glsl_error(&loc, state,
  5594.                              "redeclaration of gl_PerVertex output not "
  5595.                              "allowed in the %s shader",
  5596.                              _mesa_shader_stage_to_string(state->stage));
  5597.          }
  5598.          if (this->instance_name != NULL) {
  5599.             _mesa_glsl_error(&loc, state,
  5600.                              "gl_PerVertex output may not be redeclared with "
  5601.                              "an instance name");
  5602.          }
  5603.          break;
  5604.       default:
  5605.          _mesa_glsl_error(&loc, state,
  5606.                           "gl_PerVertex must be declared as an input or an "
  5607.                           "output");
  5608.          break;
  5609.       }
  5610.  
  5611.       if (earlier_per_vertex == NULL) {
  5612.          /* An error has already been reported.  Bail out to avoid null
  5613.           * dereferences later in this function.
  5614.           */
  5615.          return NULL;
  5616.       }
  5617.  
  5618.       /* Copy locations from the old gl_PerVertex interface block. */
  5619.       for (unsigned i = 0; i < num_variables; i++) {
  5620.          int j = earlier_per_vertex->field_index(fields[i].name);
  5621.          if (j == -1) {
  5622.             _mesa_glsl_error(&loc, state,
  5623.                              "redeclaration of gl_PerVertex must be a subset "
  5624.                              "of the built-in members of gl_PerVertex");
  5625.          } else {
  5626.             fields[i].location =
  5627.                earlier_per_vertex->fields.structure[j].location;
  5628.             fields[i].interpolation =
  5629.                earlier_per_vertex->fields.structure[j].interpolation;
  5630.             fields[i].centroid =
  5631.                earlier_per_vertex->fields.structure[j].centroid;
  5632.             fields[i].sample =
  5633.                earlier_per_vertex->fields.structure[j].sample;
  5634.          }
  5635.       }
  5636.  
  5637.       /* From section 7.1 ("Built-in Language Variables") of the GLSL 4.10
  5638.        * spec:
  5639.        *
  5640.        *     If a built-in interface block is redeclared, it must appear in
  5641.        *     the shader before any use of any member included in the built-in
  5642.        *     declaration, or a compilation error will result.
  5643.        *
  5644.        * This appears to be a clarification to the behaviour established for
  5645.        * gl_PerVertex by GLSL 1.50, therefore we implement this behaviour
  5646.        * regardless of GLSL version.
  5647.        */
  5648.       interface_block_usage_visitor v(var_mode, earlier_per_vertex);
  5649.       v.run(instructions);
  5650.       if (v.usage_found()) {
  5651.          _mesa_glsl_error(&loc, state,
  5652.                           "redeclaration of a built-in interface block must "
  5653.                           "appear before any use of any member of the "
  5654.                           "interface block");
  5655.       }
  5656.    }
  5657.  
  5658.    const glsl_type *block_type =
  5659.       glsl_type::get_interface_instance(fields,
  5660.                                         num_variables,
  5661.                                         packing,
  5662.                                         this->block_name);
  5663.  
  5664.    if (!state->symbols->add_interface(block_type->name, block_type, var_mode)) {
  5665.       YYLTYPE loc = this->get_location();
  5666.       _mesa_glsl_error(&loc, state, "interface block `%s' with type `%s' "
  5667.                        "already taken in the current scope",
  5668.                        this->block_name, iface_type_name);
  5669.    }
  5670.  
  5671.    /* Since interface blocks cannot contain statements, it should be
  5672.     * impossible for the block to generate any instructions.
  5673.     */
  5674.    assert(declared_variables.is_empty());
  5675.  
  5676.    /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec:
  5677.     *
  5678.     *     Geometry shader input variables get the per-vertex values written
  5679.     *     out by vertex shader output variables of the same names. Since a
  5680.     *     geometry shader operates on a set of vertices, each input varying
  5681.     *     variable (or input block, see interface blocks below) needs to be
  5682.     *     declared as an array.
  5683.     */
  5684.    if (state->stage == MESA_SHADER_GEOMETRY && this->array_specifier == NULL &&
  5685.        var_mode == ir_var_shader_in) {
  5686.       _mesa_glsl_error(&loc, state, "geometry shader inputs must be arrays");
  5687.    }
  5688.  
  5689.    /* Page 39 (page 45 of the PDF) of section 4.3.7 in the GLSL ES 3.00 spec
  5690.     * says:
  5691.     *
  5692.     *     "If an instance name (instance-name) is used, then it puts all the
  5693.     *     members inside a scope within its own name space, accessed with the
  5694.     *     field selector ( . ) operator (analogously to structures)."
  5695.     */
  5696.    if (this->instance_name) {
  5697.       if (redeclaring_per_vertex) {
  5698.          /* When a built-in in an unnamed interface block is redeclared,
  5699.           * get_variable_being_redeclared() calls
  5700.           * check_builtin_array_max_size() to make sure that built-in array
  5701.           * variables aren't redeclared to illegal sizes.  But we're looking
  5702.           * at a redeclaration of a named built-in interface block.  So we
  5703.           * have to manually call check_builtin_array_max_size() for all parts
  5704.           * of the interface that are arrays.
  5705.           */
  5706.          for (unsigned i = 0; i < num_variables; i++) {
  5707.             if (fields[i].type->is_array()) {
  5708.                const unsigned size = fields[i].type->array_size();
  5709.                check_builtin_array_max_size(fields[i].name, size, loc, state);
  5710.             }
  5711.          }
  5712.       } else {
  5713.          validate_identifier(this->instance_name, loc, state);
  5714.       }
  5715.  
  5716.       ir_variable *var;
  5717.  
  5718.       if (this->array_specifier != NULL) {
  5719.          /* Section 4.3.7 (Interface Blocks) of the GLSL 1.50 spec says:
  5720.           *
  5721.           *     For uniform blocks declared an array, each individual array
  5722.           *     element corresponds to a separate buffer object backing one
  5723.           *     instance of the block. As the array size indicates the number
  5724.           *     of buffer objects needed, uniform block array declarations
  5725.           *     must specify an array size.
  5726.           *
  5727.           * And a few paragraphs later:
  5728.           *
  5729.           *     Geometry shader input blocks must be declared as arrays and
  5730.           *     follow the array declaration and linking rules for all
  5731.           *     geometry shader inputs. All other input and output block
  5732.           *     arrays must specify an array size.
  5733.           *
  5734.           * The upshot of this is that the only circumstance where an
  5735.           * interface array size *doesn't* need to be specified is on a
  5736.           * geometry shader input.
  5737.           */
  5738.          if (this->array_specifier->is_unsized_array &&
  5739.              (state->stage != MESA_SHADER_GEOMETRY || !this->layout.flags.q.in)) {
  5740.             _mesa_glsl_error(&loc, state,
  5741.                              "only geometry shader inputs may be unsized "
  5742.                              "instance block arrays");
  5743.  
  5744.          }
  5745.  
  5746.          const glsl_type *block_array_type =
  5747.             process_array_type(&loc, block_type, this->array_specifier, state);
  5748.  
  5749.          var = new(state) ir_variable(block_array_type,
  5750.                                       this->instance_name,
  5751.                                       var_mode);
  5752.       } else {
  5753.          var = new(state) ir_variable(block_type,
  5754.                                       this->instance_name,
  5755.                                       var_mode);
  5756.       }
  5757.  
  5758.       var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED
  5759.          ? GLSL_MATRIX_LAYOUT_COLUMN_MAJOR : matrix_layout;
  5760.  
  5761.       if (var_mode == ir_var_shader_in || var_mode == ir_var_uniform)
  5762.          var->data.read_only = true;
  5763.  
  5764.       if (state->stage == MESA_SHADER_GEOMETRY && var_mode == ir_var_shader_in)
  5765.          handle_geometry_shader_input_decl(state, loc, var);
  5766.  
  5767.       if (ir_variable *earlier =
  5768.           state->symbols->get_variable(this->instance_name)) {
  5769.          if (!redeclaring_per_vertex) {
  5770.             _mesa_glsl_error(&loc, state, "`%s' redeclared",
  5771.                              this->instance_name);
  5772.          }
  5773.          earlier->data.how_declared = ir_var_declared_normally;
  5774.          earlier->type = var->type;
  5775.          earlier->reinit_interface_type(block_type);
  5776.          delete var;
  5777.       } else {
  5778.          /* Propagate the "binding" keyword into this UBO's fields;
  5779.           * the UBO declaration itself doesn't get an ir_variable unless it
  5780.           * has an instance name.  This is ugly.
  5781.           */
  5782.          var->data.explicit_binding = this->layout.flags.q.explicit_binding;
  5783.          var->data.binding = this->layout.binding;
  5784.  
  5785.          state->symbols->add_variable(var);
  5786.          instructions->push_tail(var);
  5787.       }
  5788.    } else {
  5789.       /* In order to have an array size, the block must also be declared with
  5790.        * an instance name.
  5791.        */
  5792.       assert(this->array_specifier == NULL);
  5793.  
  5794.       for (unsigned i = 0; i < num_variables; i++) {
  5795.          ir_variable *var =
  5796.             new(state) ir_variable(fields[i].type,
  5797.                                    ralloc_strdup(state, fields[i].name),
  5798.                                    var_mode);
  5799.          var->data.interpolation = fields[i].interpolation;
  5800.          var->data.centroid = fields[i].centroid;
  5801.          var->data.sample = fields[i].sample;
  5802.          var->init_interface_type(block_type);
  5803.  
  5804.          if (var_mode == ir_var_shader_in || var_mode == ir_var_uniform)
  5805.             var->data.read_only = true;
  5806.  
  5807.          if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED) {
  5808.             var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED
  5809.                ? GLSL_MATRIX_LAYOUT_COLUMN_MAJOR : matrix_layout;
  5810.          } else {
  5811.             var->data.matrix_layout = fields[i].matrix_layout;
  5812.          }
  5813.  
  5814.          if (fields[i].stream != -1 &&
  5815.              ((unsigned)fields[i].stream) != this->layout.stream) {
  5816.             _mesa_glsl_error(&loc, state,
  5817.                              "stream layout qualifier on "
  5818.                              "interface block member `%s' does not match "
  5819.                              "the interface block (%d vs %d)",
  5820.                              var->name, fields[i].stream, this->layout.stream);
  5821.          }
  5822.  
  5823.          var->data.stream = this->layout.stream;
  5824.  
  5825.          /* Examine var name here since var may get deleted in the next call */
  5826.          bool var_is_gl_id = is_gl_identifier(var->name);
  5827.  
  5828.          if (redeclaring_per_vertex) {
  5829.             ir_variable *earlier =
  5830.                get_variable_being_redeclared(var, loc, state,
  5831.                                              true /* allow_all_redeclarations */);
  5832.             if (!var_is_gl_id || earlier == NULL) {
  5833.                _mesa_glsl_error(&loc, state,
  5834.                                 "redeclaration of gl_PerVertex can only "
  5835.                                 "include built-in variables");
  5836.             } else if (earlier->data.how_declared == ir_var_declared_normally) {
  5837.                _mesa_glsl_error(&loc, state,
  5838.                                 "`%s' has already been redeclared",
  5839.                                 earlier->name);
  5840.             } else {
  5841.                earlier->data.how_declared = ir_var_declared_in_block;
  5842.                earlier->reinit_interface_type(block_type);
  5843.             }
  5844.             continue;
  5845.          }
  5846.  
  5847.          if (state->symbols->get_variable(var->name) != NULL)
  5848.             _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name);
  5849.  
  5850.          /* Propagate the "binding" keyword into this UBO's fields;
  5851.           * the UBO declaration itself doesn't get an ir_variable unless it
  5852.           * has an instance name.  This is ugly.
  5853.           */
  5854.          var->data.explicit_binding = this->layout.flags.q.explicit_binding;
  5855.          var->data.binding = this->layout.binding;
  5856.  
  5857.          state->symbols->add_variable(var);
  5858.          instructions->push_tail(var);
  5859.       }
  5860.  
  5861.       if (redeclaring_per_vertex && block_type != earlier_per_vertex) {
  5862.          /* From section 7.1 ("Built-in Language Variables") of the GLSL 4.10 spec:
  5863.           *
  5864.           *     It is also a compilation error ... to redeclare a built-in
  5865.           *     block and then use a member from that built-in block that was
  5866.           *     not included in the redeclaration.
  5867.           *
  5868.           * This appears to be a clarification to the behaviour established
  5869.           * for gl_PerVertex by GLSL 1.50, therefore we implement this
  5870.           * behaviour regardless of GLSL version.
  5871.           *
  5872.           * To prevent the shader from using a member that was not included in
  5873.           * the redeclaration, we disable any ir_variables that are still
  5874.           * associated with the old declaration of gl_PerVertex (since we've
  5875.           * already updated all of the variables contained in the new
  5876.           * gl_PerVertex to point to it).
  5877.           *
  5878.           * As a side effect this will prevent
  5879.           * validate_intrastage_interface_blocks() from getting confused and
  5880.           * thinking there are conflicting definitions of gl_PerVertex in the
  5881.           * shader.
  5882.           */
  5883.          foreach_in_list_safe(ir_instruction, node, instructions) {
  5884.             ir_variable *const var = node->as_variable();
  5885.             if (var != NULL &&
  5886.                 var->get_interface_type() == earlier_per_vertex &&
  5887.                 var->data.mode == var_mode) {
  5888.                if (var->data.how_declared == ir_var_declared_normally) {
  5889.                   _mesa_glsl_error(&loc, state,
  5890.                                    "redeclaration of gl_PerVertex cannot "
  5891.                                    "follow a redeclaration of `%s'",
  5892.                                    var->name);
  5893.                }
  5894.                state->symbols->disable_variable(var->name);
  5895.                var->remove();
  5896.             }
  5897.          }
  5898.       }
  5899.    }
  5900.  
  5901.    return NULL;
  5902. }
  5903.  
  5904.  
  5905. ir_rvalue *
  5906. ast_gs_input_layout::hir(exec_list *instructions,
  5907.                          struct _mesa_glsl_parse_state *state)
  5908. {
  5909.    YYLTYPE loc = this->get_location();
  5910.  
  5911.    /* If any geometry input layout declaration preceded this one, make sure it
  5912.     * was consistent with this one.
  5913.     */
  5914.    if (state->gs_input_prim_type_specified &&
  5915.        state->in_qualifier->prim_type != this->prim_type) {
  5916.       _mesa_glsl_error(&loc, state,
  5917.                        "geometry shader input layout does not match"
  5918.                        " previous declaration");
  5919.       return NULL;
  5920.    }
  5921.  
  5922.    /* If any shader inputs occurred before this declaration and specified an
  5923.     * array size, make sure the size they specified is consistent with the
  5924.     * primitive type.
  5925.     */
  5926.    unsigned num_vertices = vertices_per_prim(this->prim_type);
  5927.    if (state->gs_input_size != 0 && state->gs_input_size != num_vertices) {
  5928.       _mesa_glsl_error(&loc, state,
  5929.                        "this geometry shader input layout implies %u vertices"
  5930.                        " per primitive, but a previous input is declared"
  5931.                        " with size %u", num_vertices, state->gs_input_size);
  5932.       return NULL;
  5933.    }
  5934.  
  5935.    state->gs_input_prim_type_specified = true;
  5936.  
  5937.    /* If any shader inputs occurred before this declaration and did not
  5938.     * specify an array size, their size is determined now.
  5939.     */
  5940.    foreach_in_list(ir_instruction, node, instructions) {
  5941.       ir_variable *var = node->as_variable();
  5942.       if (var == NULL || var->data.mode != ir_var_shader_in)
  5943.          continue;
  5944.  
  5945.       /* Note: gl_PrimitiveIDIn has mode ir_var_shader_in, but it's not an
  5946.        * array; skip it.
  5947.        */
  5948.  
  5949.       if (var->type->is_unsized_array()) {
  5950.          if (var->data.max_array_access >= num_vertices) {
  5951.             _mesa_glsl_error(&loc, state,
  5952.                              "this geometry shader input layout implies %u"
  5953.                              " vertices, but an access to element %u of input"
  5954.                              " `%s' already exists", num_vertices,
  5955.                              var->data.max_array_access, var->name);
  5956.          } else {
  5957.             var->type = glsl_type::get_array_instance(var->type->fields.array,
  5958.                                                       num_vertices);
  5959.          }
  5960.       }
  5961.    }
  5962.  
  5963.    return NULL;
  5964. }
  5965.  
  5966.  
  5967. ir_rvalue *
  5968. ast_cs_input_layout::hir(exec_list *instructions,
  5969.                          struct _mesa_glsl_parse_state *state)
  5970. {
  5971.    YYLTYPE loc = this->get_location();
  5972.  
  5973.    /* If any compute input layout declaration preceded this one, make sure it
  5974.     * was consistent with this one.
  5975.     */
  5976.    if (state->cs_input_local_size_specified) {
  5977.       for (int i = 0; i < 3; i++) {
  5978.          if (state->cs_input_local_size[i] != this->local_size[i]) {
  5979.             _mesa_glsl_error(&loc, state,
  5980.                              "compute shader input layout does not match"
  5981.                              " previous declaration");
  5982.             return NULL;
  5983.          }
  5984.       }
  5985.    }
  5986.  
  5987.    /* From the ARB_compute_shader specification:
  5988.     *
  5989.     *     If the local size of the shader in any dimension is greater
  5990.     *     than the maximum size supported by the implementation for that
  5991.     *     dimension, a compile-time error results.
  5992.     *
  5993.     * It is not clear from the spec how the error should be reported if
  5994.     * the total size of the work group exceeds
  5995.     * MAX_COMPUTE_WORK_GROUP_INVOCATIONS, but it seems reasonable to
  5996.     * report it at compile time as well.
  5997.     */
  5998.    GLuint64 total_invocations = 1;
  5999.    for (int i = 0; i < 3; i++) {
  6000.       if (this->local_size[i] > state->ctx->Const.MaxComputeWorkGroupSize[i]) {
  6001.          _mesa_glsl_error(&loc, state,
  6002.                           "local_size_%c exceeds MAX_COMPUTE_WORK_GROUP_SIZE"
  6003.                           " (%d)", 'x' + i,
  6004.                           state->ctx->Const.MaxComputeWorkGroupSize[i]);
  6005.          break;
  6006.       }
  6007.       total_invocations *= this->local_size[i];
  6008.       if (total_invocations >
  6009.           state->ctx->Const.MaxComputeWorkGroupInvocations) {
  6010.          _mesa_glsl_error(&loc, state,
  6011.                           "product of local_sizes exceeds "
  6012.                           "MAX_COMPUTE_WORK_GROUP_INVOCATIONS (%d)",
  6013.                           state->ctx->Const.MaxComputeWorkGroupInvocations);
  6014.          break;
  6015.       }
  6016.    }
  6017.  
  6018.    state->cs_input_local_size_specified = true;
  6019.    for (int i = 0; i < 3; i++)
  6020.       state->cs_input_local_size[i] = this->local_size[i];
  6021.  
  6022.    /* We may now declare the built-in constant gl_WorkGroupSize (see
  6023.     * builtin_variable_generator::generate_constants() for why we didn't
  6024.     * declare it earlier).
  6025.     */
  6026.    ir_variable *var = new(state->symbols)
  6027.       ir_variable(glsl_type::uvec3_type, "gl_WorkGroupSize", ir_var_auto);
  6028.    var->data.how_declared = ir_var_declared_implicitly;
  6029.    var->data.read_only = true;
  6030.    instructions->push_tail(var);
  6031.    state->symbols->add_variable(var);
  6032.    ir_constant_data data;
  6033.    memset(&data, 0, sizeof(data));
  6034.    for (int i = 0; i < 3; i++)
  6035.       data.u[i] = this->local_size[i];
  6036.    var->constant_value = new(var) ir_constant(glsl_type::uvec3_type, &data);
  6037.    var->constant_initializer =
  6038.       new(var) ir_constant(glsl_type::uvec3_type, &data);
  6039.    var->data.has_initializer = true;
  6040.  
  6041.    return NULL;
  6042. }
  6043.  
  6044.  
  6045. static void
  6046. detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
  6047.                                exec_list *instructions)
  6048. {
  6049.    bool gl_FragColor_assigned = false;
  6050.    bool gl_FragData_assigned = false;
  6051.    bool user_defined_fs_output_assigned = false;
  6052.    ir_variable *user_defined_fs_output = NULL;
  6053.  
  6054.    /* It would be nice to have proper location information. */
  6055.    YYLTYPE loc;
  6056.    memset(&loc, 0, sizeof(loc));
  6057.  
  6058.    foreach_in_list(ir_instruction, node, instructions) {
  6059.       ir_variable *var = node->as_variable();
  6060.  
  6061.       if (!var || !var->data.assigned)
  6062.          continue;
  6063.  
  6064.       if (strcmp(var->name, "gl_FragColor") == 0)
  6065.          gl_FragColor_assigned = true;
  6066.       else if (strcmp(var->name, "gl_FragData") == 0)
  6067.          gl_FragData_assigned = true;
  6068.       else if (!is_gl_identifier(var->name)) {
  6069.          if (state->stage == MESA_SHADER_FRAGMENT &&
  6070.              var->data.mode == ir_var_shader_out) {
  6071.             user_defined_fs_output_assigned = true;
  6072.             user_defined_fs_output = var;
  6073.          }
  6074.       }
  6075.    }
  6076.  
  6077.    /* From the GLSL 1.30 spec:
  6078.     *
  6079.     *     "If a shader statically assigns a value to gl_FragColor, it
  6080.     *      may not assign a value to any element of gl_FragData. If a
  6081.     *      shader statically writes a value to any element of
  6082.     *      gl_FragData, it may not assign a value to
  6083.     *      gl_FragColor. That is, a shader may assign values to either
  6084.     *      gl_FragColor or gl_FragData, but not both. Multiple shaders
  6085.     *      linked together must also consistently write just one of
  6086.     *      these variables.  Similarly, if user declared output
  6087.     *      variables are in use (statically assigned to), then the
  6088.     *      built-in variables gl_FragColor and gl_FragData may not be
  6089.     *      assigned to. These incorrect usages all generate compile
  6090.     *      time errors."
  6091.     */
  6092.    if (gl_FragColor_assigned && gl_FragData_assigned) {
  6093.       _mesa_glsl_error(&loc, state, "fragment shader writes to both "
  6094.                        "`gl_FragColor' and `gl_FragData'");
  6095.    } else if (gl_FragColor_assigned && user_defined_fs_output_assigned) {
  6096.       _mesa_glsl_error(&loc, state, "fragment shader writes to both "
  6097.                        "`gl_FragColor' and `%s'",
  6098.                        user_defined_fs_output->name);
  6099.    } else if (gl_FragData_assigned && user_defined_fs_output_assigned) {
  6100.       _mesa_glsl_error(&loc, state, "fragment shader writes to both "
  6101.                        "`gl_FragData' and `%s'",
  6102.                        user_defined_fs_output->name);
  6103.    }
  6104. }
  6105.  
  6106.  
  6107. static void
  6108. remove_per_vertex_blocks(exec_list *instructions,
  6109.                          _mesa_glsl_parse_state *state, ir_variable_mode mode)
  6110. {
  6111.    /* Find the gl_PerVertex interface block of the appropriate (in/out) mode,
  6112.     * if it exists in this shader type.
  6113.     */
  6114.    const glsl_type *per_vertex = NULL;
  6115.    switch (mode) {
  6116.    case ir_var_shader_in:
  6117.       if (ir_variable *gl_in = state->symbols->get_variable("gl_in"))
  6118.          per_vertex = gl_in->get_interface_type();
  6119.       break;
  6120.    case ir_var_shader_out:
  6121.       if (ir_variable *gl_Position =
  6122.           state->symbols->get_variable("gl_Position")) {
  6123.          per_vertex = gl_Position->get_interface_type();
  6124.       }
  6125.       break;
  6126.    default:
  6127.       assert(!"Unexpected mode");
  6128.       break;
  6129.    }
  6130.  
  6131.    /* If we didn't find a built-in gl_PerVertex interface block, then we don't
  6132.     * need to do anything.
  6133.     */
  6134.    if (per_vertex == NULL)
  6135.       return;
  6136.  
  6137.    /* If the interface block is used by the shader, then we don't need to do
  6138.     * anything.
  6139.     */
  6140.    interface_block_usage_visitor v(mode, per_vertex);
  6141.    v.run(instructions);
  6142.    if (v.usage_found())
  6143.       return;
  6144.  
  6145.    /* Remove any ir_variable declarations that refer to the interface block
  6146.     * we're removing.
  6147.     */
  6148.    foreach_in_list_safe(ir_instruction, node, instructions) {
  6149.       ir_variable *const var = node->as_variable();
  6150.       if (var != NULL && var->get_interface_type() == per_vertex &&
  6151.           var->data.mode == mode) {
  6152.          state->symbols->disable_variable(var->name);
  6153.          var->remove();
  6154.       }
  6155.    }
  6156. }
  6157.