glsl-optimizer/src/compiler/glsl/ast_to

Bug Summary

File:	root/firefox-clang/third_party/rust/glslopt/glsl-optimizer/src/compiler/glsl/ast_to_hir.cpp
Warning:	line 3888, column 18 Null pointer passed to 1st parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ast_to_hir.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/third_party/rust/glslopt -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/root/firefox-clang/third_party/rust/glslopt -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I glsl-optimizer/include -I glsl-optimizer/src/mesa -I glsl-optimizer/src/mapi -I glsl-optimizer/src/compiler -I glsl-optimizer/src/compiler/glsl -I glsl-optimizer/src/gallium/auxiliary -I glsl-optimizer/src/gallium/include -I glsl-optimizer/src -I glsl-optimizer/src/util -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -D MOZILLA_CONFIG_H -D __STDC_FORMAT_MACROS -D _GNU_SOURCE -D HAVE_ENDIAN_H -D HAVE_PTHREAD -D HAVE_TIMESPEC_GET -D MOZ_INCLUDE_MOZALLOC_H -D mozilla_throw_gcc_h -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ glsl-optimizer/src/compiler/glsl/ast_to_hir.cpp

1/*
* Copyright © 2010 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/

24/**
* \file ast_to_hir.c
* Convert abstract syntax to to high-level intermediate reprensentation (HIR).
*
* During the conversion to HIR, the majority of the symantic checking is
* preformed on the program.  This includes:
*
*    * Symbol table management
*    * Type checking
*    * Function binding
*
* The majority of this work could be done during parsing, and the parser could
* probably generate HIR directly.  However, this results in frequent changes
* to the parser code.  Since we do not assume that every system this complier
* is built on will have Flex and Bison installed, we have to store the code
* generated by these tools in our version control system.  In other parts of
* the system we've seen problems where a parser was changed but the generated
* code was not committed, merge conflicts where created because two developers
* had slightly different versions of Bison installed, etc.
*
* I have also noticed that running Bison generated parsers in GDB is very
* irritating.  When you get a segfault on '$$ = $1->foo', you can't very
* well 'print $1' in GDB.
*
* As a result, my preference is to put as little C code as possible in the
* parser (and lexer) sources.
*/

52#include "glsl_symbol_table.h"
53#include "glsl_parser_extras.h"
54#include "ast.h"
55#include "compiler/glsl_types.h"
56#include "util/hash_table.h"
57#include "main/mtypes.h"
58#include "main/macros.h"
59#include "main/shaderobj.h"
60#include "ir.h"
61#include "ir_builder.h"
62#include "builtin_functions.h"

64using namespace ir_builder;

66static void
67detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
                             exec_list *instructions);
69static void
70verify_subroutine_associated_funcs(struct _mesa_glsl_parse_state *state);

72static void
73remove_per_vertex_blocks(exec_list *instructions,
                       _mesa_glsl_parse_state *state, ir_variable_mode mode);

76/**
* Visitor class that finds the first instance of any write-only variable that
* is ever read, if any
*/
80class read_from_write_only_variable_visitor : public ir_hierarchical_visitor
81{
82public:
 read_from_write_only_variable_visitor() : found(NULL__null)
 {
 }

 virtual ir_visitor_status visit(ir_dereference_variable *ir)
 {
    if (this->in_assignee)
       return visit_continue;

    ir_variable *var = ir->variable_referenced();
    /* We can have memory_write_only set on both images and buffer variables,
     * but in the former there is a distinction between reads from
     * the variable itself (write_only) and from the memory they point to
     * (memory_write_only), while in the case of buffer variables there is
     * no such distinction, that is why this check here is limited to
     * buffer variables alone.
     */
    if (!var || var->data.mode != ir_var_shader_storage)
       return visit_continue;

    if (var->data.memory_write_only) {
       found = var;
       return visit_stop;
    }

    return visit_continue;
 }

 ir_variable *get_variable() {
    return found;
 }

 virtual ir_visitor_status visit_enter(ir_expression *ir)
 {
    /* .length() doesn't actually read anything */
    if (ir->operation == ir_unop_ssbo_unsized_array_length)
       return visit_continue_with_parent;

    return visit_continue;
 }

124private:
 ir_variable *found;
126};

128void
129_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
130{
 _mesa_glsl_initialize_variables(instructions, state);

 state->symbols->separate_function_namespace = state->language_version == 110;

 state->current_function = NULL__null;

 state->toplevel_ir = instructions;

 state->gs_input_prim_type_specified = false;
 state->tcs_output_vertices_specified = false;
 state->cs_input_local_size_specified = false;

 /* Section 4.2 of the GLSL 1.20 specification states:
  * "The built-in functions are scoped in a scope outside the global scope
  *  users declare global variables in.  That is, a shader's global scope,
  *  available for user-defined functions and global variables, is nested
  *  inside the scope containing the built-in functions."
  *
  * Since built-in functions like ftransform() access built-in variables,
  * it follows that those must be in the outer scope as well.
  *
  * We push scope here to create this nesting effect...but don't pop.
  * This way, a shader's globals are still in the symbol table for use
  * by the linker.
  */
 state->symbols->push_scope();

 foreach_list_typed (ast_node, ast, link, & state->translation_unit)for (ast_node * ast = (!exec_node_is_tail_sentinel((& state
->translation_unit)->head_sentinel.next) ? ((ast_node *
) (((uintptr_t) (& state->translation_unit)->head_sentinel
.next) - (((char *) &((ast_node *) (& state->translation_unit
)->head_sentinel.next)->link) - ((char *) (& state->
translation_unit)->head_sentinel.next)))) : __null); (ast)
 != __null; (ast) = (!exec_node_is_tail_sentinel((ast)->link
.next) ? ((ast_node *) (((uintptr_t) (ast)->link.next) - (
((char *) &((ast_node *) (ast)->link.next)->link) -
 ((char *) (ast)->link.next)))) : __null))
    ast->hir(instructions, state);

 verify_subroutine_associated_funcs(state);
 detect_recursion_unlinked(state, instructions);
 detect_conflicting_assignments(state, instructions);

 state->toplevel_ir = NULL__null;

 /* Move all of the variable declarations to the front of the IR list, and
  * reverse the order.  This has the (intended!) side effect that vertex
  * shader inputs and fragment shader outputs will appear in the IR in the
  * same order that they appeared in the shader code.  This results in the
  * locations being assigned in the declared order.  Many (arguably buggy)
  * applications depend on this behavior, and it matches what nearly all
  * other drivers do.
  * However, do not push the declarations before struct decls or precision
  * statements.
  */
 ir_instruction* before_node = (ir_instruction*)instructions->get_head();
 ir_instruction* after_node = NULL__null;
 while (before_node && (before_node->ir_type == ir_type_precision || before_node->ir_type == ir_type_typedecl))
 {
    after_node = before_node;
    before_node = (ir_instruction*)before_node->next;
 }

 foreach_in_list_safe(ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null), *__next = (node) ? (!exec_node_is_tail_sentinel
((instructions)->head_sentinel.next->next) ? (ir_instruction
 *) ((instructions)->head_sentinel.next->next) : __null
) : __null; (node) != __null; (node) = __next, __next = __next
 ? (!exec_node_is_tail_sentinel(__next->next) ? (ir_instruction
 *) (__next->next) : __null) : __null) {
    ir_variable *const var = node->as_variable();

    if (var == NULL__null)
       continue;

    var->remove();
    if (after_node)
       after_node->insert_after(var);
    else
       instructions->push_head(var);
 }

 /* Figure out if gl_FragCoord is actually used in fragment shader */
 ir_variable *const var = state->symbols->get_variable("gl_FragCoord");
 if (var != NULL__null)
    state->fs_uses_gl_fragcoord = var->data.used;

 /* From section 7.1 (Built-In Language Variables) of the GLSL 4.10 spec:
  *
  *     If multiple shaders using members of a built-in block belonging to
  *     the same interface are linked together in the same program, they
  *     must all redeclare the built-in block in the same way, as described
  *     in section 4.3.7 "Interface Blocks" for interface block matching, or
  *     a link error will result.
  *
  * The phrase "using members of a built-in block" implies that if two
  * shaders are linked together and one of them *does not use* any members
  * of the built-in block, then that shader does not need to have a matching
  * redeclaration of the built-in block.
  *
  * This appears to be a clarification to the behaviour established for
  * gl_PerVertex by GLSL 1.50, therefore implement it regardless of GLSL
  * version.
  *
  * The definition of "interface" in section 4.3.7 that applies here is as
  * follows:
  *
  *     The boundary between adjacent programmable pipeline stages: This
  *     spans all the outputs in all compilation units of the first stage
  *     and all the inputs in all compilation units of the second stage.
  *
  * Therefore this rule applies to both inter- and intra-stage linking.
  *
  * The easiest way to implement this is to check whether the shader uses
  * gl_PerVertex right after ast-to-ir conversion, and if it doesn't, simply
  * remove all the relevant variable declaration from the IR, so that the
  * linker won't see them and complain about mismatches.
  */
 remove_per_vertex_blocks(instructions, state, ir_var_shader_in);
 remove_per_vertex_blocks(instructions, state, ir_var_shader_out);

 /* Check that we don't have reads from write-only variables */
 read_from_write_only_variable_visitor v;
 v.run(instructions);
 ir_variable *error_var = v.get_variable();
 if (error_var) {
    /* It would be nice to have proper location information, but for that
     * we would need to check this as we process each kind of AST node
     */
    YYLTYPE loc;
    memset(&loc, 0, sizeof(loc));
    _mesa_glsl_error(&loc, state, "Read from write-only variable `%s'",
                     error_var->name);
 }
250}


253static ir_expression_operation
254get_implicit_conversion_operation(const glsl_type *to, const glsl_type *from,
                                struct _mesa_glsl_parse_state *state)
256{
 switch (to->base_type) {
 case GLSL_TYPE_FLOAT:
    switch (from->base_type) {
    case GLSL_TYPE_INT: return ir_unop_i2f;
    case GLSL_TYPE_UINT: return ir_unop_u2f;
    default: return (ir_expression_operation)0;
    }

 case GLSL_TYPE_UINT:
    if (!state->has_implicit_uint_to_int_conversion())
       return (ir_expression_operation)0;
    switch (from->base_type) {
       case GLSL_TYPE_INT: return ir_unop_i2u;
       default: return (ir_expression_operation)0;
    }

 case GLSL_TYPE_DOUBLE:
    if (!state->has_double())
       return (ir_expression_operation)0;
    switch (from->base_type) {
    case GLSL_TYPE_INT: return ir_unop_i2d;
    case GLSL_TYPE_UINT: return ir_unop_u2d;
    case GLSL_TYPE_FLOAT: return ir_unop_f2d;
    case GLSL_TYPE_INT64: return ir_unop_i642d;
    case GLSL_TYPE_UINT64: return ir_unop_u642d;
    default: return (ir_expression_operation)0;
    }

 case GLSL_TYPE_UINT64:
    if (!state->has_int64())
       return (ir_expression_operation)0;
    switch (from->base_type) {
    case GLSL_TYPE_INT: return ir_unop_i2u64;
    case GLSL_TYPE_UINT: return ir_unop_u2u64;
    case GLSL_TYPE_INT64: return ir_unop_i642u64;
    default: return (ir_expression_operation)0;
    }

 case GLSL_TYPE_INT64:
    if (!state->has_int64())
       return (ir_expression_operation)0;
    switch (from->base_type) {
    case GLSL_TYPE_INT: return ir_unop_i2i64;
    default: return (ir_expression_operation)0;
    }

 default: return (ir_expression_operation)0;
 }
305}


308/**
* If a conversion is available, convert one operand to a different type
*
* The \c from \c ir_rvalue is converted "in place".
*
* \param to     Type that the operand it to be converted to
* \param from   Operand that is being converted
* \param state  GLSL compiler state
*
* \return
* If a conversion is possible (or unnecessary), \c true is returned.
* Otherwise \c false is returned.
*/
321static bool
322apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
                        struct _mesa_glsl_parse_state *state)
324{
 void *ctx = state;
 if (to->base_type == from->type->base_type)
    return true;

 /* Prior to GLSL 1.20, there are no implicit conversions */
 if (!state->has_implicit_conversions())
    return false;

 /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
  *
  *    "There are no implicit array or structure conversions. For
  *    example, an array of int cannot be implicitly converted to an
  *    array of float.
  */
 if (!to->is_numeric() || !from->type->is_numeric())
    return false;

 /* We don't actually want the specific type `to`, we want a type
  * with the same base type as `to`, but the same vector width as
  * `from`.
  */
 to = glsl_type::get_instance(to->base_type, from->type->vector_elements,
                              from->type->matrix_columns);

 ir_expression_operation op = get_implicit_conversion_operation(to, from->type, state);
 if (op) {
    from = new(ctx) ir_expression(op, to, from, NULL__null);
    return true;
 } else {
    return false;
 }
356}


359static const struct glsl_type *
360arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
                     bool multiply,
                     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
363{
 const glsl_type *type_a = value_a->type;
 const glsl_type *type_b = value_b->type;

 /* From GLSL 1.50 spec, page 56:
  *
  *    "The arithmetic binary operators add (+), subtract (-),
  *    multiply (*), and divide (/) operate on integer and
  *    floating-point scalars, vectors, and matrices."
  */
 if (!type_a->is_numeric() || !type_b->is_numeric()) {
    _mesa_glsl_error(loc, state,
                     "operands to arithmetic operators must be numeric");
    return glsl_type::error_type;
 }


 /*    "If one operand is floating-point based and the other is
  *    not, then the conversions from Section 4.1.10 "Implicit
  *    Conversions" are applied to the non-floating-point-based operand."
  */
 if (!apply_implicit_conversion(type_a, value_b, state)
     && !apply_implicit_conversion(type_b, value_a, state)) {
    _mesa_glsl_error(loc, state,
                     "could not implicitly convert operands to "
                     "arithmetic operator");
    return glsl_type::error_type;
 }
 type_a = value_a->type;
 type_b = value_b->type;

 /*    "If the operands are integer types, they must both be signed or
  *    both be unsigned."
  *
  * From this rule and the preceeding conversion it can be inferred that
  * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
  * The is_numeric check above already filtered out the case where either
  * type is not one of these, so now the base types need only be tested for
  * equality.
  */
 if (type_a->base_type != type_b->base_type) {
    _mesa_glsl_error(loc, state,
                     "base type mismatch for arithmetic operator");
    return glsl_type::error_type;
 }

 /*    "All arithmetic binary operators result in the same fundamental type
  *    (signed integer, unsigned integer, or floating-point) as the
  *    operands they operate on, after operand type conversion. After
  *    conversion, the following cases are valid
  *
  *    * The two operands are scalars. In this case the operation is
  *      applied, resulting in a scalar."
  */
 if (type_a->is_scalar() && type_b->is_scalar())
    return type_a;

 /*   "* One operand is a scalar, and the other is a vector or matrix.
  *      In this case, the scalar operation is applied independently to each
  *      component of the vector or matrix, resulting in the same size
  *      vector or matrix."
  */
 if (type_a->is_scalar()) {
    if (!type_b->is_scalar())
       return type_b;
 } else if (type_b->is_scalar()) {
    return type_a;
 }

 /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
  * handled.
  */
 assert(!type_a->is_scalar())(static_cast <bool> (!type_a->is_scalar()) ? void (0
) : __assert_fail ("!type_a->is_scalar()", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
 assert(!type_b->is_scalar())(static_cast <bool> (!type_b->is_scalar()) ? void (0
) : __assert_fail ("!type_b->is_scalar()", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

 /*   "* The two operands are vectors of the same size. In this case, the
  *      operation is done component-wise resulting in the same size
  *      vector."
  */
 if (type_a->is_vector() && type_b->is_vector()) {
    if (type_a == type_b) {
       return type_a;
    } else {
       _mesa_glsl_error(loc, state,
                        "vector size mismatch for arithmetic operator");
       return glsl_type::error_type;
    }
 }

 /* All of the combinations of <scalar, scalar>, <vector, scalar>,
  * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
  * <vector, vector> have been handled.  At least one of the operands must
  * be matrix.  Further, since there are no integer matrix types, the base
  * type of both operands must be float.
  */
 assert(type_a->is_matrix() || type_b->is_matrix())(static_cast <bool> (type_a->is_matrix() || type_b->
is_matrix()) ? void (0) : __assert_fail ("type_a->is_matrix() || type_b->is_matrix()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
 assert(type_a->is_float() || type_a->is_double())(static_cast <bool> (type_a->is_float() || type_a->
is_double()) ? void (0) : __assert_fail ("type_a->is_float() || type_a->is_double()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
 assert(type_b->is_float() || type_b->is_double())(static_cast <bool> (type_b->is_float() || type_b->
is_double()) ? void (0) : __assert_fail ("type_b->is_float() || type_b->is_double()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

 /*   "* The operator is add (+), subtract (-), or divide (/), and the
  *      operands are matrices with the same number of rows and the same
  *      number of columns. In this case, the operation is done component-
  *      wise resulting in the same size matrix."
  *    * The operator is multiply (*), where both operands are matrices or
  *      one operand is a vector and the other a matrix. A right vector
  *      operand is treated as a column vector and a left vector operand as a
  *      row vector. In all these cases, it is required that the number of
  *      columns of the left operand is equal to the number of rows of the
  *      right operand. Then, the multiply (*) operation does a linear
  *      algebraic multiply, yielding an object that has the same number of
  *      rows as the left operand and the same number of columns as the right
  *      operand. Section 5.10 "Vector and Matrix Operations" explains in
  *      more detail how vectors and matrices are operated on."
  */
 if (! multiply) {
    if (type_a == type_b)
       return type_a;
 } else {
    const glsl_type *type = glsl_type::get_mul_type(type_a, type_b);

    if (type == glsl_type::error_type) {
       _mesa_glsl_error(loc, state,
                        "size mismatch for matrix multiplication");
    }

    return type;
 }


 /*    "All other cases are illegal."
  */
 _mesa_glsl_error(loc, state, "type mismatch");
 return glsl_type::error_type;
497}


500static const struct glsl_type *
501unary_arithmetic_result_type(const struct glsl_type *type,
                           struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
503{
 /* From GLSL 1.50 spec, page 57:
  *
  *    "The arithmetic unary operators negate (-), post- and pre-increment
  *     and decrement (-- and ++) operate on integer or floating-point
  *     values (including vectors and matrices). All unary operators work
  *     component-wise on their operands. These result with the same type
  *     they operated on."
  */
 if (!type->is_numeric()) {
    _mesa_glsl_error(loc, state,
                     "operands to arithmetic operators must be numeric");
    return glsl_type::error_type;
 }

 return type;
519}

521/**
* \brief Return the result type of a bit-logic operation.
*
* If the given types to the bit-logic operator are invalid, return
* glsl_type::error_type.
*
* \param value_a LHS of bit-logic op
* \param value_b RHS of bit-logic op
*/
530static const struct glsl_type *
531bit_logic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
                    ast_operators op,
                    struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
534{
 const glsl_type *type_a = value_a->type;
 const glsl_type *type_b = value_b->type;

 if (!state->check_bitwise_operations_allowed(loc)) {
    return glsl_type::error_type;
 }

 /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:
  *
  *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or
  *     (|). The operands must be of type signed or unsigned integers or
  *     integer vectors."
  */
 if (!type_a->is_integer_32_64()) {
    _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",
                      ast_expression::operator_string(op));
    return glsl_type::error_type;
 }
 if (!type_b->is_integer_32_64()) {
    _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",
                     ast_expression::operator_string(op));
    return glsl_type::error_type;
 }

 /* Prior to GLSL 4.0 / GL_ARB_gpu_shader5, implicit conversions didn't
  * make sense for bitwise operations, as they don't operate on floats.
  *
  * GLSL 4.0 added implicit int -> uint conversions, which are relevant
  * here.  It wasn't clear whether or not we should apply them to bitwise
  * operations.  However, Khronos has decided that they should in future
  * language revisions.  Applications also rely on this behavior.  We opt
  * to apply them in general, but issue a portability warning.
  *
  * See https://www.khronos.org/bugzilla/show_bug.cgi?id=1405
  */
 if (type_a->base_type != type_b->base_type) {
    if (!apply_implicit_conversion(type_a, value_b, state)
        && !apply_implicit_conversion(type_b, value_a, state)) {
       _mesa_glsl_error(loc, state,
                        "could not implicitly convert operands to "
                        "`%s` operator",
                        ast_expression::operator_string(op));
       return glsl_type::error_type;
    } else {
       _mesa_glsl_warning(loc, state,
                          "some implementations may not support implicit "
                          "int -> uint conversions for `%s' operators; "
                          "consider casting explicitly for portability",
                          ast_expression::operator_string(op));
    }
    type_a = value_a->type;
    type_b = value_b->type;
 }

 /*     "The fundamental types of the operands (signed or unsigned) must
  *     match,"
  */
 if (type_a->base_type != type_b->base_type) {
    _mesa_glsl_error(loc, state, "operands of `%s' must have the same "
                     "base type", ast_expression::operator_string(op));
    return glsl_type::error_type;
 }

 /*     "The operands cannot be vectors of differing size." */
 if (type_a->is_vector() &&
     type_b->is_vector() &&
     type_a->vector_elements != type_b->vector_elements) {
    _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "
                     "different sizes", ast_expression::operator_string(op));
    return glsl_type::error_type;
 }

 /*     "If one operand is a scalar and the other a vector, the scalar is
  *     applied component-wise to the vector, resulting in the same type as
  *     the vector. The fundamental types of the operands [...] will be the
  *     resulting fundamental type."
  */
 if (type_a->is_scalar())
     return type_b;
 else
     return type_a;
616}

618static const struct glsl_type *
619modulus_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
                  struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
621{
 const glsl_type *type_a = value_a->type;
 const glsl_type *type_b = value_b->type;

 if (!state->EXT_gpu_shader4_enable &&
     !state->check_version(130, 300, loc, "operator '%%' is reserved")) {
    return glsl_type::error_type;
 }

 /* Section 5.9 (Expressions) of the GLSL 4.00 specification says:
  *
  *    "The operator modulus (%) operates on signed or unsigned integers or
  *    integer vectors."
  */
 if (!type_a->is_integer_32_64()) {
    _mesa_glsl_error(loc, state, "LHS of operator %% must be an integer");
    return glsl_type::error_type;
 }
 if (!type_b->is_integer_32_64()) {
    _mesa_glsl_error(loc, state, "RHS of operator %% must be an integer");
    return glsl_type::error_type;
 }

 /*    "If the fundamental types in the operands do not match, then the
  *    conversions from section 4.1.10 "Implicit Conversions" are applied
  *    to create matching types."
  *
  * Note that GLSL 4.00 (and GL_ARB_gpu_shader5) introduced implicit
  * int -> uint conversion rules.  Prior to that, there were no implicit
  * conversions.  So it's harmless to apply them universally - no implicit
  * conversions will exist.  If the types don't match, we'll receive false,
  * and raise an error, satisfying the GLSL 1.50 spec, page 56:
  *
  *    "The operand types must both be signed or unsigned."
  */
 if (!apply_implicit_conversion(type_a, value_b, state) &&
     !apply_implicit_conversion(type_b, value_a, state)) {
    _mesa_glsl_error(loc, state,
                     "could not implicitly convert operands to "
                     "modulus (%%) operator");
    return glsl_type::error_type;
 }
 type_a = value_a->type;
 type_b = value_b->type;

 /*    "The operands cannot be vectors of differing size. If one operand is
  *    a scalar and the other vector, then the scalar is applied component-
  *    wise to the vector, resulting in the same type as the vector. If both
  *    are vectors of the same size, the result is computed component-wise."
  */
 if (type_a->is_vector()) {
    if (!type_b->is_vector()
        || (type_a->vector_elements == type_b->vector_elements))
    return type_a;
 } else
    return type_b;

 /*    "The operator modulus (%) is not defined for any other data types
  *    (non-integer types)."
  */
 _mesa_glsl_error(loc, state, "type mismatch");
 return glsl_type::error_type;
683}


686static const struct glsl_type *
687relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
                     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
689{
 const glsl_type *type_a = value_a->type;
 const glsl_type *type_b = value_b->type;

 /* From GLSL 1.50 spec, page 56:
  *    "The relational operators greater than (>), less than (<), greater
  *    than or equal (>=), and less than or equal (<=) operate only on
  *    scalar integer and scalar floating-point expressions."
  */
 if (!type_a->is_numeric()
     || !type_b->is_numeric()
     || !type_a->is_scalar()
     || !type_b->is_scalar()) {
    _mesa_glsl_error(loc, state,
                     "operands to relational operators must be scalar and "
                     "numeric");
    return glsl_type::error_type;
 }

 /*    "Either the operands' types must match, or the conversions from
  *    Section 4.1.10 "Implicit Conversions" will be applied to the integer
  *    operand, after which the types must match."
  */
 if (!apply_implicit_conversion(type_a, value_b, state)
     && !apply_implicit_conversion(type_b, value_a, state)) {
    _mesa_glsl_error(loc, state,
                     "could not implicitly convert operands to "
                     "relational operator");
    return glsl_type::error_type;
 }
 type_a = value_a->type;
 type_b = value_b->type;

 if (type_a->base_type != type_b->base_type) {
    _mesa_glsl_error(loc, state, "base type mismatch");
    return glsl_type::error_type;
 }

 /*    "The result is scalar Boolean."
  */
 return glsl_type::bool_type;
730}

732/**
* \brief Return the result type of a bit-shift operation.
*
* If the given types to the bit-shift operator are invalid, return
* glsl_type::error_type.
*
* \param type_a Type of LHS of bit-shift op
* \param type_b Type of RHS of bit-shift op
*/
741static const struct glsl_type *
742shift_result_type(const struct glsl_type *type_a,
                const struct glsl_type *type_b,
                ast_operators op,
                struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
746{
 if (!state->check_bitwise_operations_allowed(loc)) {
    return glsl_type::error_type;
 }

 /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:
  *
  *     "The shift operators (<<) and (>>). For both operators, the operands
  *     must be signed or unsigned integers or integer vectors. One operand
  *     can be signed while the other is unsigned."
  */
 if (!type_a->is_integer_32_64()) {
    _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
                     "integer vector", ast_expression::operator_string(op));
   return glsl_type::error_type;

 }
 if (!type_b->is_integer_32()) {
    _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
                     "integer vector", ast_expression::operator_string(op));
   return glsl_type::error_type;
 }

 /*     "If the first operand is a scalar, the second operand has to be
  *     a scalar as well."
  */
 if (type_a->is_scalar() && !type_b->is_scalar()) {
    _mesa_glsl_error(loc, state, "if the first operand of %s is scalar, the "
                     "second must be scalar as well",
                     ast_expression::operator_string(op));
   return glsl_type::error_type;
 }

 /* If both operands are vectors, check that they have same number of
  * elements.
  */
 if (type_a->is_vector() &&
    type_b->is_vector() &&
    type_a->vector_elements != type_b->vector_elements) {
    _mesa_glsl_error(loc, state, "vector operands to operator %s must "
                     "have same number of elements",
                     ast_expression::operator_string(op));
   return glsl_type::error_type;
 }

 /*     "In all cases, the resulting type will be the same type as the left
  *     operand."
  */
 return type_a;
795}

797/**
* Returns the innermost array index expression in an rvalue tree.
* This is the largest indexing level -- if an array of blocks, then
* it is the block index rather than an indexing expression for an
* array-typed member of an array of blocks.
*/
803static ir_rvalue *
804find_innermost_array_index(ir_rvalue *rv)
805{
 ir_dereference_array *last = NULL__null;
 while (rv) {
    if (rv->as_dereference_array()) {
       last = rv->as_dereference_array();
       rv = last->array;
    } else if (rv->as_dereference_record())
       rv = rv->as_dereference_record()->record;
    else if (rv->as_swizzle())
       rv = rv->as_swizzle()->val;
    else
       rv = NULL__null;
 }

 if (last)
    return last->array_index;

 return NULL__null;
823}

825/**
* Validates that a value can be assigned to a location with a specified type
*
* Validates that \c rhs can be assigned to some location.  If the types are
* not an exact match but an automatic conversion is possible, \c rhs will be
* converted.
*
* \return
* \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
* Otherwise the actual RHS to be assigned will be returned.  This may be
* \c rhs, or it may be \c rhs after some type conversion.
*
* \note
* In addition to being used for assignments, this function is used to
* type-check return values.
*/
841static ir_rvalue *
842validate_assignment(struct _mesa_glsl_parse_state *state,
                  YYLTYPE loc, ir_rvalue *lhs,
                  ir_rvalue *rhs, bool is_initializer)
845{
 /* If there is already some error in the RHS, just return it.  Anything
  * else will lead to an avalanche of error message back to the user.
  */
 if (rhs->type->is_error())
    return rhs;

 /* In the Tessellation Control Shader:
  * If a per-vertex output variable is used as an l-value, it is an error
  * if the expression indicating the vertex number is not the identifier
  * `gl_InvocationID`.
  */
 if (state->stage == MESA_SHADER_TESS_CTRL && !lhs->type->is_error()) {
    ir_variable *var = lhs->variable_referenced();
    if (var && var->data.mode == ir_var_shader_out && !var->data.patch) {
       ir_rvalue *index = find_innermost_array_index(lhs);
       ir_variable *index_var = index ? index->variable_referenced() : NULL__null;
       if (!index_var || strcmp(index_var->name, "gl_InvocationID") != 0) {
          _mesa_glsl_error(&loc, state,
                           "Tessellation control shader outputs can only "
                           "be indexed by gl_InvocationID");
          return NULL__null;
       }
    }
 }

 /* If the types are identical, the assignment can trivially proceed.
  */
 if (rhs->type == lhs->type)
    return rhs;

 /* If the array element types are the same and the LHS is unsized,
  * the assignment is okay for initializers embedded in variable
  * declarations.
  *
  * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
  * is handled by ir_dereference::is_lvalue.
  */
 const glsl_type *lhs_t = lhs->type;
 const glsl_type *rhs_t = rhs->type;
 bool unsized_array = false;
 while(lhs_t->is_array()) {
    if (rhs_t == lhs_t)
       break; /* the rest of the inner arrays match so break out early */
    if (!rhs_t->is_array()) {
       unsized_array = false;
       break; /* number of dimensions mismatch */
    }
    if (lhs_t->length == rhs_t->length) {
       lhs_t = lhs_t->fields.array;
       rhs_t = rhs_t->fields.array;
       continue;
    } else if (lhs_t->is_unsized_array()) {
       unsized_array = true;
    } else {
       unsized_array = false;
       break; /* sized array mismatch */
    }
    lhs_t = lhs_t->fields.array;
    rhs_t = rhs_t->fields.array;
 }
 if (unsized_array) {
    if (is_initializer) {
       if (rhs->type->get_scalar_type() == lhs->type->get_scalar_type())
          return rhs;
    } else {
       _mesa_glsl_error(&loc, state,
                        "implicitly sized arrays cannot be assigned");
       return NULL__null;
    }
 }

 /* Check for implicit conversion in GLSL 1.20 */
 if (apply_implicit_conversion(lhs->type, rhs, state)) {
    if (rhs->type == lhs->type)
       return rhs;
 }

 _mesa_glsl_error(&loc, state,
                  "%s of type %s cannot be assigned to "
                  "variable of type %s",
                  is_initializer ? "initializer" : "value",
                  rhs->type->name, lhs->type->name);

 return NULL__null;
930}

932static void
933mark_whole_array_access(ir_rvalue *access)
934{
 ir_dereference_variable *deref = access->as_dereference_variable();

 if (deref && deref->var) {
    deref->var->data.max_array_access = deref->type->length - 1;
 }
940}

942static bool
943do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
            const char *non_lvalue_description,
            ir_rvalue *lhs, ir_rvalue *rhs,
            ir_rvalue **out_rvalue, bool needs_rvalue,
            bool is_initializer,
            YYLTYPE lhs_loc)
949{
 void *ctx = state;
 bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());

 ir_variable *lhs_var = lhs->variable_referenced();
 if (lhs_var)
    lhs_var->data.assigned = true;

 if (!error_emitted) {
    if (non_lvalue_description != NULL__null) {
       _mesa_glsl_error(&lhs_loc, state,
                        "assignment to %s",
                        non_lvalue_description);
       error_emitted = true;
    } else if (lhs_var != NULL__null && (lhs_var->data.read_only ||
               (lhs_var->data.mode == ir_var_shader_storage &&
                lhs_var->data.memory_read_only))) {
       /* We can have memory_read_only set on both images and buffer variables,
        * but in the former there is a distinction between assignments to
        * the variable itself (read_only) and to the memory they point to
        * (memory_read_only), while in the case of buffer variables there is
        * no such distinction, that is why this check here is limited to
        * buffer variables alone.
        */
       _mesa_glsl_error(&lhs_loc, state,
                        "assignment to read-only variable '%s'",
                        lhs_var->name);
       error_emitted = true;
    } else if (lhs->type->is_array() &&
               !state->check_version(120, 300, &lhs_loc,
                                     "whole array assignment forbidden")) {
       /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec:
        *
        *    "Other binary or unary expressions, non-dereferenced
        *     arrays, function names, swizzles with repeated fields,
        *     and constants cannot be l-values."
        *
        * The restriction on arrays is lifted in GLSL 1.20 and GLSL ES 3.00.
        */
       error_emitted = true;
    } else if (!lhs->is_lvalue(state)) {
       _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
       error_emitted = true;
    }
 }

 ir_rvalue *new_rhs =
    validate_assignment(state, lhs_loc, lhs, rhs, is_initializer);
 if (new_rhs != NULL__null) {
    rhs = new_rhs;

    /* If the LHS array was not declared with a size, it takes it size from
     * the RHS.  If the LHS is an l-value and a whole array, it must be a
     * dereference of a variable.  Any other case would require that the LHS
     * is either not an l-value or not a whole array.
     */
    if (lhs->type->is_unsized_array()) {
       ir_dereference *const d = lhs->as_dereference();

       assert(d != NULL)(static_cast <bool> (d != __null) ? void (0) : __assert_fail
 ("d != NULL", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));

       ir_variable *const var = d->variable_referenced();

       assert(var != NULL)(static_cast <bool> (var != __null) ? void (0) : __assert_fail
 ("var != NULL", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));

       if (var->data.max_array_access >= rhs->type->array_size()) {
          /* FINISHME: This should actually log the location of the RHS. */
          _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
                           "previous access",
                           var->data.max_array_access);
       }

       var->type = glsl_type::get_array_instance(lhs->type->fields.array,
                                                 rhs->type->array_size());
       d->type = var->type;
    }
    if (lhs->type->is_array()) {
       mark_whole_array_access(rhs);
       mark_whole_array_access(lhs);
    }
 } else {
   error_emitted = true;
 }

 /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,
  * but not post_inc) need the converted assigned value as an rvalue
  * to handle things like:
  *
  * i = j += 1;
  */
 if (needs_rvalue) {
    ir_rvalue *rvalue;
    if (!error_emitted) {
       ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
                                               ir_var_temporary);
       instructions->push_tail(var);
       instructions->push_tail(assign(var, rhs));

       ir_dereference_variable *deref_var =
          new(ctx) ir_dereference_variable(var);
       instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var));
       rvalue = new(ctx) ir_dereference_variable(var);
    } else {
       rvalue = ir_rvalue::error_value(ctx);
    }
    *out_rvalue = rvalue;
 } else {
    if (!error_emitted)
       instructions->push_tail(new(ctx) ir_assignment(lhs, rhs));
    *out_rvalue = NULL__null;
 }

 return error_emitted;
1062}

1064static ir_rvalue *
1065get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
1066{
 void *ctx = ralloc_parent(lvalue);
 ir_variable *var;

 var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
                            ir_var_temporary);
 instructions->push_tail(var);

 instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
                                                lvalue));

 return new(ctx) ir_dereference_variable(var);
1078}


1081ir_rvalue *
1082ast_node::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
1083{
 (void) instructions;
 (void) state;

 return NULL__null;
1088}

1090bool
1091ast_node::has_sequence_subexpression() const
1092{
 return false;
1094}

1096void
1097ast_node::set_is_lhs(bool /* new_value */)
1098{
1099}

1101void
1102ast_function_expression::hir_no_rvalue(exec_list *instructions,
                                     struct _mesa_glsl_parse_state *state)
1104{
 (void)hir(instructions, state);
1106}

1108void
1109ast_aggregate_initializer::hir_no_rvalue(exec_list *instructions,
                                       struct _mesa_glsl_parse_state *state)
1111{
 (void)hir(instructions, state);
1113}

1115static ir_rvalue *
1116do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
1117{
 int join_op;
 ir_rvalue *cmp = NULL__null;

 if (operation == ir_binop_all_equal)
    join_op = ir_binop_logic_and;
 else
    join_op = ir_binop_logic_or;

 switch (op0->type->base_type) {
 case GLSL_TYPE_FLOAT:
 case GLSL_TYPE_FLOAT16:
 case GLSL_TYPE_UINT:
 case GLSL_TYPE_INT:
 case GLSL_TYPE_BOOL:
 case GLSL_TYPE_DOUBLE:
 case GLSL_TYPE_UINT64:
 case GLSL_TYPE_INT64:
 case GLSL_TYPE_UINT16:
 case GLSL_TYPE_INT16:
 case GLSL_TYPE_UINT8:
 case GLSL_TYPE_INT8:
    return new(mem_ctx) ir_expression(operation, op0, op1);

 case GLSL_TYPE_ARRAY: {
    for (unsigned int i = 0; i < op0->type->length; i++) {
       ir_rvalue *e0, *e1, *result;

       e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL__null),
                                              new(mem_ctx) ir_constant(i));
       e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL__null),
                                              new(mem_ctx) ir_constant(i));
       result = do_comparison(mem_ctx, operation, e0, e1);

       if (cmp) {
          cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
       } else {
          cmp = result;
       }
    }

    mark_whole_array_access(op0);
    mark_whole_array_access(op1);
    break;
 }

 case GLSL_TYPE_STRUCT: {
    for (unsigned int i = 0; i < op0->type->length; i++) {
       ir_rvalue *e0, *e1, *result;
       const char *field_name = op0->type->fields.structure[i].name;

       e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL__null),
                                               field_name);
       e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL__null),
                                               field_name);
       result = do_comparison(mem_ctx, operation, e0, e1);

       if (cmp) {
          cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
       } else {
          cmp = result;
       }
    }
    break;
 }

 case GLSL_TYPE_ERROR:
 case GLSL_TYPE_VOID:
 case GLSL_TYPE_SAMPLER:
 case GLSL_TYPE_IMAGE:
 case GLSL_TYPE_INTERFACE:
 case GLSL_TYPE_ATOMIC_UINT:
 case GLSL_TYPE_SUBROUTINE:
 case GLSL_TYPE_FUNCTION:
    /* I assume a comparison of a struct containing a sampler just
     * ignores the sampler present in the type.
     */
    break;
 }

 if (cmp == NULL__null)
    cmp = new(mem_ctx) ir_constant(true);

 return cmp;
1201}

1203/* For logical operations, we want to ensure that the operands are
* scalar booleans.  If it isn't, emit an error and return a constant
* boolean to avoid triggering cascading error messages.
*/
1207static ir_rvalue *
1208get_scalar_boolean_operand(exec_list *instructions,
                         struct _mesa_glsl_parse_state *state,
                         ast_expression *parent_expr,
                         int operand,
                         const char *operand_name,
                         bool *error_emitted)
1214{
 ast_expression *expr = parent_expr->subexpressions[operand];
 void *ctx = state;
 ir_rvalue *val = expr->hir(instructions, state);

 if (val->type->is_boolean() && val->type->is_scalar())
    return val;

 if (!*error_emitted) {
    YYLTYPE loc = expr->get_location();
    _mesa_glsl_error(&loc, state, "%s of `%s' must be scalar boolean",
                     operand_name,
                     parent_expr->operator_string(parent_expr->oper));
    *error_emitted = true;
 }

 return new(ctx) ir_constant(true);
1231}

1233/**
* If name refers to a builtin array whose maximum allowed size is less than
* size, report an error and return true.  Otherwise return false.
*/
1237void
1238check_builtin_array_max_size(const char *name, unsigned size,
                           YYLTYPE loc, struct _mesa_glsl_parse_state *state)
1240{
 if ((strcmp("gl_TexCoord", name) == 0)
     && (size > state->Const.MaxTextureCoords)) {
    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
     *
     *     "The size [of gl_TexCoord] can be at most
     *     gl_MaxTextureCoords."
     */
    _mesa_glsl_error(&loc, state, "`gl_TexCoord' array size cannot "
                     "be larger than gl_MaxTextureCoords (%u)",
                     state->Const.MaxTextureCoords);
 } else if (strcmp("gl_ClipDistance", name) == 0) {
    state->clip_dist_size = size;
    if (size + state->cull_dist_size > state->Const.MaxClipPlanes) {
       /* From section 7.1 (Vertex Shader Special Variables) of the
        * GLSL 1.30 spec:
        *
        *   "The gl_ClipDistance array is predeclared as unsized and
        *   must be sized by the shader either redeclaring it with a
        *   size or indexing it only with integral constant
        *   expressions. ... The size can be at most
        *   gl_MaxClipDistances."
        */
       _mesa_glsl_error(&loc, state, "`gl_ClipDistance' array size cannot "
                        "be larger than gl_MaxClipDistances (%u)",
                        state->Const.MaxClipPlanes);
    }
 } else if (strcmp("gl_CullDistance", name) == 0) {
    state->cull_dist_size = size;
    if (size + state->clip_dist_size > state->Const.MaxClipPlanes) {
       /* From the ARB_cull_distance spec:
        *
        *   "The gl_CullDistance array is predeclared as unsized and
        *    must be sized by the shader either redeclaring it with
        *    a size or indexing it only with integral constant
        *    expressions. The size determines the number and set of
        *    enabled cull distances and can be at most
        *    gl_MaxCullDistances."
        */
       _mesa_glsl_error(&loc, state, "`gl_CullDistance' array size cannot "
                        "be larger than gl_MaxCullDistances (%u)",
                        state->Const.MaxClipPlanes);
    }
 }
1284}

1286/**
* Create the constant 1, of a which is appropriate for incrementing and
* decrementing values of the given GLSL type.  For example, if type is vec4,
* this creates a constant value of 1.0 having type float.
*
* If the given type is invalid for increment and decrement operators, return
* a floating point 1--the error will be detected later.
*/
1294static ir_rvalue *
1295constant_one_for_inc_dec(void *ctx, const glsl_type *type)
1296{
 switch (type->base_type) {
 case GLSL_TYPE_UINT:
    return new(ctx) ir_constant((unsigned) 1);
 case GLSL_TYPE_INT:
    return new(ctx) ir_constant(1);
 case GLSL_TYPE_UINT64:
    return new(ctx) ir_constant((uint64_t) 1);
 case GLSL_TYPE_INT64:
    return new(ctx) ir_constant((int64_t) 1);
 default:
 case GLSL_TYPE_FLOAT:
    return new(ctx) ir_constant(1.0f);
 }
1310}

1312ir_rvalue *
1313ast_expression::hir(exec_list *instructions,
                  struct _mesa_glsl_parse_state *state)
1315{
 return do_hir(instructions, state, true);
1317}

1319void
1320ast_expression::hir_no_rvalue(exec_list *instructions,
                            struct _mesa_glsl_parse_state *state)
1322{
 do_hir(instructions, state, false);
1324}

1326void
1327ast_expression::set_is_lhs(bool new_value)
1328{
 /* is_lhs is tracked only to print "variable used uninitialized" warnings,
  * if we lack an identifier we can just skip it.
  */
 if (this->primary_expression.identifier == NULL__null)
    return;

 this->is_lhs = new_value;

 /* We need to go through the subexpressions tree to cover cases like
  * ast_field_selection
  */
 if (this->subexpressions[0] != NULL__null)
    this->subexpressions[0]->set_is_lhs(new_value);
1342}

1344ir_rvalue *
1345ast_expression::do_hir(exec_list *instructions,
                     struct _mesa_glsl_parse_state *state,
                     bool needs_rvalue)
1348{
 void *ctx = state;
 static const int operations[AST_NUM_OPERATORS(ast_aggregate + 1)] = {
    -1,               /* ast_assign doesn't convert to ir_expression. */
    -1,               /* ast_plus doesn't convert to ir_expression. */
    ir_unop_neg,
    ir_binop_add,
    ir_binop_sub,
    ir_binop_mul,
    ir_binop_div,
    ir_binop_mod,
    ir_binop_lshift,
    ir_binop_rshift,
    ir_binop_less,
    ir_binop_less,    /* This is correct.  See the ast_greater case below. */
    ir_binop_gequal,  /* This is correct.  See the ast_lequal case below. */
    ir_binop_gequal,
    ir_binop_all_equal,
    ir_binop_any_nequal,
    ir_binop_bit_and,
    ir_binop_bit_xor,
    ir_binop_bit_or,
    ir_unop_bit_not,
    ir_binop_logic_and,
    ir_binop_logic_xor,
    ir_binop_logic_or,
    ir_unop_logic_not,

    /* Note: The following block of expression types actually convert
     * to multiple IR instructions.
     */
    ir_binop_mul,     /* ast_mul_assign */
    ir_binop_div,     /* ast_div_assign */
    ir_binop_mod,     /* ast_mod_assign */
    ir_binop_add,     /* ast_add_assign */
    ir_binop_sub,     /* ast_sub_assign */
    ir_binop_lshift,  /* ast_ls_assign */
    ir_binop_rshift,  /* ast_rs_assign */
    ir_binop_bit_and, /* ast_and_assign */
    ir_binop_bit_xor, /* ast_xor_assign */
    ir_binop_bit_or,  /* ast_or_assign */

    -1,               /* ast_conditional doesn't convert to ir_expression. */
    ir_binop_add,     /* ast_pre_inc. */
    ir_binop_sub,     /* ast_pre_dec. */
    ir_binop_add,     /* ast_post_inc. */
    ir_binop_sub,     /* ast_post_dec. */
    -1,               /* ast_field_selection doesn't conv to ir_expression. */
    -1,               /* ast_array_index doesn't convert to ir_expression. */
    -1,               /* ast_function_call doesn't conv to ir_expression. */
    -1,               /* ast_identifier doesn't convert to ir_expression. */
    -1,               /* ast_int_constant doesn't convert to ir_expression. */
    -1,               /* ast_uint_constant doesn't conv to ir_expression. */
    -1,               /* ast_float_constant doesn't conv to ir_expression. */
    -1,               /* ast_bool_constant doesn't conv to ir_expression. */
    -1,               /* ast_sequence doesn't convert to ir_expression. */
    -1,               /* ast_aggregate shouldn't ever even get here. */
 };
 ir_rvalue *result = NULL__null;
 ir_rvalue *op[3];
 const struct glsl_type *type, *orig_type;
 bool error_emitted = false;
 YYLTYPE loc;

 loc = this->get_location();

 switch (this->oper) {
 case ast_aggregate:
    unreachable("ast_aggregate: Should never get here.")do { (static_cast <bool> (!"ast_aggregate: Should never get here."
) ? void (0) : __assert_fail ("!\"ast_aggregate: Should never get here.\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);

 case ast_assign: {
    this->subexpressions[0]->set_is_lhs(true);
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0], op[1], &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());
    break;
 }

 case ast_plus:
    op[0] = this->subexpressions[0]->hir(instructions, state);

    type = unary_arithmetic_result_type(op[0]->type, state, & loc);

    error_emitted = type->is_error();

    result = op[0];
    break;

 case ast_neg:
    op[0] = this->subexpressions[0]->hir(instructions, state);

    type = unary_arithmetic_result_type(op[0]->type, state, & loc);

    error_emitted = type->is_error();

    result = new(ctx) ir_expression(operations[this->oper], type,
                                    op[0], NULL__null);
    break;

 case ast_add:
 case ast_sub:
 case ast_mul:
 case ast_div:
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    type = arithmetic_result_type(op[0], op[1],
                                  (this->oper == ast_mul),
                                  state, & loc);
    error_emitted = type->is_error();

    result = new(ctx) ir_expression(operations[this->oper], type,
                                    op[0], op[1]);
    break;

 case ast_mod:
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    type = modulus_result_type(op[0], op[1], state, &loc);

    assert(operations[this->oper] == ir_binop_mod)(static_cast <bool> (operations[this->oper] == ir_binop_mod
) ? void (0) : __assert_fail ("operations[this->oper] == ir_binop_mod"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

    result = new(ctx) ir_expression(operations[this->oper], type,
                                    op[0], op[1]);
    error_emitted = type->is_error();
    break;

 case ast_lshift:
 case ast_rshift:
     if (!state->check_bitwise_operations_allowed(&loc)) {
        error_emitted = true;
     }

     op[0] = this->subexpressions[0]->hir(instructions, state);
     op[1] = this->subexpressions[1]->hir(instructions, state);
     type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
                              &loc);
     result = new(ctx) ir_expression(operations[this->oper], type,
                                     op[0], op[1]);
     error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
     break;

 case ast_less:
 case ast_greater:
 case ast_lequal:
 case ast_gequal:
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    type = relational_result_type(op[0], op[1], state, & loc);

    /* The relational operators must either generate an error or result
     * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.
     */
    assert(type->is_error()(static_cast <bool> (type->is_error() || (type->is_boolean
() && type->is_scalar())) ? void (0) : __assert_fail
 ("type->is_error() || (type->is_boolean() && type->is_scalar())"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           || (type->is_boolean() && type->is_scalar()))(static_cast <bool> (type->is_error() || (type->is_boolean
() && type->is_scalar())) ? void (0) : __assert_fail
 ("type->is_error() || (type->is_boolean() && type->is_scalar())"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

    /* Like NIR, GLSL IR does not have opcodes for > or <=.  Instead, swap
     * the arguments and use < or >=.
     */
    if (this->oper == ast_greater || this->oper == ast_lequal) {
       ir_rvalue *const tmp = op[0];
       op[0] = op[1];
       op[1] = tmp;
    }

    result = new(ctx) ir_expression(operations[this->oper], type,
                                    op[0], op[1]);
    error_emitted = type->is_error();
    break;

 case ast_nequal:
 case ast_equal:
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
     *
     *    "The equality operators equal (==), and not equal (!=)
     *    operate on all types. They result in a scalar Boolean. If
     *    the operand types do not match, then there must be a
     *    conversion from Section 4.1.10 "Implicit Conversions"
     *    applied to one operand that can make them match, in which
     *    case this conversion is done."
     */

    if (op[0]->type == glsl_type::void_type || op[1]->type == glsl_type::void_type) {
       _mesa_glsl_error(& loc, state, "`%s':  wrong operand types: "
                       "no operation `%1$s' exists that takes a left-hand "
                       "operand of type 'void' or a right operand of type "
                       "'void'", (this->oper == ast_equal) ? "==" : "!=");
       error_emitted = true;
    } else if ((!apply_implicit_conversion(op[0]->type, op[1], state)
         && !apply_implicit_conversion(op[1]->type, op[0], state))
        || (op[0]->type != op[1]->type)) {
       _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
                        "type", (this->oper == ast_equal) ? "==" : "!=");
       error_emitted = true;
    } else if ((op[0]->type->is_array() || op[1]->type->is_array()) &&
               !state->check_version(120, 300, &loc,
                                     "array comparisons forbidden")) {
       error_emitted = true;
    } else if ((op[0]->type->contains_subroutine() ||
                op[1]->type->contains_subroutine())) {
       _mesa_glsl_error(&loc, state, "subroutine comparisons forbidden");
       error_emitted = true;
    } else if ((op[0]->type->contains_opaque() ||
                op[1]->type->contains_opaque())) {
       _mesa_glsl_error(&loc, state, "opaque type comparisons forbidden");
       error_emitted = true;
    }

    if (error_emitted) {
       result = new(ctx) ir_constant(false);
    } else {
       result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
       assert(result->type == glsl_type::bool_type)(static_cast <bool> (result->type == glsl_type::bool_type
) ? void (0) : __assert_fail ("result->type == glsl_type::bool_type"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    }
    break;

 case ast_bit_and:
 case ast_bit_xor:
 case ast_bit_or:
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);
    type = bit_logic_result_type(op[0], op[1], this->oper, state, &loc);
    result = new(ctx) ir_expression(operations[this->oper], type,
                                    op[0], op[1]);
    error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
    break;

 case ast_bit_not:
    op[0] = this->subexpressions[0]->hir(instructions, state);

    if (!state->check_bitwise_operations_allowed(&loc)) {
       error_emitted = true;
    }

    if (!op[0]->type->is_integer_32_64()) {
       _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
       error_emitted = true;
    }

    type = error_emitted ? glsl_type::error_type : op[0]->type;
    result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL__null);
    break;

 case ast_logic_and: {
    exec_list rhs_instructions;
    op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
                                       "LHS", &error_emitted);
    op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
                                       "RHS", &error_emitted);

    if (rhs_instructions.is_empty()) {
       result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]);
    } else {
       ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
                                                     "and_tmp",
                                                     ir_var_temporary);
       instructions->push_tail(tmp);

       ir_if *const stmt = new(ctx) ir_if(op[0]);
       instructions->push_tail(stmt);

       stmt->then_instructions.append_list(&rhs_instructions);
       ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const then_assign =
          new(ctx) ir_assignment(then_deref, op[1]);
       stmt->then_instructions.push_tail(then_assign);

       ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const else_assign =
          new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false));
       stmt->else_instructions.push_tail(else_assign);

       result = new(ctx) ir_dereference_variable(tmp);
    }
    break;
 }

 case ast_logic_or: {
    exec_list rhs_instructions;
    op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
                                       "LHS", &error_emitted);
    op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1,
                                       "RHS", &error_emitted);

    if (rhs_instructions.is_empty()) {
       result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]);
    } else {
       ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
                                                     "or_tmp",
                                                     ir_var_temporary);
       instructions->push_tail(tmp);

       ir_if *const stmt = new(ctx) ir_if(op[0]);
       instructions->push_tail(stmt);

       ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const then_assign =
          new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true));
       stmt->then_instructions.push_tail(then_assign);

       stmt->else_instructions.append_list(&rhs_instructions);
       ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const else_assign =
          new(ctx) ir_assignment(else_deref, op[1]);
       stmt->else_instructions.push_tail(else_assign);

       result = new(ctx) ir_dereference_variable(tmp);
    }
    break;
 }

 case ast_logic_xor:
    /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
     *
     *    "The logical binary operators and (&&), or ( | | ), and
     *     exclusive or (^^). They operate only on two Boolean
     *     expressions and result in a Boolean expression."
     */
    op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
                                       &error_emitted);
    op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
                                       &error_emitted);

    result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
                                    op[0], op[1]);
    break;

 case ast_logic_not:
    op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
                                       "operand", &error_emitted);

    result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
                                    op[0], NULL__null);
    break;

 case ast_mul_assign:
 case ast_div_assign:
 case ast_add_assign:
 case ast_sub_assign: {
    this->subexpressions[0]->set_is_lhs(true);
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    orig_type = op[0]->type;

    /* Break out if operand types were not parsed successfully. */
    if ((op[0]->type == glsl_type::error_type ||
         op[1]->type == glsl_type::error_type)) {
       error_emitted = true;
       break;
    }

    type = arithmetic_result_type(op[0], op[1],
                                  (this->oper == ast_mul_assign),
                                  state, & loc);

    if (type != orig_type) {
       _mesa_glsl_error(& loc, state,
                        "could not implicitly convert "
                        "%s to %s", type->name, orig_type->name);
       type = glsl_type::error_type;
    }

    ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
                                                 op[0], op[1]);

    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());

    /* GLSL 1.10 does not allow array assignment.  However, we don't have to
     * explicitly test for this because none of the binary expression
     * operators allow array operands either.
     */

    break;
 }

 case ast_mod_assign: {
    this->subexpressions[0]->set_is_lhs(true);
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    orig_type = op[0]->type;
    type = modulus_result_type(op[0], op[1], state, &loc);

    if (type != orig_type) {
       _mesa_glsl_error(& loc, state,
                        "could not implicitly convert "
                        "%s to %s", type->name, orig_type->name);
       type = glsl_type::error_type;
    }

    assert(operations[this->oper] == ir_binop_mod)(static_cast <bool> (operations[this->oper] == ir_binop_mod
) ? void (0) : __assert_fail ("operations[this->oper] == ir_binop_mod"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

    ir_rvalue *temp_rhs;
    temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
                                      op[0], op[1]);

    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());
    break;
 }

 case ast_ls_assign:
 case ast_rs_assign: {
    this->subexpressions[0]->set_is_lhs(true);
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);
    type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
                             &loc);
    ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
                                                 type, op[0], op[1]);
    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());
    break;
 }

 case ast_and_assign:
 case ast_xor_assign:
 case ast_or_assign: {
    this->subexpressions[0]->set_is_lhs(true);
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = this->subexpressions[1]->hir(instructions, state);

    orig_type = op[0]->type;
    type = bit_logic_result_type(op[0], op[1], this->oper, state, &loc);

    if (type != orig_type) {
       _mesa_glsl_error(& loc, state,
                        "could not implicitly convert "
                        "%s to %s", type->name, orig_type->name);
       type = glsl_type::error_type;
    }

    ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
                                                 type, op[0], op[1]);
    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());
    break;
 }

 case ast_conditional: {
    /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
     *
     *    "The ternary selection operator (?:). It operates on three
     *    expressions (exp1 ? exp2 : exp3). This operator evaluates the
     *    first expression, which must result in a scalar Boolean."
     */
    op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
                                       "condition", &error_emitted);

    /* The :? operator is implemented by generating an anonymous temporary
     * followed by an if-statement.  The last instruction in each branch of
     * the if-statement assigns a value to the anonymous temporary.  This
     * temporary is the r-value of the expression.
     */
    exec_list then_instructions;
    exec_list else_instructions;

    op[1] = this->subexpressions[1]->hir(&then_instructions, state);
    op[2] = this->subexpressions[2]->hir(&else_instructions, state);

    /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
     *
     *     "The second and third expressions can be any type, as
     *     long their types match, or there is a conversion in
     *     Section 4.1.10 "Implicit Conversions" that can be applied
     *     to one of the expressions to make their types match. This
     *     resulting matching type is the type of the entire
     *     expression."
     */
    if ((!apply_implicit_conversion(op[1]->type, op[2], state)
        && !apply_implicit_conversion(op[2]->type, op[1], state))
        || (op[1]->type != op[2]->type)) {
       YYLTYPE loc = this->subexpressions[1]->get_location();

       _mesa_glsl_error(& loc, state, "second and third operands of ?: "
                        "operator must have matching types");
       error_emitted = true;
       type = glsl_type::error_type;
    } else {
       type = op[1]->type;
    }

    /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
     *
     *    "The second and third expressions must be the same type, but can
     *    be of any type other than an array."
     */
    if (type->is_array() &&
        !state->check_version(120, 300, &loc,
                              "second and third operands of ?: operator "
                              "cannot be arrays")) {
       error_emitted = true;
    }

    /* From section 4.1.7 of the GLSL 4.50 spec (Opaque Types):
     *
     *  "Except for array indexing, structure member selection, and
     *   parentheses, opaque variables are not allowed to be operands in
     *   expressions; such use results in a compile-time error."
     */
    if (type->contains_opaque()) {
       if (!(state->has_bindless() && (type->is_image() || type->is_sampler()))) {
          _mesa_glsl_error(&loc, state, "variables of type %s cannot be "
                           "operands of the ?: operator", type->name);
          error_emitted = true;
       }
    }

    ir_constant *cond_val = op[0]->constant_expression_value(ctx);

    if (then_instructions.is_empty()
        && else_instructions.is_empty()
        && cond_val != NULL__null) {
       result = cond_val->value.b[0] ? op[1] : op[2];
    } else {
       /* The copy to conditional_tmp reads the whole array. */
       if (type->is_array()) {
          mark_whole_array_access(op[1]);
          mark_whole_array_access(op[2]);
       }

       ir_variable *const tmp =
          new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
       instructions->push_tail(tmp);

       ir_if *const stmt = new(ctx) ir_if(op[0]);
       instructions->push_tail(stmt);

       then_instructions.move_nodes_to(& stmt->then_instructions);
       ir_dereference *const then_deref =
          new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const then_assign =
          new(ctx) ir_assignment(then_deref, op[1]);
       stmt->then_instructions.push_tail(then_assign);

       else_instructions.move_nodes_to(& stmt->else_instructions);
       ir_dereference *const else_deref =
          new(ctx) ir_dereference_variable(tmp);
       ir_assignment *const else_assign =
          new(ctx) ir_assignment(else_deref, op[2]);
       stmt->else_instructions.push_tail(else_assign);

       result = new(ctx) ir_dereference_variable(tmp);
    }
    break;
 }

 case ast_pre_inc:
 case ast_pre_dec: {
    this->non_lvalue_description = (this->oper == ast_pre_inc)
       ? "pre-increment operation" : "pre-decrement operation";

    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = constant_one_for_inc_dec(ctx, op[0]->type);

    type = arithmetic_result_type(op[0], op[1], false, state, & loc);

    ir_rvalue *temp_rhs;
    temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
                                      op[0], op[1]);

    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &result, needs_rvalue, false,
                     this->subexpressions[0]->get_location());
    break;
 }

 case ast_post_inc:
 case ast_post_dec: {
    this->non_lvalue_description = (this->oper == ast_post_inc)
       ? "post-increment operation" : "post-decrement operation";
    op[0] = this->subexpressions[0]->hir(instructions, state);
    op[1] = constant_one_for_inc_dec(ctx, op[0]->type);

    error_emitted = op[0]->type->is_error() || op[1]->type->is_error();

    if (error_emitted) {
       result = ir_rvalue::error_value(ctx);
       break;
    }

    type = arithmetic_result_type(op[0], op[1], false, state, & loc);

    ir_rvalue *temp_rhs;
    temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
                                      op[0], op[1]);

    /* Get a temporary of a copy of the lvalue before it's modified.
     * This may get thrown away later.
     */
    result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL__null));

    ir_rvalue *junk_rvalue;
    error_emitted =
       do_assignment(instructions, state,
                     this->subexpressions[0]->non_lvalue_description,
                     op[0]->clone(ctx, NULL__null), temp_rhs,
                     &junk_rvalue, false, false,
                     this->subexpressions[0]->get_location());

    break;
 }

 case ast_field_selection:
    result = _mesa_ast_field_selection_to_hir(this, instructions, state);
    break;

 case ast_array_index: {
    YYLTYPE index_loc = subexpressions[1]->get_location();

    /* Getting if an array is being used uninitialized is beyond what we get
     * from ir_value.data.assigned. Setting is_lhs as true would force to
     * not raise a uninitialized warning when using an array
     */
    subexpressions[0]->set_is_lhs(true);
    op[0] = subexpressions[0]->hir(instructions, state);
    op[1] = subexpressions[1]->hir(instructions, state);

    result = _mesa_ast_array_index_to_hir(ctx, state, op[0], op[1],
                                          loc, index_loc);

    if (result->type->is_error())
       error_emitted = true;

    break;
 }

 case ast_unsized_array_dim:
    unreachable("ast_unsized_array_dim: Should never get here.")do { (static_cast <bool> (!"ast_unsized_array_dim: Should never get here."
) ? void (0) : __assert_fail ("!\"ast_unsized_array_dim: Should never get here.\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);

 case ast_function_call:
    /* Should *NEVER* get here.  ast_function_call should always be handled
     * by ast_function_expression::hir.
     */
    unreachable("ast_function_call: handled elsewhere ")do { (static_cast <bool> (!"ast_function_call: handled elsewhere "
) ? void (0) : __assert_fail ("!\"ast_function_call: handled elsewhere \""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);

 case ast_identifier: {
    /* ast_identifier can appear several places in a full abstract syntax
     * tree.  This particular use must be at location specified in the grammar
     * as 'variable_identifier'.
     */
    ir_variable *var =
       state->symbols->get_variable(this->primary_expression.identifier);

    if (var == NULL__null) {
       /* the identifier might be a subroutine name */
       char *sub_name;
       sub_name = ralloc_asprintf(ctx, "%s_%s", _mesa_shader_stage_to_subroutine_prefix(state->stage), this->primary_expression.identifier);
       var = state->symbols->get_variable(sub_name);
       ralloc_free(sub_name);
    }

    if (var != NULL__null) {
       var->data.used = true;
       result = new(ctx) ir_dereference_variable(var);

       if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_shader_out)
           && !this->is_lhs
           && result->variable_referenced()->data.assigned != true
           && !is_gl_identifier(var->name)) {
          _mesa_glsl_warning(&loc, state, "`%s' used uninitialized",
                             this->primary_expression.identifier);
       }

       /* From the EXT_shader_framebuffer_fetch spec:
        *
        *   "Unless the GL_EXT_shader_framebuffer_fetch extension has been
        *    enabled in addition, it's an error to use gl_LastFragData if it
        *    hasn't been explicitly redeclared with layout(noncoherent)."
        */
       if (var->data.fb_fetch_output && var->data.memory_coherent &&
           !state->EXT_shader_framebuffer_fetch_enable) {
          _mesa_glsl_error(&loc, state,
                           "invalid use of framebuffer fetch output not "
                           "qualified with layout(noncoherent)");
       }

    } else {
       _mesa_glsl_error(& loc, state, "`%s' undeclared",
                        this->primary_expression.identifier);

       result = ir_rvalue::error_value(ctx);
       error_emitted = true;
    }
    break;
 }

 case ast_int_constant:
    result = new(ctx) ir_constant(this->primary_expression.int_constant);
    break;

 case ast_uint_constant:
    result = new(ctx) ir_constant(this->primary_expression.uint_constant);
    break;

 case ast_float_constant:
    result = new(ctx) ir_constant(this->primary_expression.float_constant);
    break;

 case ast_bool_constant:
    result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
    break;

 case ast_double_constant:
    result = new(ctx) ir_constant(this->primary_expression.double_constant);
    break;

 case ast_uint64_constant:
    result = new(ctx) ir_constant(this->primary_expression.uint64_constant);
    break;

 case ast_int64_constant:
    result = new(ctx) ir_constant(this->primary_expression.int64_constant);
    break;

 case ast_sequence: {
    /* It should not be possible to generate a sequence in the AST without
     * any expressions in it.
     */
    assert(!this->expressions.is_empty())(static_cast <bool> (!this->expressions.is_empty()) ?
 void (0) : __assert_fail ("!this->expressions.is_empty()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

    /* The r-value of a sequence is the last expression in the sequence.  If
     * the other expressions in the sequence do not have side-effects (and
     * therefore add instructions to the instruction list), they get dropped
     * on the floor.
     */
    exec_node *previous_tail = NULL__null;
    YYLTYPE previous_operand_loc = loc;

    foreach_list_typed (ast_node, ast, link, &this->expressions)for (ast_node * ast = (!exec_node_is_tail_sentinel((&this
->expressions)->head_sentinel.next) ? ((ast_node *) (((
uintptr_t) (&this->expressions)->head_sentinel.next
) - (((char *) &((ast_node *) (&this->expressions)
->head_sentinel.next)->link) - ((char *) (&this->
expressions)->head_sentinel.next)))) : __null); (ast) != __null
; (ast) = (!exec_node_is_tail_sentinel((ast)->link.next) ?
 ((ast_node *) (((uintptr_t) (ast)->link.next) - (((char *
) &((ast_node *) (ast)->link.next)->link) - ((char *
) (ast)->link.next)))) : __null)) {
       /* If one of the operands of comma operator does not generate any
        * code, we want to emit a warning.  At each pass through the loop
        * previous_tail will point to the last instruction in the stream
        * *before* processing the previous operand.  Naturally,
        * instructions->get_tail_raw() will point to the last instruction in
        * the stream *after* processing the previous operand.  If the two
        * pointers match, then the previous operand had no effect.
        *
        * The warning behavior here differs slightly from GCC.  GCC will
        * only emit a warning if none of the left-hand operands have an
        * effect.  However, it will emit a warning for each.  I believe that
        * there are some cases in C (especially with GCC extensions) where
        * it is useful to have an intermediate step in a sequence have no
        * effect, but I don't think these cases exist in GLSL.  Either way,
        * it would be a giant hassle to replicate that behavior.
        */
       if (previous_tail == instructions->get_tail_raw()) {
          _mesa_glsl_warning(&previous_operand_loc, state,
                             "left-hand operand of comma expression has "
                             "no effect");
       }

       /* The tail is directly accessed instead of using the get_tail()
        * method for performance reasons.  get_tail() has extra code to
        * return NULL when the list is empty.  We don't care about that
        * here, so using get_tail_raw() is fine.
        */
       previous_tail = instructions->get_tail_raw();
       previous_operand_loc = ast->get_location();

       result = ast->hir(instructions, state);
    }

    /* Any errors should have already been emitted in the loop above.
     */
    error_emitted = true;
    break;
 }
 }
 type = NULL__null; /* use result->type, not type. */
 assert(error_emitted || (result != NULL || !needs_rvalue))(static_cast <bool> (error_emitted || (result != __null
 || !needs_rvalue)) ? void (0) : __assert_fail ("error_emitted || (result != NULL || !needs_rvalue)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

 if (result && result->type->is_error() && !error_emitted)
    _mesa_glsl_error(& loc, state, "type mismatch");

 return result;
2155}

2157bool
2158ast_expression::has_sequence_subexpression() const
2159{
 switch (this->oper) {
 case ast_plus:
 case ast_neg:
 case ast_bit_not:
 case ast_logic_not:
 case ast_pre_inc:
 case ast_pre_dec:
 case ast_post_inc:
 case ast_post_dec:
    return this->subexpressions[0]->has_sequence_subexpression();

 case ast_assign:
 case ast_add:
 case ast_sub:
 case ast_mul:
 case ast_div:
 case ast_mod:
 case ast_lshift:
 case ast_rshift:
 case ast_less:
 case ast_greater:
 case ast_lequal:
 case ast_gequal:
 case ast_nequal:
 case ast_equal:
 case ast_bit_and:
 case ast_bit_xor:
 case ast_bit_or:
 case ast_logic_and:
 case ast_logic_or:
 case ast_logic_xor:
 case ast_array_index:
 case ast_mul_assign:
 case ast_div_assign:
 case ast_add_assign:
 case ast_sub_assign:
 case ast_mod_assign:
 case ast_ls_assign:
 case ast_rs_assign:
 case ast_and_assign:
 case ast_xor_assign:
 case ast_or_assign:
    return this->subexpressions[0]->has_sequence_subexpression() ||
           this->subexpressions[1]->has_sequence_subexpression();

 case ast_conditional:
    return this->subexpressions[0]->has_sequence_subexpression() ||
           this->subexpressions[1]->has_sequence_subexpression() ||
           this->subexpressions[2]->has_sequence_subexpression();

 case ast_sequence:
    return true;

 case ast_field_selection:
 case ast_identifier:
 case ast_int_constant:
 case ast_uint_constant:
 case ast_float_constant:
 case ast_bool_constant:
 case ast_double_constant:
 case ast_int64_constant:
 case ast_uint64_constant:
    return false;

 case ast_aggregate:
    return false;

 case ast_function_call:
    unreachable("should be handled by ast_function_expression::hir")do { (static_cast <bool> (!"should be handled by ast_function_expression::hir"
) ? void (0) : __assert_fail ("!\"should be handled by ast_function_expression::hir\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);

 case ast_unsized_array_dim:
    unreachable("ast_unsized_array_dim: Should never get here.")do { (static_cast <bool> (!"ast_unsized_array_dim: Should never get here."
) ? void (0) : __assert_fail ("!\"ast_unsized_array_dim: Should never get here.\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);
 }

 return false;
2235}

2237ir_rvalue *
2238ast_expression_statement::hir(exec_list *instructions,
                            struct _mesa_glsl_parse_state *state)
2240{
 /* It is possible to have expression statements that don't have an
  * expression.  This is the solitary semicolon:
  *
  * for (i = 0; i < 5; i++)
  *     ;
  *
  * In this case the expression will be NULL.  Test for NULL and don't do
  * anything in that case.
  */
 if (expression != NULL__null)
    expression->hir_no_rvalue(instructions, state);

 /* Statements do not have r-values.
  */
 return NULL__null;
2256}


2259ir_rvalue *
2260ast_compound_statement::hir(exec_list *instructions,
                          struct _mesa_glsl_parse_state *state)
2262{
 if (new_scope)
    state->symbols->push_scope();

 foreach_list_typed (ast_node, ast, link, &this->statements)for (ast_node * ast = (!exec_node_is_tail_sentinel((&this
->statements)->head_sentinel.next) ? ((ast_node *) (((uintptr_t
) (&this->statements)->head_sentinel.next) - (((char
 *) &((ast_node *) (&this->statements)->head_sentinel
.next)->link) - ((char *) (&this->statements)->head_sentinel
.next)))) : __null); (ast) != __null; (ast) = (!exec_node_is_tail_sentinel
((ast)->link.next) ? ((ast_node *) (((uintptr_t) (ast)->
link.next) - (((char *) &((ast_node *) (ast)->link.next
)->link) - ((char *) (ast)->link.next)))) : __null))
    ast->hir(instructions, state);

 if (new_scope)
    state->symbols->pop_scope();

 /* Compound statements do not have r-values.
  */
 return NULL__null;
2275}

2277/**
* Evaluate the given exec_node (which should be an ast_node representing
* a single array dimension) and return its integer value.
*/
2281static unsigned
2282process_array_size(exec_node *node,
                 struct _mesa_glsl_parse_state *state)
2284{
 void *mem_ctx = state;

 exec_list dummy_instructions;

 ast_node *array_size = exec_node_data(ast_node, node, link)((ast_node *) (((uintptr_t) node) - (((char *) &((ast_node
 *) node)->link) - ((char *) node))));

 /**
  * Dimensions other than the outermost dimension can by unsized if they
  * are immediately sized by a constructor or initializer.
  */
 if (((ast_expression*)array_size)->oper == ast_unsized_array_dim)
    return 0;

 ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
 YYLTYPE loc = array_size->get_location();

 if (ir == NULL__null) {
    _mesa_glsl_error(& loc, state,
                     "array size could not be resolved");
    return 0;
 }

 if (!ir->type->is_integer_32()) {
    _mesa_glsl_error(& loc, state,
                     "array size must be integer type");
    return 0;
 }

 if (!ir->type->is_scalar()) {
    _mesa_glsl_error(& loc, state,
                     "array size must be scalar type");
    return 0;
 }

 ir_constant *const size = ir->constant_expression_value(mem_ctx);
 if (size == NULL__null ||
     (state->is_version(120, 300) &&
      array_size->has_sequence_subexpression())) {
    _mesa_glsl_error(& loc, state, "array size must be a "
                     "constant valued expression");
    return 0;
 }

 if (size->value.i[0] <= 0) {
    _mesa_glsl_error(& loc, state, "array size must be > 0");
    return 0;
 }

 assert(size->type == ir->type)(static_cast <bool> (size->type == ir->type) ? void
 (0) : __assert_fail ("size->type == ir->type", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

 /* If the array size is const (and we've verified that
  * it is) then no instructions should have been emitted
  * when we converted it to HIR. If they were emitted,
  * then either the array size isn't const after all, or
  * we are emitting unnecessary instructions.
  */
 assert(dummy_instructions.is_empty())(static_cast <bool> (dummy_instructions.is_empty()) ? void
 (0) : __assert_fail ("dummy_instructions.is_empty()", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

 return size->value.u[0];
2344}

2346static const glsl_type *
2347process_array_type(YYLTYPE *loc, const glsl_type *base,
                 ast_array_specifier *array_specifier,
                 struct _mesa_glsl_parse_state *state)
2350{
 const glsl_type *array_type = base;

 if (array_specifier != NULL__null) {
    if (base->is_array()) {

       /* From page 19 (page 25) of the GLSL 1.20 spec:
        *
        * "Only one-dimensional arrays may be declared."
        */
       if (!state->check_arrays_of_arrays_allowed(loc)) {
          return glsl_type::error_type;
       }
    }

    for (exec_node *node = array_specifier->array_dimensions.get_tail_raw();
         !node->is_head_sentinel(); node = node->prev) {
       unsigned array_size = process_array_size(node, state);
       array_type = glsl_type::get_array_instance(array_type, array_size);
    }
 }

 return array_type;
2373}

2375static bool
2376precision_qualifier_allowed(const glsl_type *type)
2377{
 /* Precision qualifiers apply to floating point, integer and opaque
  * types.
  *
  * Section 4.5.2 (Precision Qualifiers) of the GLSL 1.30 spec says:
  *    "Any floating point or any integer declaration can have the type
  *    preceded by one of these precision qualifiers [...] Literal
  *    constants do not have precision qualifiers. Neither do Boolean
  *    variables.
  *
  * Section 4.5 (Precision and Precision Qualifiers) of the GLSL 1.30
  * spec also says:
  *
  *     "Precision qualifiers are added for code portability with OpenGL
  *     ES, not for functionality. They have the same syntax as in OpenGL
  *     ES."
  *
  * Section 8 (Built-In Functions) of the GLSL ES 1.00 spec says:
  *
  *     "uniform lowp sampler2D sampler;
  *     highp vec2 coord;
  *     ...
  *     lowp vec4 col = texture2D (sampler, coord);
  *                                            // texture2D returns lowp"
  *
  * From this, we infer that GLSL 1.30 (and later) should allow precision
  * qualifiers on sampler types just like float and integer types.
  */
 const glsl_type *const t = type->without_array();

 return (t->is_float() || t->is_integer_32() || t->contains_opaque()) &&
        !t->is_struct();
2409}

2411const glsl_type *
2412ast_type_specifier::glsl_type(const char **name,
                            struct _mesa_glsl_parse_state *state) const
2414{
 const struct glsl_type *type;

 if (this->type != NULL__null)
    type = this->type;
 else if (structure)
    type = structure->type;
 else
    type = state->symbols->get_type(this->type_name);
 *name = this->type_name;

 YYLTYPE loc = this->get_location();
 type = process_array_type(&loc, type, this->array_specifier, state);

 return type;
2429}

2431/**
* From the OpenGL ES 3.0 spec, 4.5.4 Default Precision Qualifiers:
*
* "The precision statement
*
*    precision precision-qualifier type;
*
*  can be used to establish a default precision qualifier. The type field can
*  be either int or float or any of the sampler types, (...) If type is float,
*  the directive applies to non-precision-qualified floating point type
*  (scalar, vector, and matrix) declarations. If type is int, the directive
*  applies to all non-precision-qualified integer type (scalar, vector, signed,
*  and unsigned) declarations."
*
* We use the symbol table to keep the values of the default precisions for
* each 'type' in each scope and we use the 'type' string from the precision
* statement as key in the symbol table. When we want to retrieve the default
* precision associated with a given glsl_type we need to know the type string
* associated with it. This is what this function returns.
*/
2451static const char *
2452get_type_name_for_precision_qualifier(const glsl_type *type)
2453{
 switch (type->base_type) {
 case GLSL_TYPE_FLOAT:
    return "float";
 case GLSL_TYPE_UINT:
 case GLSL_TYPE_INT:
    return "int";
 case GLSL_TYPE_ATOMIC_UINT:
    return "atomic_uint";
 case GLSL_TYPE_IMAGE:
 /* fallthrough */
 case GLSL_TYPE_SAMPLER: {
    const unsigned type_idx =
       type->sampler_array + 2 * type->sampler_shadow;
    const unsigned offset = type->is_sampler() ? 0 : 4;
    assert(type_idx < 4)(static_cast <bool> (type_idx < 4) ? void (0) : __assert_fail
 ("type_idx < 4", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
    switch (type->sampled_type) {
    case GLSL_TYPE_FLOAT:
       switch (type->sampler_dimensionality) {
       case GLSL_SAMPLER_DIM_1D: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "sampler1D", "sampler1DArray",
            "sampler1DShadow", "sampler1DArrayShadow"
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_2D: {
          static const char *const names[8] = {
            "sampler2D", "sampler2DArray",
            "sampler2DShadow", "sampler2DArrayShadow",
            "image2D", "image2DArray", NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_3D: {
          static const char *const names[8] = {
            "sampler3D", NULL__null, NULL__null, NULL__null,
            "image3D", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_CUBE: {
          static const char *const names[8] = {
            "samplerCube", "samplerCubeArray",
            "samplerCubeShadow", "samplerCubeArrayShadow",
            "imageCube", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_MS: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "sampler2DMS", "sampler2DMSArray", NULL__null, NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_RECT: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "samplerRect", NULL__null, "samplerRectShadow", NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_BUF: {
          static const char *const names[8] = {
            "samplerBuffer", NULL__null, NULL__null, NULL__null,
            "imageBuffer", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_EXTERNAL: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "samplerExternalOES", NULL__null, NULL__null, NULL__null
          };
          return names[type_idx];
       }
       default:
          unreachable("Unsupported sampler/image dimensionality")do { (static_cast <bool> (!"Unsupported sampler/image dimensionality"
) ? void (0) : __assert_fail ("!\"Unsupported sampler/image dimensionality\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);
       } /* sampler/image float dimensionality */
       break;
    case GLSL_TYPE_INT:
       switch (type->sampler_dimensionality) {
       case GLSL_SAMPLER_DIM_1D: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "isampler1D", "isampler1DArray", NULL__null, NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_2D: {
          static const char *const names[8] = {
            "isampler2D", "isampler2DArray", NULL__null, NULL__null,
            "iimage2D", "iimage2DArray", NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_3D: {
          static const char *const names[8] = {
            "isampler3D", NULL__null, NULL__null, NULL__null,
            "iimage3D", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_CUBE: {
          static const char *const names[8] = {
            "isamplerCube", "isamplerCubeArray", NULL__null, NULL__null,
            "iimageCube", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_MS: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "isampler2DMS", "isampler2DMSArray", NULL__null, NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_RECT: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "isamplerRect", NULL__null, "isamplerRectShadow", NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_BUF: {
          static const char *const names[8] = {
            "isamplerBuffer", NULL__null, NULL__null, NULL__null,
            "iimageBuffer", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       default:
          unreachable("Unsupported isampler/iimage dimensionality")do { (static_cast <bool> (!"Unsupported isampler/iimage dimensionality"
) ? void (0) : __assert_fail ("!\"Unsupported isampler/iimage dimensionality\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);
       } /* sampler/image int dimensionality */
       break;
    case GLSL_TYPE_UINT:
       switch (type->sampler_dimensionality) {
       case GLSL_SAMPLER_DIM_1D: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "usampler1D", "usampler1DArray", NULL__null, NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_2D: {
          static const char *const names[8] = {
            "usampler2D", "usampler2DArray", NULL__null, NULL__null,
            "uimage2D", "uimage2DArray", NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_3D: {
          static const char *const names[8] = {
            "usampler3D", NULL__null, NULL__null, NULL__null,
            "uimage3D", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_CUBE: {
          static const char *const names[8] = {
            "usamplerCube", "usamplerCubeArray", NULL__null, NULL__null,
            "uimageCube", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       case GLSL_SAMPLER_DIM_MS: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "usampler2DMS", "usampler2DMSArray", NULL__null, NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_RECT: {
          assert(type->is_sampler())(static_cast <bool> (type->is_sampler()) ? void (0) :
 __assert_fail ("type->is_sampler()", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
          static const char *const names[4] = {
            "usamplerRect", NULL__null, "usamplerRectShadow", NULL__null
          };
          return names[type_idx];
       }
       case GLSL_SAMPLER_DIM_BUF: {
          static const char *const names[8] = {
            "usamplerBuffer", NULL__null, NULL__null, NULL__null,
            "uimageBuffer", NULL__null, NULL__null, NULL__null
          };
          return names[offset + type_idx];
       }
       default:
          unreachable("Unsupported usampler/uimage dimensionality")do { (static_cast <bool> (!"Unsupported usampler/uimage dimensionality"
) ? void (0) : __assert_fail ("!\"Unsupported usampler/uimage dimensionality\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);
       } /* sampler/image uint dimensionality */
       break;
    default:
       unreachable("Unsupported sampler/image type")do { (static_cast <bool> (!"Unsupported sampler/image type"
) ? void (0) : __assert_fail ("!\"Unsupported sampler/image type\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); __builtin_unreachable(); } while (0);
    } /* sampler/image type */
    break;
 } /* GLSL_TYPE_SAMPLER/GLSL_TYPE_IMAGE */
 break;
 default:
    unreachable("Unsupported type")do { (static_cast <bool> (!"Unsupported type") ? void (
0) : __assert_fail ("!\"Unsupported type\"", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); __builtin_unreachable
(); } while (0);
 } /* base type */
2654}

2656static unsigned
2657select_gles_precision(unsigned qual_precision,
                    const glsl_type *type,
                    struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
2660{
 /* Precision qualifiers do not have any meaning in Desktop GLSL.
  * In GLES we take the precision from the type qualifier if present,
  * otherwise, if the type of the variable allows precision qualifiers at
  * all, we look for the default precision qualifier for that type in the
  * current scope.
  */
 assert(state->es_shader)(static_cast <bool> (state->es_shader) ? void (0) : __assert_fail
 ("state->es_shader", __builtin_FILE (), __builtin_LINE ()
, __extension__ __PRETTY_FUNCTION__));

 unsigned precision = GLSL_PRECISION_NONE;
 if (qual_precision) {
    precision = qual_precision;
 } else if (precision_qualifier_allowed(type)) {
    const char *type_name =
       get_type_name_for_precision_qualifier(type->without_array());
    assert(type_name != NULL)(static_cast <bool> (type_name != __null) ? void (0) : __assert_fail
 ("type_name != NULL", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));

    precision =
       state->symbols->get_default_precision_qualifier(type_name);
    if (precision == ast_precision_none) {
       _mesa_glsl_error(loc, state,
                        "No precision specified in this scope for type `%s'",
                        type->name);
    }
 }


 /* Section 4.1.7.3 (Atomic Counters) of the GLSL ES 3.10 spec says:
  *
  *    "The default precision of all atomic types is highp. It is an error to
  *    declare an atomic type with a different precision or to specify the
  *    default precision for an atomic type to be lowp or mediump."
  */
 if (type->is_atomic_uint() && precision != ast_precision_high) {
    _mesa_glsl_error(loc, state,
                     "atomic_uint can only have highp precision qualifier");
 }

 return precision;
2699}

2701const glsl_type *
2702ast_fully_specified_type::glsl_type(const char **name,
                                  struct _mesa_glsl_parse_state *state) const
2704{
 return this->specifier->glsl_type(name, state);
2706}

2708/**
* Determine whether a toplevel variable declaration declares a varying.  This
* function operates by examining the variable's mode and the shader target,
* so it correctly identifies linkage variables regardless of whether they are
* declared using the deprecated "varying" syntax or the new "in/out" syntax.
*
* Passing a non-toplevel variable declaration (e.g. a function parameter) to
* this function will produce undefined results.
*/
2717static bool
2718is_varying_var(ir_variable *var, gl_shader_stage target)
2719{
 switch (target) {
 case MESA_SHADER_VERTEX:
    return var->data.mode == ir_var_shader_out;
 case MESA_SHADER_FRAGMENT:
    return var->data.mode == ir_var_shader_in ||
           (var->data.mode == ir_var_system_value &&
            var->data.location == SYSTEM_VALUE_FRAG_COORD);
 default:
    return var->data.mode == ir_var_shader_out || var->data.mode == ir_var_shader_in;
 }
2730}

2732static bool
2733is_allowed_invariant(ir_variable *var, struct _mesa_glsl_parse_state *state)
2734{
 if (is_varying_var(var, state->stage))
    return true;

 /* From Section 4.6.1 ("The Invariant Qualifier") GLSL 1.20 spec:
  * "Only variables output from a vertex shader can be candidates
  * for invariance".
  */
 if (!state->is_version(130, 100))
    return false;

 /*
  * Later specs remove this language - so allowed invariant
  * on fragment shader outputs as well.
  */
 if (state->stage == MESA_SHADER_FRAGMENT &&
     var->data.mode == ir_var_shader_out)
    return true;
 return false;
2753}

2755/**
* Matrix layout qualifiers are only allowed on certain types
*/
2758static void
2759validate_matrix_layout_for_type(struct _mesa_glsl_parse_state *state,
                              YYLTYPE *loc,
                              const glsl_type *type,
                              ir_variable *var)
2763{
 if (var && !var->is_in_buffer_block()) {
    /* Layout qualifiers may only apply to interface blocks and fields in
     * them.
     */
    _mesa_glsl_error(loc, state,
                     "uniform block layout qualifiers row_major and "
                     "column_major may not be applied to variables "
                     "outside of uniform blocks");
 } else if (!type->without_array()->is_matrix()) {
    /* The OpenGL ES 3.0 conformance tests did not originally allow
     * matrix layout qualifiers on non-matrices.  However, the OpenGL
     * 4.4 and OpenGL ES 3.0 (revision TBD) specifications were
     * amended to specifically allow these layouts on all types.  Emit
     * a warning so that people know their code may not be portable.
     */
    _mesa_glsl_warning(loc, state,
                       "uniform block layout qualifiers row_major and "
                       "column_major applied to non-matrix types may "
                       "be rejected by older compilers");
 }
2784}

2786static bool
2787validate_xfb_buffer_qualifier(YYLTYPE *loc,
                            struct _mesa_glsl_parse_state *state,
                            unsigned xfb_buffer) {
 if (xfb_buffer >= state->Const.MaxTransformFeedbackBuffers) {
    _mesa_glsl_error(loc, state,
                     "invalid xfb_buffer specified %d is larger than "
                     "MAX_TRANSFORM_FEEDBACK_BUFFERS - 1 (%d).",
                     xfb_buffer,
                     state->Const.MaxTransformFeedbackBuffers - 1);
    return false;
 }

 return true;
2800}

2802/* From the ARB_enhanced_layouts spec:
*
*    "Variables and block members qualified with *xfb_offset* can be
*    scalars, vectors, matrices, structures, and (sized) arrays of these.
*    The offset must be a multiple of the size of the first component of
*    the first qualified variable or block member, or a compile-time error
*    results.  Further, if applied to an aggregate containing a double,
*    the offset must also be a multiple of 8, and the space taken in the
*    buffer will be a multiple of 8.
*/
2812static bool
2813validate_xfb_offset_qualifier(YYLTYPE *loc,
                            struct _mesa_glsl_parse_state *state,
                            int xfb_offset, const glsl_type *type,
                            unsigned component_size) {
const glsl_type *t_without_array = type->without_array();

 if (xfb_offset != -1 && type->is_unsized_array()) {
    _mesa_glsl_error(loc, state,
                     "xfb_offset can't be used with unsized arrays.");
    return false;
 }

 /* Make sure nested structs don't contain unsized arrays, and validate
  * any xfb_offsets on interface members.
  */
 if (t_without_array->is_struct() || t_without_array->is_interface())
    for (unsigned int i = 0; i < t_without_array->length; i++) {
       const glsl_type *member_t = t_without_array->fields.structure[i].type;

       /* When the interface block doesn't have an xfb_offset qualifier then
        * we apply the component size rules at the member level.
        */
       if (xfb_offset == -1)
          component_size = member_t->contains_double() ? 8 : 4;

       int xfb_offset = t_without_array->fields.structure[i].offset;
       validate_xfb_offset_qualifier(loc, state, xfb_offset, member_t,
                                     component_size);
    }

/* Nested structs or interface block without offset may not have had an
 * offset applied yet so return.
 */
 if (xfb_offset == -1) {
   return true;
 }

 if (xfb_offset % component_size) {
    _mesa_glsl_error(loc, state,
                     "invalid qualifier xfb_offset=%d must be a multiple "
                     "of the first component size of the first qualified "
                     "variable or block member. Or double if an aggregate "
                     "that contains a double (%d).",
                     xfb_offset, component_size);
    return false;
 }

 return true;
2861}

2863static bool
2864validate_stream_qualifier(YYLTYPE *loc, struct _mesa_glsl_parse_state *state,
                        unsigned stream)
2866{
 if (stream >= state->ctx->Const.MaxVertexStreams) {
    _mesa_glsl_error(loc, state,
                     "invalid stream specified %d is larger than "
                     "MAX_VERTEX_STREAMS - 1 (%d).",
                     stream, state->ctx->Const.MaxVertexStreams - 1);
    return false;
 }

 return true;
2876}

2878static void
2879apply_explicit_binding(struct _mesa_glsl_parse_state *state,
                     YYLTYPE *loc,
                     ir_variable *var,
                     const glsl_type *type,
                     const ast_type_qualifier *qual)
2884{
 if (!qual->flags.q.uniform && !qual->flags.q.buffer) {
    _mesa_glsl_error(loc, state,
                     "the \"binding\" qualifier only applies to uniforms and "
                     "shader storage buffer objects");
    return;
 }

 unsigned qual_binding;
 if (!process_qualifier_constant(state, loc, "binding", qual->binding,
                                 &qual_binding)) {
    return;
 }

 const struct gl_context *const ctx = state->ctx;
 unsigned elements = type->is_array() ? type->arrays_of_arrays_size() : 1;
 unsigned max_index = qual_binding + elements - 1;
 const glsl_type *base_type = type->without_array();

 if (base_type->is_interface()) {
    /* UBOs.  From page 60 of the GLSL 4.20 specification:
     * "If the binding point for any uniform block instance is less than zero,
     *  or greater than or equal to the implementation-dependent maximum
     *  number of uniform buffer bindings, a compilation error will occur.
     *  When the binding identifier is used with a uniform block instanced as
     *  an array of size N, all elements of the array from binding through
     *  binding + N – 1 must be within this range."
     *
     * The implementation-dependent maximum is GL_MAX_UNIFORM_BUFFER_BINDINGS.
     */
    if (qual->flags.q.uniform &&
       max_index >= ctx->Const.MaxUniformBufferBindings) {
       _mesa_glsl_error(loc, state, "layout(binding = %u) for %d UBOs exceeds "
                        "the maximum number of UBO binding points (%d)",
                        qual_binding, elements,
                        ctx->Const.MaxUniformBufferBindings);
       return;
    }

    /* SSBOs. From page 67 of the GLSL 4.30 specification:
     * "If the binding point for any uniform or shader storage block instance
     *  is less than zero, or greater than or equal to the
     *  implementation-dependent maximum number of uniform buffer bindings, a
     *  compile-time error will occur. When the binding identifier is used
     *  with a uniform or shader storage block instanced as an array of size
     *  N, all elements of the array from binding through binding + N – 1 must
     *  be within this range."
     */
    if (qual->flags.q.buffer &&
       max_index >= ctx->Const.MaxShaderStorageBufferBindings) {
       _mesa_glsl_error(loc, state, "layout(binding = %u) for %d SSBOs exceeds "
                        "the maximum number of SSBO binding points (%d)",
                        qual_binding, elements,
                        ctx->Const.MaxShaderStorageBufferBindings);
       return;
    }
 } else if (base_type->is_sampler()) {
    /* Samplers.  From page 63 of the GLSL 4.20 specification:
     * "If the binding is less than zero, or greater than or equal to the
     *  implementation-dependent maximum supported number of units, a
     *  compilation error will occur. When the binding identifier is used
     *  with an array of size N, all elements of the array from binding
     *  through binding + N - 1 must be within this range."
     */
    unsigned limit = ctx->Const.MaxCombinedTextureImageUnits;

    if (max_index >= limit) {
       _mesa_glsl_error(loc, state, "layout(binding = %d) for %d samplers "
                        "exceeds the maximum number of texture image units "
                        "(%u)", qual_binding, elements, limit);

       return;
    }
 } else if (base_type->contains_atomic()) {
    assert(ctx->Const.MaxAtomicBufferBindings <= MAX_COMBINED_ATOMIC_BUFFERS)(static_cast <bool> (ctx->Const.MaxAtomicBufferBindings
 <= (15 * 6)) ? void (0) : __assert_fail ("ctx->Const.MaxAtomicBufferBindings <= MAX_COMBINED_ATOMIC_BUFFERS"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    if (qual_binding >= ctx->Const.MaxAtomicBufferBindings) {
       _mesa_glsl_error(loc, state, "layout(binding = %d) exceeds the "
                        "maximum number of atomic counter buffer bindings "
                        "(%u)", qual_binding,
                        ctx->Const.MaxAtomicBufferBindings);

       return;
    }
 } else if ((state->is_version(420, 310) ||
             state->ARB_shading_language_420pack_enable) &&
            base_type->is_image()) {
    assert(ctx->Const.MaxImageUnits <= MAX_IMAGE_UNITS)(static_cast <bool> (ctx->Const.MaxImageUnits <= (
* 6)) ? void (0) : __assert_fail ("ctx->Const.MaxImageUnits <= MAX_IMAGE_UNITS"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    if (max_index >= ctx->Const.MaxImageUnits) {
       _mesa_glsl_error(loc, state, "Image binding %d exceeds the "
                        "maximum number of image units (%d)", max_index,
                        ctx->Const.MaxImageUnits);
       return;
    }

 } else {
    _mesa_glsl_error(loc, state,
                     "the \"binding\" qualifier only applies to uniform "
                     "blocks, storage blocks, opaque variables, or arrays "
                     "thereof");
    return;
 }

 var->data.explicit_binding = true;
 var->data.binding = qual_binding;

 return;
2990}

2992static void
2993validate_fragment_flat_interpolation_input(struct _mesa_glsl_parse_state *state,
                                         YYLTYPE *loc,
                                         const glsl_interp_mode interpolation,
                                         const struct glsl_type *var_type,
                                         ir_variable_mode mode)
2998{
 if (state->stage != MESA_SHADER_FRAGMENT ||
     interpolation == INTERP_MODE_FLAT ||
     mode != ir_var_shader_in)
    return;

 /* Integer fragment inputs must be qualified with 'flat'.  In GLSL ES,
  * so must integer vertex outputs.
  *
  * From section 4.3.4 ("Inputs") of the GLSL 1.50 spec:
  *    "Fragment shader inputs that are signed or unsigned integers or
  *    integer vectors must be qualified with the interpolation qualifier
  *    flat."
  *
  * From section 4.3.4 ("Input Variables") of the GLSL 3.00 ES spec:
  *    "Fragment shader inputs that are, or contain, signed or unsigned
  *    integers or integer vectors must be qualified with the
  *    interpolation qualifier flat."
  *
  * From section 4.3.6 ("Output Variables") of the GLSL 3.00 ES spec:
  *    "Vertex shader outputs that are, or contain, signed or unsigned
  *    integers or integer vectors must be qualified with the
  *    interpolation qualifier flat."
  *
  * Note that prior to GLSL 1.50, this requirement applied to vertex
  * outputs rather than fragment inputs.  That creates problems in the
  * presence of geometry shaders, so we adopt the GLSL 1.50 rule for all
  * desktop GL shaders.  For GLSL ES shaders, we follow the spec and
  * apply the restriction to both vertex outputs and fragment inputs.
  *
  * Note also that the desktop GLSL specs are missing the text "or
  * contain"; this is presumably an oversight, since there is no
  * reasonable way to interpolate a fragment shader input that contains
  * an integer. See Khronos bug #15671.
  */
 if ((state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
     && var_type->contains_integer()) {
    _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
                     "an integer, then it must be qualified with 'flat'");
 }

 /* Double fragment inputs must be qualified with 'flat'.
  *
  * From the "Overview" of the ARB_gpu_shader_fp64 extension spec:
  *    "This extension does not support interpolation of double-precision
  *    values; doubles used as fragment shader inputs must be qualified as
  *    "flat"."
  *
  * From section 4.3.4 ("Inputs") of the GLSL 4.00 spec:
  *    "Fragment shader inputs that are signed or unsigned integers, integer
  *    vectors, or any double-precision floating-point type must be
  *    qualified with the interpolation qualifier flat."
  *
  * Note that the GLSL specs are missing the text "or contain"; this is
  * presumably an oversight. See Khronos bug #15671.
  *
  * The 'double' type does not exist in GLSL ES so far.
  */
 if (state->has_double()
     && var_type->contains_double()) {
    _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
                     "a double, then it must be qualified with 'flat'");
 }

 /* Bindless sampler/image fragment inputs must be qualified with 'flat'.
  *
  * From section 4.3.4 of the ARB_bindless_texture spec:
  *
  *    "(modify last paragraph, p. 35, allowing samplers and images as
  *     fragment shader inputs) ... Fragment inputs can only be signed and
  *     unsigned integers and integer vectors, floating point scalars,
  *     floating-point vectors, matrices, sampler and image types, or arrays
  *     or structures of these.  Fragment shader inputs that are signed or
  *     unsigned integers, integer vectors, or any double-precision floating-
  *     point type, or any sampler or image type must be qualified with the
  *     interpolation qualifier "flat"."
  */
 if (state->has_bindless()
     && (var_type->contains_sampler() || var_type->contains_image())) {
    _mesa_glsl_error(loc, state, "if a fragment input is (or contains) "
                     "a bindless sampler (or image), then it must be "
                     "qualified with 'flat'");
 }
3081}

3083static void
3084validate_interpolation_qualifier(struct _mesa_glsl_parse_state *state,
                               YYLTYPE *loc,
                               const glsl_interp_mode interpolation,
                               const struct ast_type_qualifier *qual,
                               const struct glsl_type *var_type,
                               ir_variable_mode mode)
3090{
 /* Interpolation qualifiers can only apply to shader inputs or outputs, but
  * not to vertex shader inputs nor fragment shader outputs.
  *
  * From section 4.3 ("Storage Qualifiers") of the GLSL 1.30 spec:
  *    "Outputs from a vertex shader (out) and inputs to a fragment
  *    shader (in) can be further qualified with one or more of these
  *    interpolation qualifiers"
  *    ...
  *    "These interpolation qualifiers may only precede the qualifiers in,
  *    centroid in, out, or centroid out in a declaration. They do not apply
  *    to the deprecated storage qualifiers varying or centroid
  *    varying. They also do not apply to inputs into a vertex shader or
  *    outputs from a fragment shader."
  *
  * From section 4.3 ("Storage Qualifiers") of the GLSL ES 3.00 spec:
  *    "Outputs from a shader (out) and inputs to a shader (in) can be
  *    further qualified with one of these interpolation qualifiers."
  *    ...
  *    "These interpolation qualifiers may only precede the qualifiers
  *    in, centroid in, out, or centroid out in a declaration. They do
  *    not apply to inputs into a vertex shader or outputs from a
  *    fragment shader."
  */
 if ((state->is_version(130, 300) || state->EXT_gpu_shader4_enable)
     && interpolation != INTERP_MODE_NONE) {
    const char *i = interpolation_string(interpolation);
    if (mode != ir_var_shader_in && mode != ir_var_shader_out)
       _mesa_glsl_error(loc, state,
                        "interpolation qualifier `%s' can only be applied to "
                        "shader inputs or outputs.", i);

    switch (state->stage) {
    case MESA_SHADER_VERTEX:
       if (mode == ir_var_shader_in) {
          _mesa_glsl_error(loc, state,
                           "interpolation qualifier '%s' cannot be applied to "
                           "vertex shader inputs", i);
       }
       break;
    case MESA_SHADER_FRAGMENT:
       if (mode == ir_var_shader_out) {
          _mesa_glsl_error(loc, state,
                           "interpolation qualifier '%s' cannot be applied to "
                           "fragment shader outputs", i);
       }
       break;
    default:
       break;
    }
 }

 /* Interpolation qualifiers cannot be applied to 'centroid' and
  * 'centroid varying'.
  *
  * From section 4.3 ("Storage Qualifiers") of the GLSL 1.30 spec:
  *    "interpolation qualifiers may only precede the qualifiers in,
  *    centroid in, out, or centroid out in a declaration. They do not apply
  *    to the deprecated storage qualifiers varying or centroid varying."
  *
  * These deprecated storage qualifiers do not exist in GLSL ES 3.00.
  *
  * GL_EXT_gpu_shader4 allows this.
  */
 if (state->is_version(130, 0) && !state->EXT_gpu_shader4_enable
     && interpolation != INTERP_MODE_NONE
     && qual->flags.q.varying) {

    const char *i = interpolation_string(interpolation);
    const char *s;
    if (qual->flags.q.centroid)
       s = "centroid varying";
    else
       s = "varying";

    _mesa_glsl_error(loc, state,
                     "qualifier '%s' cannot be applied to the "
                     "deprecated storage qualifier '%s'", i, s);
 }

 validate_fragment_flat_interpolation_input(state, loc, interpolation,
                                            var_type, mode);
3172}

3174static glsl_interp_mode
3175interpret_interpolation_qualifier(const struct ast_type_qualifier *qual,
                                const struct glsl_type *var_type,
                                ir_variable_mode mode,
                                struct _mesa_glsl_parse_state *state,
                                YYLTYPE *loc)
3180{
 glsl_interp_mode interpolation;
 if (qual->flags.q.flat)
    interpolation = INTERP_MODE_FLAT;
 else if (qual->flags.q.noperspective)
    interpolation = INTERP_MODE_NOPERSPECTIVE;
 else if (qual->flags.q.smooth)
    interpolation = INTERP_MODE_SMOOTH;
 else
    interpolation = INTERP_MODE_NONE;

 validate_interpolation_qualifier(state, loc,
                                  interpolation,
                                  qual, var_type, mode);

 return interpolation;
3196}


3199static void
3200apply_explicit_location(const struct ast_type_qualifier *qual,
                      ir_variable *var,
                      struct _mesa_glsl_parse_state *state,
                      YYLTYPE *loc)
3204{
 bool fail = false;

 unsigned qual_location;
 if (!process_qualifier_constant(state, loc, "location", qual->location,
                                 &qual_location)) {
    return;
 }

 /* Checks for GL_ARB_explicit_uniform_location. */
 if (qual->flags.q.uniform) {
    if (!state->check_explicit_uniform_location_allowed(loc, var))
       return;

    const struct gl_context *const ctx = state->ctx;
    unsigned max_loc = qual_location + var->type->uniform_locations() - 1;

    if (max_loc >= ctx->Const.MaxUserAssignableUniformLocations) {
       _mesa_glsl_error(loc, state, "location(s) consumed by uniform %s "
                        ">= MAX_UNIFORM_LOCATIONS (%u)", var->name,
                        ctx->Const.MaxUserAssignableUniformLocations);
       return;
    }

    var->data.explicit_location = true;
    var->data.location = qual_location;
    return;
 }

 /* Between GL_ARB_explicit_attrib_location an
  * GL_ARB_separate_shader_objects, the inputs and outputs of any shader
  * stage can be assigned explicit locations.  The checking here associates
  * the correct extension with the correct stage's input / output:
  *
  *                     input            output
  *                     -----            ------
  * vertex              explicit_loc     sso
  * tess control        sso              sso
  * tess eval           sso              sso
  * geometry            sso              sso
  * fragment            sso              explicit_loc
  */
 switch (state->stage) {
 case MESA_SHADER_VERTEX:
    if (var->data.mode == ir_var_shader_in) {
       if (!state->check_explicit_attrib_location_allowed(loc, var))
          return;

       break;
    }

    if (var->data.mode == ir_var_shader_out) {
       if (!state->check_separate_shader_objects_allowed(loc, var))
          return;

       break;
    }

    fail = true;
    break;

 case MESA_SHADER_TESS_CTRL:
 case MESA_SHADER_TESS_EVAL:
 case MESA_SHADER_GEOMETRY:
    if (var->data.mode == ir_var_shader_in || var->data.mode == ir_var_shader_out) {
       if (!state->check_separate_shader_objects_allowed(loc, var))
          return;

       break;
    }

    fail = true;
    break;

 case MESA_SHADER_FRAGMENT:
    if (var->data.mode == ir_var_shader_in) {
       if (!state->check_separate_shader_objects_allowed(loc, var))
          return;

       break;
    }

    if (var->data.mode == ir_var_shader_out) {
       if (!state->check_explicit_attrib_location_allowed(loc, var))
          return;

       break;
    }

    fail = true;
    break;

 case MESA_SHADER_COMPUTE:
    _mesa_glsl_error(loc, state,
                     "compute shader variables cannot be given "
                     "explicit locations");
    return;
 default:
    fail = true;
    break;
 };

 if (fail) {
    _mesa_glsl_error(loc, state,
                     "%s cannot be given an explicit location in %s shader",
                     mode_string(var),
    _mesa_shader_stage_to_string(state->stage));
 } else {
    var->data.explicit_location = true;

    switch (state->stage) {
    case MESA_SHADER_VERTEX:
       var->data.location = (var->data.mode == ir_var_shader_in)
          ? (qual_location + VERT_ATTRIB_GENERIC0)
          : (qual_location + VARYING_SLOT_VAR0);
       break;

    case MESA_SHADER_TESS_CTRL:
    case MESA_SHADER_TESS_EVAL:
    case MESA_SHADER_GEOMETRY:
       if (var->data.patch)
          var->data.location = qual_location + VARYING_SLOT_PATCH0((VARYING_SLOT_VAR0 + 32));
       else
          var->data.location = qual_location + VARYING_SLOT_VAR0;
       break;

    case MESA_SHADER_FRAGMENT:
       var->data.location = (var->data.mode == ir_var_shader_out)
          ? (qual_location + FRAG_RESULT_DATA0)
          : (qual_location + VARYING_SLOT_VAR0);
       break;
    default:
       assert(!"Unexpected shader type")(static_cast <bool> (!"Unexpected shader type") ? void (
0) : __assert_fail ("!\"Unexpected shader type\"", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
       break;
    }

    /* Check if index was set for the uniform instead of the function */
    if (qual->flags.q.explicit_index && qual->is_subroutine_decl()) {
       _mesa_glsl_error(loc, state, "an index qualifier can only be "
                        "used with subroutine functions");
       return;
    }

    unsigned qual_index;
    if (qual->flags.q.explicit_index &&
        process_qualifier_constant(state, loc, "index", qual->index,
                                   &qual_index)) {
       /* From the GLSL 4.30 specification, section 4.4.2 (Output
        * Layout Qualifiers):
        *
        * "It is also a compile-time error if a fragment shader
        *  sets a layout index to less than 0 or greater than 1."
        *
        * Older specifications don't mandate a behavior; we take
        * this as a clarification and always generate the error.
        */
       if (qual_index > 1) {
          _mesa_glsl_error(loc, state,
                           "explicit index may only be 0 or 1");
       } else {
          var->data.explicit_index = true;
          var->data.index = qual_index;
       }
    }
 }
3369}

3371static bool
3372validate_storage_for_sampler_image_types(ir_variable *var,
                                       struct _mesa_glsl_parse_state *state,
                                       YYLTYPE *loc)
3375{
 /* From section 4.1.7 of the GLSL 4.40 spec:
  *
  *    "[Opaque types] can only be declared as function
  *     parameters or uniform-qualified variables."
  *
  * From section 4.1.7 of the ARB_bindless_texture spec:
  *
  *    "Samplers may be declared as shader inputs and outputs, as uniform
  *     variables, as temporary variables, and as function parameters."
  *
  * From section 4.1.X of the ARB_bindless_texture spec:
  *
  *    "Images may be declared as shader inputs and outputs, as uniform
  *     variables, as temporary variables, and as function parameters."
  */
 if (state->has_bindless()) {
    if (var->data.mode != ir_var_auto &&
        var->data.mode != ir_var_uniform &&
        var->data.mode != ir_var_shader_in &&
        var->data.mode != ir_var_shader_out &&
        var->data.mode != ir_var_function_in &&
        var->data.mode != ir_var_function_out &&
        var->data.mode != ir_var_function_inout) {
       _mesa_glsl_error(loc, state, "bindless image/sampler variables may "
                       "only be declared as shader inputs and outputs, as "
                       "uniform variables, as temporary variables and as "
                       "function parameters");
       return false;
    }
 } else {
    if (var->data.mode != ir_var_uniform &&
        var->data.mode != ir_var_function_in) {
       _mesa_glsl_error(loc, state, "image/sampler variables may only be "
                        "declared as function parameters or "
                        "uniform-qualified global variables");
       return false;
    }
 }
 return true;
3415}

3417static bool
3418validate_memory_qualifier_for_type(struct _mesa_glsl_parse_state *state,
                                 YYLTYPE *loc,
                                 const struct ast_type_qualifier *qual,
                                 const glsl_type *type)
3422{
 /* From Section 4.10 (Memory Qualifiers) of the GLSL 4.50 spec:
  *
  * "Memory qualifiers are only supported in the declarations of image
  *  variables, buffer variables, and shader storage blocks; it is an error
  *  to use such qualifiers in any other declarations.
  */
 if (!type->is_image() && !qual->flags.q.buffer) {
    if (qual->flags.q.read_only ||
        qual->flags.q.write_only ||
        qual->flags.q.coherent ||
        qual->flags.q._volatile ||
        qual->flags.q.restrict_flag) {
       _mesa_glsl_error(loc, state, "memory qualifiers may only be applied "
                        "in the declarations of image variables, buffer "
                        "variables, and shader storage blocks");
       return false;
    }
 }
 return true;
3442}

3444static bool
3445validate_image_format_qualifier_for_type(struct _mesa_glsl_parse_state *state,
                                       YYLTYPE *loc,
                                       const struct ast_type_qualifier *qual,
                                       const glsl_type *type)
3449{
 /* From section 4.4.6.2 (Format Layout Qualifiers) of the GLSL 4.50 spec:
  *
  * "Format layout qualifiers can be used on image variable declarations
  *  (those declared with a basic type  having “image ” in its keyword)."
  */
 if (!type->is_image() && qual->flags.q.explicit_image_format) {
    _mesa_glsl_error(loc, state, "format layout qualifiers may only be "
                     "applied to images");
    return false;
 }
 return true;
3461}

3463static void
3464apply_image_qualifier_to_variable(const struct ast_type_qualifier *qual,
                                ir_variable *var,
                                struct _mesa_glsl_parse_state *state,
                                YYLTYPE *loc)
3468{
 const glsl_type *base_type = var->type->without_array();

 if (!validate_image_format_qualifier_for_type(state, loc, qual, base_type) ||
     !validate_memory_qualifier_for_type(state, loc, qual, base_type))
    return;

 if (!base_type->is_image())
    return;

 if (!validate_storage_for_sampler_image_types(var, state, loc))
    return;

 var->data.memory_read_only |= qual->flags.q.read_only;
 var->data.memory_write_only |= qual->flags.q.write_only;
 var->data.memory_coherent |= qual->flags.q.coherent;
 var->data.memory_volatile |= qual->flags.q._volatile;
 var->data.memory_restrict |= qual->flags.q.restrict_flag;

 if (qual->flags.q.explicit_image_format) {
    if (var->data.mode == ir_var_function_in) {
       _mesa_glsl_error(loc, state, "format qualifiers cannot be used on "
                        "image function parameters");
    }

    if (qual->image_base_type != base_type->sampled_type) {
       _mesa_glsl_error(loc, state, "format qualifier doesn't match the base "
                        "data type of the image");
    }

    var->data.image_format = qual->image_format;
 } else if (state->has_image_load_formatted()) {
    if (var->data.mode == ir_var_uniform &&
        state->EXT_shader_image_load_formatted_warn) {
       _mesa_glsl_warning(loc, state, "GL_EXT_image_load_formatted used");
    }
 } else {
    if (var->data.mode == ir_var_uniform) {
       if (state->es_shader ||
           !(state->is_version(420, 310) || state->ARB_shader_image_load_store_enable)) {
          _mesa_glsl_error(loc, state, "all image uniforms must have a "
                           "format layout qualifier");
       } else if (!qual->flags.q.write_only) {
          _mesa_glsl_error(loc, state, "image uniforms not qualified with "
                           "`writeonly' must have a format layout qualifier");
       }
    }
    var->data.image_format = PIPE_FORMAT_NONE;
 }

 /* From page 70 of the GLSL ES 3.1 specification:
  *
  * "Except for image variables qualified with the format qualifiers r32f,
  *  r32i, and r32ui, image variables must specify either memory qualifier
  *  readonly or the memory qualifier writeonly."
  */
 if (state->es_shader &&
     var->data.image_format != PIPE_FORMAT_R32_FLOAT &&
     var->data.image_format != PIPE_FORMAT_R32_SINT &&
     var->data.image_format != PIPE_FORMAT_R32_UINT &&
     !var->data.memory_read_only &&
     !var->data.memory_write_only) {
    _mesa_glsl_error(loc, state, "image variables of format other than r32f, "
                     "r32i or r32ui must be qualified `readonly' or "
                     "`writeonly'");
 }
3534}

3536static inline const char*
3537get_layout_qualifier_string(bool origin_upper_left, bool pixel_center_integer)
3538{
 if (origin_upper_left && pixel_center_integer)
    return "origin_upper_left, pixel_center_integer";
 else if (origin_upper_left)
    return "origin_upper_left";
 else if (pixel_center_integer)
    return "pixel_center_integer";
 else
    return " ";
3547}

3549static inline bool
3550is_conflicting_fragcoord_redeclaration(struct _mesa_glsl_parse_state *state,
                                     const struct ast_type_qualifier *qual)
3552{
 /* If gl_FragCoord was previously declared, and the qualifiers were
  * different in any way, return true.
  */
 if (state->fs_redeclares_gl_fragcoord) {
    return (state->fs_pixel_center_integer != qual->flags.q.pixel_center_integer
       || state->fs_origin_upper_left != qual->flags.q.origin_upper_left);
 }

 return false;
3562}

3564static inline bool
3565is_conflicting_layer_redeclaration(struct _mesa_glsl_parse_state *state,
                                 const struct ast_type_qualifier *qual)
3567{
 if (state->redeclares_gl_layer) {
    return state->layer_viewport_relative != qual->flags.q.viewport_relative;
 }
 return false;
3572}

3574static inline void
3575validate_array_dimensions(const glsl_type *t,
                        struct _mesa_glsl_parse_state *state,
                        YYLTYPE *loc) {
 if (t->is_array()) {
    t = t->fields.array;
    while (t->is_array()) {
       if (t->is_unsized_array()) {
          _mesa_glsl_error(loc, state,
                           "only the outermost array dimension can "
                           "be unsized",
                           t->name);
          break;
       }
       t = t->fields.array;
    }
 }
3591}

3593static void
3594apply_bindless_qualifier_to_variable(const struct ast_type_qualifier *qual,
                                   ir_variable *var,
                                   struct _mesa_glsl_parse_state *state,
                                   YYLTYPE *loc)
3598{
 bool has_local_qualifiers = qual->flags.q.bindless_sampler ||
                             qual->flags.q.bindless_image ||
                             qual->flags.q.bound_sampler ||
                             qual->flags.q.bound_image;

 /* The ARB_bindless_texture spec says:
  *
  * "Modify Section 4.4.6 Opaque-Uniform Layout Qualifiers of the GLSL 4.30
  *  spec"
  *
  * "If these layout qualifiers are applied to other types of default block
  *  uniforms, or variables with non-uniform storage, a compile-time error
  *  will be generated."
  */
 if (has_local_qualifiers && !qual->flags.q.uniform) {
    _mesa_glsl_error(loc, state, "ARB_bindless_texture layout qualifiers "
                     "can only be applied to default block uniforms or "
                     "variables with uniform storage");
    return;
 }

 /* The ARB_bindless_texture spec doesn't state anything in this situation,
  * but it makes sense to only allow bindless_sampler/bound_sampler for
  * sampler types, and respectively bindless_image/bound_image for image
  * types.
  */
 if ((qual->flags.q.bindless_sampler || qual->flags.q.bound_sampler) &&
     !var->type->contains_sampler()) {
    _mesa_glsl_error(loc, state, "bindless_sampler or bound_sampler can only "
                     "be applied to sampler types");
    return;
 }

 if ((qual->flags.q.bindless_image || qual->flags.q.bound_image) &&
     !var->type->contains_image()) {
    _mesa_glsl_error(loc, state, "bindless_image or bound_image can only be "
                     "applied to image types");
    return;
 }

 /* The bindless_sampler/bindless_image (and respectively
  * bound_sampler/bound_image) layout qualifiers can be set at global and at
  * local scope.
  */
 if (var->type->contains_sampler() || var->type->contains_image()) {
    var->data.bindless = qual->flags.q.bindless_sampler ||
                         qual->flags.q.bindless_image ||
                         state->bindless_sampler_specified ||
                         state->bindless_image_specified;

    var->data.bound = qual->flags.q.bound_sampler ||
                      qual->flags.q.bound_image ||
                      state->bound_sampler_specified ||
                      state->bound_image_specified;
 }
3654}

3656static void
3657apply_layout_qualifier_to_variable(const struct ast_type_qualifier *qual,
                                 ir_variable *var,
                                 struct _mesa_glsl_parse_state *state,
                                 YYLTYPE *loc)
3661{
 if (var->name != NULL__null && strcmp(var->name, "gl_FragCoord") == 0) {
1
Assuming field 'name' is equal to NULL→

    /* Section 4.3.8.1, page 39 of GLSL 1.50 spec says:
     *
     *    "Within any shader, the first redeclarations of gl_FragCoord
     *     must appear before any use of gl_FragCoord."
     *
     * Generate a compiler error if above condition is not met by the
     * fragment shader.
     */
    ir_variable *earlier = state->symbols->get_variable("gl_FragCoord");
    if (earlier != NULL__null &&
        earlier->data.used &&
        !state->fs_redeclares_gl_fragcoord) {
       _mesa_glsl_error(loc, state,
                        "gl_FragCoord used before its first redeclaration "
                        "in fragment shader");
    }

    /* Make sure all gl_FragCoord redeclarations specify the same layout
     * qualifiers.
     */
    if (is_conflicting_fragcoord_redeclaration(state, qual)) {
       const char *const qual_string =
          get_layout_qualifier_string(qual->flags.q.origin_upper_left,
                                      qual->flags.q.pixel_center_integer);

       const char *const state_string =
          get_layout_qualifier_string(state->fs_origin_upper_left,
                                      state->fs_pixel_center_integer);

       _mesa_glsl_error(loc, state,
                        "gl_FragCoord redeclared with different layout "
                        "qualifiers (%s) and (%s) ",
                        state_string,
                        qual_string);
    }
    state->fs_origin_upper_left = qual->flags.q.origin_upper_left;
    state->fs_pixel_center_integer = qual->flags.q.pixel_center_integer;
    state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers =
       !qual->flags.q.origin_upper_left && !qual->flags.q.pixel_center_integer;
    state->fs_redeclares_gl_fragcoord =
       state->fs_origin_upper_left ||
       state->fs_pixel_center_integer ||
       state->fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
 }

 if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
2
←
Assuming field 'origin_upper_left' is 0→
3
←
Assuming field 'pixel_center_integer' is 0→
     && (strcmp(var->name, "gl_FragCoord") != 0)) {
    const char *const qual_string = (qual->flags.q.origin_upper_left)
       ? "origin_upper_left" : "pixel_center_integer";

    _mesa_glsl_error(loc, state,
                     "layout qualifier `%s' can only be applied to "
                     "fragment shader input `gl_FragCoord'",
                     qual_string);
 }

 if (qual->flags.q.explicit_location) {
4
←
Assuming field 'explicit_location' is 0→
5
←
Taking false branch→
    apply_explicit_location(qual, var, state, loc);

    if (qual->flags.q.explicit_component) {
       unsigned qual_component;
       if (process_qualifier_constant(state, loc, "component",
                                      qual->component, &qual_component)) {
          const glsl_type *type = var->type->without_array();
          unsigned components = type->component_slots();

          if (type->is_matrix() || type->is_struct()) {
             _mesa_glsl_error(loc, state, "component layout qualifier "
                              "cannot be applied to a matrix, a structure, "
                              "a block, or an array containing any of "
                              "these.");
          } else if (components > 4 && type->is_64bit()) {
             _mesa_glsl_error(loc, state, "component layout qualifier "
                              "cannot be applied to dvec%u.",
                              components / 2);
          } else if (qual_component != 0 &&
              (qual_component + components - 1) > 3) {
             _mesa_glsl_error(loc, state, "component overflow (%u > 3)",
                              (qual_component + components - 1));
          } else if (qual_component == 1 && type->is_64bit()) {
             /* We don't bother checking for 3 as it should be caught by the
              * overflow check above.
              */
             _mesa_glsl_error(loc, state, "doubles cannot begin at "
                              "component 1 or 3");
          } else {
             var->data.explicit_component = true;
             var->data.location_frac = qual_component;
          }
       }
    }
 } else if (qual->flags.q.explicit_index) {
6
←
Assuming field 'explicit_index' is 0→
7
←
Taking false branch→
    if (!qual->subroutine_list)
       _mesa_glsl_error(loc, state,
                        "explicit index requires explicit location");
 } else if (qual->flags.q.explicit_component) {
8
←
Assuming field 'explicit_component' is 0→
9
←
Taking false branch→
    _mesa_glsl_error(loc, state,
                     "explicit component requires explicit location");
 }

 if (qual->flags.q.explicit_binding) {
10
←
Assuming field 'explicit_binding' is 0→
    apply_explicit_binding(state, loc, var, var->type, qual);
 }

 if (state->stage == MESA_SHADER_GEOMETRY &&
11
←
Assuming field 'stage' is not equal to MESA_SHADER_GEOMETRY→
     qual->flags.q.out && qual->flags.q.stream) {
    unsigned qual_stream;
    if (process_qualifier_constant(state, loc, "stream", qual->stream,
                                   &qual_stream) &&
        validate_stream_qualifier(loc, state, qual_stream)) {
       var->data.stream = qual_stream;
    }
 }

 if (qual->flags.q.out && qual->flags.q.xfb_buffer) {
12
←
Assuming field 'out' is 0→
    unsigned qual_xfb_buffer;
    if (process_qualifier_constant(state, loc, "xfb_buffer",
                                   qual->xfb_buffer, &qual_xfb_buffer) &&
        validate_xfb_buffer_qualifier(loc, state, qual_xfb_buffer)) {
       var->data.xfb_buffer = qual_xfb_buffer;
       if (qual->flags.q.explicit_xfb_buffer)
          var->data.explicit_xfb_buffer = true;
    }
 }

 if (qual->flags.q.explicit_xfb_offset) {
13
←
Assuming field 'explicit_xfb_offset' is 0→
14
←
Taking false branch→
    unsigned qual_xfb_offset;
    unsigned component_size = var->type->contains_double() ? 8 : 4;

    if (process_qualifier_constant(state, loc, "xfb_offset",
                                   qual->offset, &qual_xfb_offset) &&
        validate_xfb_offset_qualifier(loc, state, (int) qual_xfb_offset,
                                      var->type, component_size)) {
       var->data.offset = qual_xfb_offset;
       var->data.explicit_xfb_offset = true;
    }
 }

 if (qual->flags.q.explicit_xfb_stride) {
15
←
Assuming field 'explicit_xfb_stride' is 0→
16
←
Taking false branch→
    unsigned qual_xfb_stride;
    if (process_qualifier_constant(state, loc, "xfb_stride",
                                   qual->xfb_stride, &qual_xfb_stride)) {
       var->data.xfb_stride = qual_xfb_stride;
       var->data.explicit_xfb_stride = true;
    }
 }

 if (var->type->contains_atomic()) {
    if (var->data.mode == ir_var_uniform) {
       if (var->data.explicit_binding) {
          unsigned *offset =
             &state->atomic_counter_offsets[var->data.binding];

          if (*offset % ATOMIC_COUNTER_SIZE4)
             _mesa_glsl_error(loc, state,
                              "misaligned atomic counter offset");

          var->data.offset = *offset;
          *offset += var->type->atomic_size();

       } else {
          _mesa_glsl_error(loc, state,
                           "atomic counters require explicit binding point");
       }
    } else if (var->data.mode != ir_var_function_in) {
       _mesa_glsl_error(loc, state, "atomic counters may only be declared as "
                        "function parameters or uniform-qualified "
                        "global variables");
    }
 }

 if (var->type->contains_sampler() &&
17
←
Assuming the condition is false→
     !validate_storage_for_sampler_image_types(var, state, loc))
    return;

 /* Is the 'layout' keyword used with parameters that allow relaxed checking.
  * Many implementations of GL_ARB_fragment_coord_conventions_enable and some
  * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable
  * allowed the layout qualifier to be used with 'varying' and 'attribute'.
  * These extensions and all following extensions that add the 'layout'
  * keyword have been modified to require the use of 'in' or 'out'.
  *
  * The following extension do not allow the deprecated keywords:
  *
  *    GL_AMD_conservative_depth
  *    GL_ARB_conservative_depth
  *    GL_ARB_gpu_shader5
  *    GL_ARB_separate_shader_objects
  *    GL_ARB_tessellation_shader
  *    GL_ARB_transform_feedback3
  *    GL_ARB_uniform_buffer_object
  *
  * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5
  * allow layout with the deprecated keywords.
  */
 const bool relaxed_layout_qualifier_checking =
    state->ARB_fragment_coord_conventions_enable;

 const bool uses_deprecated_qualifier = qual->flags.q.attribute
18
←
Assuming field 'attribute' is 0→
    || qual->flags.q.varying;
 if (qual->has_layout() && uses_deprecated_qualifier) {
19
←
Assuming the condition is false→
    if (relaxed_layout_qualifier_checking) {
       _mesa_glsl_warning(loc, state,
                          "`layout' qualifier may not be used with "
                          "`attribute' or `varying'");
    } else {
       _mesa_glsl_error(loc, state,
                        "`layout' qualifier may not be used with "
                        "`attribute' or `varying'");
    }
 }

 /* Layout qualifiers for gl_FragDepth, which are enabled by extension
  * AMD_conservative_depth.
  */
 if (qual->flags.q.depth_type
20
←
Assuming field 'depth_type' is not equal to 0→
     && !state->is_version(420, 0)
     && !state->AMD_conservative_depth_enable
     && !state->ARB_conservative_depth_enable) {
     _mesa_glsl_error(loc, state,
                      "extension GL_AMD_conservative_depth or "
                      "GL_ARB_conservative_depth must be enabled "
                      "to use depth layout qualifiers");
 } else if (qual->flags.q.depth_type

20.1	Field 'depth_type' is not equal to 0

3888 && strcmp(var->name, "gl_FragDepth") != 0) {

←

Null pointer passed to 1st parameter expecting 'nonnull'

3889 _mesa_glsl_error(loc, state, 3890 "depth layout qualifiers can be applied only to " 3891 "gl_FragDepth"); 3892 } 3893 3894 switch (qual->depth_type) { 3895 case ast_depth_any: 3896 var->data.depth_layout = ir_depth_layout_any; 3897 break; 3898 case ast_depth_greater: 3899 var->data.depth_layout = ir_depth_layout_greater; 3900 break; 3901 case ast_depth_less: 3902 var->data.depth_layout = ir_depth_layout_less; 3903 break; 3904 case ast_depth_unchanged: 3905 var->data.depth_layout = ir_depth_layout_unchanged; 3906 break; 3907 default: 3908 var->data.depth_layout = ir_depth_layout_none; 3909 break; 3910 } 3911 3912 if (qual->flags.q.std140 || 3913 qual->flags.q.std430 || 3914 qual->flags.q.packed || 3915 qual->flags.q.shared) { 3916 _mesa_glsl_error(loc, state, 3917 "uniform and shader storage block layout qualifiers " 3918 "std140, std430, packed, and shared can only be " 3919 "applied to uniform or shader storage blocks, not " 3920 "members"); 3921 } 3922 3923 if (qual->flags.q.row_major || qual->flags.q.column_major) { 3924 validate_matrix_layout_for_type(state, loc, var->type, var); 3925 } 3926 3927 /* From section 4.4.1.3 of the GLSL 4.50 specification (Fragment Shader 3928 * Inputs): 3929 * 3930 * "Fragment shaders also allow the following layout qualifier on in only 3931 * (not with variable declarations) 3932 * layout-qualifier-id 3933 * early_fragment_tests 3934 * [...]" 3935 */ 3936 if (qual->flags.q.early_fragment_tests) { 3937 _mesa_glsl_error(loc, state, "early_fragment_tests layout qualifier only " 3938 "valid in fragment shader input layout declaration."); 3939 } 3940 3941 if (qual->flags.q.inner_coverage) { 3942 _mesa_glsl_error(loc, state, "inner_coverage layout qualifier only " 3943 "valid in fragment shader input layout declaration."); 3944 } 3945 3946 if (qual->flags.q.post_depth_coverage) { 3947 _mesa_glsl_error(loc, state, "post_depth_coverage layout qualifier only " 3948 "valid in fragment shader input layout declaration."); 3949 } 3950 3951 if (state->has_bindless()) 3952 apply_bindless_qualifier_to_variable(qual, var, state, loc); 3953 3954 if (qual->flags.q.pixel_interlock_ordered || 3955 qual->flags.q.pixel_interlock_unordered || 3956 qual->flags.q.sample_interlock_ordered || 3957 qual->flags.q.sample_interlock_unordered) { 3958 _mesa_glsl_error(loc, state, "interlock layout qualifiers: " 3959 "pixel_interlock_ordered, pixel_interlock_unordered, " 3960 "sample_interlock_ordered and sample_interlock_unordered, " 3961 "only valid in fragment shader input layout declaration."); 3962 } 3963 3964 if (var->name != NULL__null && strcmp(var->name, "gl_Layer") == 0) { 3965 if (is_conflicting_layer_redeclaration(state, qual)) { 3966 _mesa_glsl_error(loc, state, "gl_Layer redeclaration with " 3967 "different viewport_relative setting than earlier"); 3968 } 3969 state->redeclares_gl_layer = 1; 3970 if (qual->flags.q.viewport_relative) { 3971 state->layer_viewport_relative = 1; 3972 } 3973 } else if (qual->flags.q.viewport_relative) { 3974 _mesa_glsl_error(loc, state, 3975 "viewport_relative qualifier " 3976 "can only be applied to gl_Layer."); 3977 } 3978} 3979 3980static void 3981apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, 3982 ir_variable *var, 3983 struct _mesa_glsl_parse_state *state, 3984 YYLTYPE *loc, 3985 bool is_parameter) 3986{ 3987 STATIC_ASSERT(sizeof(qual->flags.q) <= sizeof(qual->flags.i))do { (void) sizeof(char [1 - 2*!(sizeof(qual->flags.q) <=
sizeof(qual->flags.i))]); } while (0); 3988 3989 if (qual->flags.q.invariant) { 3990 if (var->data.used) { 3991 _mesa_glsl_error(loc, state, 3992 "variable `%s' may not be redeclared " 3993 "`invariant' after being used", 3994 var->name); 3995 } else { 3996 var->data.explicit_invariant = true; 3997 var->data.invariant = true; 3998 } 3999 } 4000 4001 if (qual->flags.q.precise) { 4002 if (var->data.used) { 4003 _mesa_glsl_error(loc, state, 4004 "variable `%s' may not be redeclared " 4005 "`precise' after being used", 4006 var->name); 4007 } else { 4008 var->data.precise = 1; 4009 } 4010 } 4011 4012 if (qual->is_subroutine_decl() && !qual->flags.q.uniform) { 4013 _mesa_glsl_error(loc, state, 4014 "`subroutine' may only be applied to uniforms, " 4015 "subroutine type declarations, or function definitions"); 4016 } 4017 4018 if (qual->flags.q.constant || qual->flags.q.attribute 4019 || qual->flags.q.uniform 4020 || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT))) 4021 var->data.read_only = 1; 4022 4023 if (qual->flags.q.centroid) 4024 var->data.centroid = 1; 4025 4026 if (qual->flags.q.sample) 4027 var->data.sample = 1; 4028 4029 /* Precision qualifiers do not hold any meaning in Desktop GLSL */ 4030 if (state->es_shader) { 4031 var->data.precision = 4032 select_gles_precision(qual->precision, var->type, state, loc); 4033 } 4034 4035 if (qual->flags.q.patch) 4036 var->data.patch = 1; 4037 4038 if (qual->flags.q.attribute && state->stage != MESA_SHADER_VERTEX) { 4039 var->type = glsl_type::error_type; 4040 _mesa_glsl_error(loc, state, 4041 "`attribute' variables may not be declared in the " 4042 "%s shader", 4043 _mesa_shader_stage_to_string(state->stage)); 4044 } 4045 4046 /* Disallow layout qualifiers which may only appear on layout declarations. */ 4047 if (qual->flags.q.prim_type) { 4048 _mesa_glsl_error(loc, state, 4049 "Primitive type may only be specified on GS input or output " 4050 "layout declaration, not on variables."); 4051 } 4052 4053 /* Section 6.1.1 (Function Calling Conventions) of the GLSL 1.10 spec says: 4054 * 4055 * "However, the const qualifier cannot be used with out or inout." 4056 * 4057 * The same section of the GLSL 4.40 spec further clarifies this saying: 4058 * 4059 * "The const qualifier cannot be used with out or inout, or a 4060 * compile-time error results." 4061 */ 4062 if (is_parameter && qual->flags.q.constant && qual->flags.q.out) { 4063 _mesa_glsl_error(loc, state, 4064 "`const' may not be applied to `out' or `inout' " 4065 "function parameters"); 4066 } 4067 4068 /* If there is no qualifier that changes the mode of the variable, leave 4069 * the setting alone. 4070 */ 4071 assert(var->data.mode != ir_var_temporary)(static_cast <bool> (var->data.mode != ir_var_temporary
) ? void (0) : __assert_fail ("var->data.mode != ir_var_temporary"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 4072 if (qual->flags.q.in && qual->flags.q.out) 4073 var->data.mode = is_parameter ? ir_var_function_inout : ir_var_shader_out; 4074 else if (qual->flags.q.in) 4075 var->data.mode = is_parameter ? ir_var_function_in : ir_var_shader_in; 4076 else if (qual->flags.q.attribute 4077 || (qual->flags.q.varying && (state->stage == MESA_SHADER_FRAGMENT))) 4078 var->data.mode = ir_var_shader_in; 4079 else if (qual->flags.q.out) 4080 var->data.mode = is_parameter ? ir_var_function_out : ir_var_shader_out; 4081 else if (qual->flags.q.varying && (state->stage == MESA_SHADER_VERTEX)) 4082 var->data.mode = ir_var_shader_out; 4083 else if (qual->flags.q.uniform) 4084 var->data.mode = ir_var_uniform; 4085 else if (qual->flags.q.buffer) 4086 var->data.mode = ir_var_shader_storage; 4087 else if (qual->flags.q.shared_storage) 4088 var->data.mode = ir_var_shader_shared; 4089 4090 if (!is_parameter && state->has_framebuffer_fetch() && 4091 state->stage == MESA_SHADER_FRAGMENT) { 4092 if (state->is_version(130, 300)) 4093 var->data.fb_fetch_output = qual->flags.q.in && qual->flags.q.out; 4094 else 4095 var->data.fb_fetch_output = (strcmp(var->name, "gl_LastFragData") == 0); 4096 } 4097 4098 if (var->data.fb_fetch_output) { 4099 var->data.assigned = true; 4100 var->data.memory_coherent = !qual->flags.q.non_coherent; 4101 4102 /* From the EXT_shader_framebuffer_fetch spec: 4103 * 4104 * "It is an error to declare an inout fragment output not qualified 4105 * with layout(noncoherent) if the GL_EXT_shader_framebuffer_fetch 4106 * extension hasn't been enabled." 4107 */ 4108 if (var->data.memory_coherent && 4109 !state->EXT_shader_framebuffer_fetch_enable) 4110 _mesa_glsl_error(loc, state, 4111 "invalid declaration of framebuffer fetch output not " 4112 "qualified with layout(noncoherent)"); 4113 4114 } else { 4115 /* From the EXT_shader_framebuffer_fetch spec: 4116 * 4117 * "Fragment outputs declared inout may specify the following layout 4118 * qualifier: [...] noncoherent" 4119 */ 4120 if (qual->flags.q.non_coherent) 4121 _mesa_glsl_error(loc, state, 4122 "invalid layout(noncoherent) qualifier not part of " 4123 "framebuffer fetch output declaration"); 4124 } 4125 4126 if (!is_parameter && is_varying_var(var, state->stage)) { 4127 /* User-defined ins/outs are not permitted in compute shaders. */ 4128 if (state->stage == MESA_SHADER_COMPUTE) { 4129 _mesa_glsl_error(loc, state, 4130 "user-defined input and output variables are not " 4131 "permitted in compute shaders"); 4132 } 4133 4134 /* This variable is being used to link data between shader stages (in 4135 * pre-glsl-1.30 parlance, it's a "varying"). Check that it has a type 4136 * that is allowed for such purposes. 4137 * 4138 * From page 25 (page 31 of the PDF) of the GLSL 1.10 spec: 4139 * 4140 * "The varying qualifier can be used only with the data types 4141 * float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of 4142 * these." 4143 * 4144 * This was relaxed in GLSL version 1.30 and GLSL ES version 3.00. From 4145 * page 31 (page 37 of the PDF) of the GLSL 1.30 spec: 4146 * 4147 * "Fragment inputs can only be signed and unsigned integers and 4148 * integer vectors, float, floating-point vectors, matrices, or 4149 * arrays of these. Structures cannot be input. 4150 * 4151 * Similar text exists in the section on vertex shader outputs. 4152 * 4153 * Similar text exists in the GLSL ES 3.00 spec, except that the GLSL ES 4154 * 3.00 spec allows structs as well. Varying structs are also allowed 4155 * in GLSL 1.50. 4156 * 4157 * From section 4.3.4 of the ARB_bindless_texture spec: 4158 * 4159 * "(modify third paragraph of the section to allow sampler and image 4160 * types) ... Vertex shader inputs can only be float, 4161 * single-precision floating-point scalars, single-precision 4162 * floating-point vectors, matrices, signed and unsigned integers 4163 * and integer vectors, sampler and image types." 4164 * 4165 * From section 4.3.6 of the ARB_bindless_texture spec: 4166 * 4167 * "Output variables can only be floating-point scalars, 4168 * floating-point vectors, matrices, signed or unsigned integers or 4169 * integer vectors, sampler or image types, or arrays or structures 4170 * of any these." 4171 */ 4172 switch (var->type->without_array()->base_type) { 4173 case GLSL_TYPE_FLOAT: 4174 /* Ok in all GLSL versions */ 4175 break; 4176 case GLSL_TYPE_UINT: 4177 case GLSL_TYPE_INT: 4178 if (state->is_version(130, 300) || state->EXT_gpu_shader4_enable) 4179 break; 4180 _mesa_glsl_error(loc, state, 4181 "varying variables must be of base type float in %s", 4182 state->get_version_string()); 4183 break; 4184 case GLSL_TYPE_STRUCT: 4185 if (state->is_version(150, 300)) 4186 break; 4187 _mesa_glsl_error(loc, state, 4188 "varying variables may not be of type struct"); 4189 break; 4190 case GLSL_TYPE_DOUBLE: 4191 case GLSL_TYPE_UINT64: 4192 case GLSL_TYPE_INT64: 4193 break; 4194 case GLSL_TYPE_SAMPLER: 4195 case GLSL_TYPE_IMAGE: 4196 if (state->has_bindless()) 4197 break; 4198 /* fallthrough */ 4199 default: 4200 _mesa_glsl_error(loc, state, "illegal type for a varying variable"); 4201 break; 4202 } 4203 } 4204 4205 if (state->all_invariant && var->data.mode == ir_var_shader_out) { 4206 var->data.explicit_invariant = true; 4207 var->data.invariant = true; 4208 } 4209 4210 var->data.interpolation = 4211 interpret_interpolation_qualifier(qual, var->type, 4212 (ir_variable_mode) var->data.mode, 4213 state, loc); 4214 4215 /* Does the declaration use the deprecated 'attribute' or 'varying' 4216 * keywords? 4217 */ 4218 const bool uses_deprecated_qualifier = qual->flags.q.attribute 4219 || qual->flags.q.varying; 4220 4221 4222 /* Validate auxiliary storage qualifiers */ 4223 4224 /* From section 4.3.4 of the GLSL 1.30 spec: 4225 * "It is an error to use centroid in in a vertex shader." 4226 * 4227 * From section 4.3.4 of the GLSL ES 3.00 spec: 4228 * "It is an error to use centroid in or interpolation qualifiers in 4229 * a vertex shader input." 4230 */ 4231 4232 /* Section 4.3.6 of the GLSL 1.30 specification states: 4233 * "It is an error to use centroid out in a fragment shader." 4234 * 4235 * The GL_ARB_shading_language_420pack extension specification states: 4236 * "It is an error to use auxiliary storage qualifiers or interpolation 4237 * qualifiers on an output in a fragment shader." 4238 */ 4239 if (qual->flags.q.sample && (!is_varying_var(var, state->stage) || uses_deprecated_qualifier)) { 4240 _mesa_glsl_error(loc, state, 4241 "sample qualifier may only be used on `in` or `out` " 4242 "variables between shader stages"); 4243 } 4244 if (qual->flags.q.centroid && !is_varying_var(var, state->stage)) { 4245 _mesa_glsl_error(loc, state, 4246 "centroid qualifier may only be used with `in', " 4247 "`out' or `varying' variables between shader stages"); 4248 } 4249 4250 if (qual->flags.q.shared_storage && state->stage != MESA_SHADER_COMPUTE) { 4251 _mesa_glsl_error(loc, state, 4252 "the shared storage qualifiers can only be used with " 4253 "compute shaders"); 4254 } 4255 4256 apply_image_qualifier_to_variable(qual, var, state, loc); 4257} 4258 4259/** 4260 * Get the variable that is being redeclared by this declaration or if it 4261 * does not exist, the current declared variable. 4262 * 4263 * Semantic checks to verify the validity of the redeclaration are also 4264 * performed. If semantic checks fail, compilation error will be emitted via 4265 * \c _mesa_glsl_error, but a non-\c NULL pointer will still be returned. 4266 * 4267 * \returns 4268 * A pointer to an existing variable in the current scope if the declaration 4269 * is a redeclaration, current variable otherwise. \c is_declared boolean 4270 * will return \c true if the declaration is a redeclaration, \c false 4271 * otherwise. 4272 */ 4273static ir_variable * 4274get_variable_being_redeclared(ir_variable **var_ptr, YYLTYPE loc, 4275 struct _mesa_glsl_parse_state *state, 4276 bool allow_all_redeclarations, 4277 bool *is_redeclaration) 4278{ 4279 ir_variable *var = *var_ptr; 4280 4281 /* Check if this declaration is actually a re-declaration, either to 4282 * resize an array or add qualifiers to an existing variable. 4283 * 4284 * This is allowed for variables in the current scope, or when at 4285 * global scope (for built-ins in the implicit outer scope). 4286 */ 4287 ir_variable *earlier = state->symbols->get_variable(var->name); 4288 if (earlier == NULL__null || 4289 (state->current_function != NULL__null && 4290 !state->symbols->name_declared_this_scope(var->name))) { 4291 *is_redeclaration = false; 4292 return var; 4293 } 4294 4295 *is_redeclaration = true; 4296 4297 if (earlier->data.how_declared == ir_var_declared_implicitly) { 4298 /* Verify that the redeclaration of a built-in does not change the 4299 * storage qualifier. There are a couple special cases. 4300 * 4301 * 1. Some built-in variables that are defined as 'in' in the 4302 * specification are implemented as system values. Allow 4303 * ir_var_system_value -> ir_var_shader_in. 4304 * 4305 * 2. gl_LastFragData is implemented as a ir_var_shader_out, but the 4306 * specification requires that redeclarations omit any qualifier. 4307 * Allow ir_var_shader_out -> ir_var_auto for this one variable. 4308 */ 4309 if (earlier->data.mode != var->data.mode && 4310 !(earlier->data.mode == ir_var_system_value && 4311 var->data.mode == ir_var_shader_in) && 4312 !(strcmp(var->name, "gl_LastFragData") == 0 && 4313 var->data.mode == ir_var_auto)) { 4314 _mesa_glsl_error(&loc, state, 4315 "redeclaration cannot change qualification of `%s'", 4316 var->name); 4317 } 4318 } 4319 4320 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec, 4321 * 4322 * "It is legal to declare an array without a size and then 4323 * later re-declare the same name as an array of the same 4324 * type and specify a size." 4325 */ 4326 if (earlier->type->is_unsized_array() && var->type->is_array() 4327 && (var->type->fields.array == earlier->type->fields.array)) { 4328 const int size = var->type->array_size(); 4329 check_builtin_array_max_size(var->name, size, loc, state); 4330 if ((size > 0) && (size <= earlier->data.max_array_access)) { 4331 _mesa_glsl_error(& loc, state, "array size must be > %u due to " 4332 "previous access", 4333 earlier->data.max_array_access); 4334 } 4335 4336 earlier->type = var->type; 4337 delete var; 4338 var = NULL__null; 4339 *var_ptr = NULL__null; 4340 } else if (earlier->type != var->type) { 4341 _mesa_glsl_error(&loc, state, 4342 "redeclaration of `%s' has incorrect type", 4343 var->name); 4344 } else if ((state->ARB_fragment_coord_conventions_enable || 4345 state->is_version(150, 0)) 4346 && strcmp(var->name, "gl_FragCoord") == 0) { 4347 /* Allow redeclaration of gl_FragCoord for ARB_fcc layout 4348 * qualifiers. 4349 * 4350 * We don't really need to do anything here, just allow the 4351 * redeclaration. Any error on the gl_FragCoord is handled on the ast 4352 * level at apply_layout_qualifier_to_variable using the 4353 * ast_type_qualifier and _mesa_glsl_parse_state, or later at 4354 * linker.cpp. 4355 */ 4356 /* According to section 4.3.7 of the GLSL 1.30 spec, 4357 * the following built-in varaibles can be redeclared with an 4358 * interpolation qualifier: 4359 * * gl_FrontColor 4360 * * gl_BackColor 4361 * * gl_FrontSecondaryColor 4362 * * gl_BackSecondaryColor 4363 * * gl_Color 4364 * * gl_SecondaryColor 4365 */ 4366 } else if (state->is_version(130, 0) 4367 && (strcmp(var->name, "gl_FrontColor") == 0 4368 || strcmp(var->name, "gl_BackColor") == 0 4369 || strcmp(var->name, "gl_FrontSecondaryColor") == 0 4370 || strcmp(var->name, "gl_BackSecondaryColor") == 0 4371 || strcmp(var->name, "gl_Color") == 0 4372 || strcmp(var->name, "gl_SecondaryColor") == 0)) { 4373 earlier->data.interpolation = var->data.interpolation; 4374 4375 /* Layout qualifiers for gl_FragDepth. */ 4376 } else if ((state->is_version(420, 0) || 4377 state->AMD_conservative_depth_enable || 4378 state->ARB_conservative_depth_enable) 4379 && strcmp(var->name, "gl_FragDepth") == 0) { 4380 4381 /** From the AMD_conservative_depth spec: 4382 * Within any shader, the first redeclarations of gl_FragDepth 4383 * must appear before any use of gl_FragDepth. 4384 */ 4385 if (earlier->data.used) { 4386 _mesa_glsl_error(&loc, state, 4387 "the first redeclaration of gl_FragDepth " 4388 "must appear before any use of gl_FragDepth"); 4389 } 4390 4391 /* Prevent inconsistent redeclaration of depth layout qualifier. */ 4392 if (earlier->data.depth_layout != ir_depth_layout_none 4393 && earlier->data.depth_layout != var->data.depth_layout) { 4394 _mesa_glsl_error(&loc, state, 4395 "gl_FragDepth: depth layout is declared here " 4396 "as '%s, but it was previously declared as " 4397 "'%s'", 4398 depth_layout_string(var->data.depth_layout), 4399 depth_layout_string(earlier->data.depth_layout)); 4400 } 4401 4402 earlier->data.depth_layout = var->data.depth_layout; 4403 4404 } else if (state->has_framebuffer_fetch() && 4405 strcmp(var->name, "gl_LastFragData") == 0 && 4406 var->data.mode == ir_var_auto) { 4407 /* According to the EXT_shader_framebuffer_fetch spec: 4408 * 4409 * "By default, gl_LastFragData is declared with the mediump precision 4410 * qualifier. This can be changed by redeclaring the corresponding 4411 * variables with the desired precision qualifier." 4412 * 4413 * "Fragment shaders may specify the following layout qualifier only for 4414 * redeclaring the built-in gl_LastFragData array [...]: noncoherent" 4415 */ 4416 earlier->data.precision = var->data.precision; 4417 earlier->data.memory_coherent = var->data.memory_coherent; 4418 4419 } else if (state->NV_viewport_array2_enable && 4420 strcmp(var->name, "gl_Layer") == 0 && 4421 earlier->data.how_declared == ir_var_declared_implicitly) { 4422 /* No need to do anything, just allow it. Qualifier is stored in state */ 4423 4424 } else if ((earlier->data.how_declared == ir_var_declared_implicitly && 4425 state->allow_builtin_variable_redeclaration) || 4426 allow_all_redeclarations) { 4427 /* Allow verbatim redeclarations of built-in variables. Not explicitly 4428 * valid, but some applications do it. 4429 */ 4430 } else { 4431 _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name); 4432 } 4433 4434 return earlier; 4435} 4436 4437/** 4438 * Generate the IR for an initializer in a variable declaration 4439 */ 4440static ir_rvalue * 4441process_initializer(ir_variable *var, ast_declaration *decl, 4442 ast_fully_specified_type *type, 4443 exec_list *initializer_instructions, 4444 struct _mesa_glsl_parse_state *state) 4445{ 4446 void *mem_ctx = state; 4447 ir_rvalue *result = NULL__null; 4448 4449 YYLTYPE initializer_loc = decl->initializer->get_location(); 4450 4451 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec: 4452 * 4453 * "All uniform variables are read-only and are initialized either 4454 * directly by an application via API commands, or indirectly by 4455 * OpenGL." 4456 */ 4457 if (var->data.mode == ir_var_uniform) { 4458 state->check_version(120, 0, &initializer_loc, 4459 "cannot initialize uniform %s", 4460 var->name); 4461 } 4462 4463 /* Section 4.3.7 "Buffer Variables" of the GLSL 4.30 spec: 4464 * 4465 * "Buffer variables cannot have initializers." 4466 */ 4467 if (var->data.mode == ir_var_shader_storage) { 4468 _mesa_glsl_error(&initializer_loc, state, 4469 "cannot initialize buffer variable %s", 4470 var->name); 4471 } 4472 4473 /* From section 4.1.7 of the GLSL 4.40 spec: 4474 * 4475 * "Opaque variables [...] are initialized only through the 4476 * OpenGL API; they cannot be declared with an initializer in a 4477 * shader." 4478 * 4479 * From section 4.1.7 of the ARB_bindless_texture spec: 4480 * 4481 * "Samplers may be declared as shader inputs and outputs, as uniform 4482 * variables, as temporary variables, and as function parameters." 4483 * 4484 * From section 4.1.X of the ARB_bindless_texture spec: 4485 * 4486 * "Images may be declared as shader inputs and outputs, as uniform 4487 * variables, as temporary variables, and as function parameters." 4488 */ 4489 if (var->type->contains_atomic() || 4490 (!state->has_bindless() && var->type->contains_opaque())) { 4491 _mesa_glsl_error(&initializer_loc, state, 4492 "cannot initialize %s variable %s", 4493 var->name, state->has_bindless() ? "atomic" : "opaque"); 4494 } 4495 4496 if ((var->data.mode == ir_var_shader_in) && (state->current_function == NULL__null)) { 4497 _mesa_glsl_error(&initializer_loc, state, 4498 "cannot initialize %s shader input / %s %s", 4499 _mesa_shader_stage_to_string(state->stage), 4500 (state->stage == MESA_SHADER_VERTEX) 4501 ? "attribute" : "varying", 4502 var->name); 4503 } 4504 4505 if (var->data.mode == ir_var_shader_out && state->current_function == NULL__null) { 4506 _mesa_glsl_error(&initializer_loc, state, 4507 "cannot initialize %s shader output %s", 4508 _mesa_shader_stage_to_string(state->stage), 4509 var->name); 4510 } 4511 4512 /* If the initializer is an ast_aggregate_initializer, recursively store 4513 * type information from the LHS into it, so that its hir() function can do 4514 * type checking. 4515 */ 4516 if (decl->initializer->oper == ast_aggregate) 4517 _mesa_ast_set_aggregate_type(var->type, decl->initializer); 4518 4519 ir_dereference *const lhs = new(state) ir_dereference_variable(var); 4520 ir_rvalue *rhs = decl->initializer->hir(initializer_instructions, state); 4521 4522 /* Calculate the constant value if this is a const or uniform 4523 * declaration. 4524 * 4525 * Section 4.3 (Storage Qualifiers) of the GLSL ES 1.00.17 spec says: 4526 * 4527 * "Declarations of globals without a storage qualifier, or with 4528 * just the const qualifier, may include initializers, in which case 4529 * they will be initialized before the first line of main() is 4530 * executed. Such initializers must be a constant expression." 4531 * 4532 * The same section of the GLSL ES 3.00.4 spec has similar language. 4533 */ 4534 if (type->qualifier.flags.q.constant 4535 || type->qualifier.flags.q.uniform 4536 || (state->es_shader && state->current_function == NULL__null)) { 4537 ir_rvalue *new_rhs = validate_assignment(state, initializer_loc, 4538 lhs, rhs, true); 4539 if (new_rhs != NULL__null) { 4540 rhs = new_rhs; 4541 4542 /* Section 4.3.3 (Constant Expressions) of the GLSL ES 3.00.4 spec 4543 * says: 4544 * 4545 * "A constant expression is one of 4546 * 4547 * ... 4548 * 4549 * - an expression formed by an operator on operands that are 4550 * all constant expressions, including getting an element of 4551 * a constant array, or a field of a constant structure, or 4552 * components of a constant vector. However, the sequence 4553 * operator ( , ) and the assignment operators ( =, +=, ...) 4554 * are not included in the operators that can create a 4555 * constant expression." 4556 * 4557 * Section 12.43 (Sequence operator and constant expressions) says: 4558 * 4559 * "Should the following construct be allowed? 4560 * 4561 * float a[2,3]; 4562 * 4563 * The expression within the brackets uses the sequence operator 4564 * (',') and returns the integer 3 so the construct is declaring 4565 * a single-dimensional array of size 3. In some languages, the 4566 * construct declares a two-dimensional array. It would be 4567 * preferable to make this construct illegal to avoid confusion. 4568 * 4569 * One possibility is to change the definition of the sequence 4570 * operator so that it does not return a constant-expression and 4571 * hence cannot be used to declare an array size. 4572 * 4573 * RESOLUTION: The result of a sequence operator is not a 4574 * constant-expression." 4575 * 4576 * Section 4.3.3 (Constant Expressions) of the GLSL 4.30.9 spec 4577 * contains language almost identical to the section 4.3.3 in the 4578 * GLSL ES 3.00.4 spec. This is a new limitation for these GLSL 4579 * versions. 4580 */ 4581 ir_constant *constant_value = 4582 rhs->constant_expression_value(mem_ctx); 4583 4584 if (!constant_value || 4585 (state->is_version(430, 300) && 4586 decl->initializer->has_sequence_subexpression())) { 4587 const char *const variable_mode = 4588 (type->qualifier.flags.q.constant) 4589 ? "const" 4590 : ((type->qualifier.flags.q.uniform) ? "uniform" : "global"); 4591 4592 /* If ARB_shading_language_420pack is enabled, initializers of 4593 * const-qualified local variables do not have to be constant 4594 * expressions. Const-qualified global variables must still be 4595 * initialized with constant expressions. 4596 */ 4597 if (!state->has_420pack() 4598 || state->current_function == NULL__null) { 4599 _mesa_glsl_error(& initializer_loc, state, 4600 "initializer of %s variable `%s' must be a " 4601 "constant expression", 4602 variable_mode, 4603 decl->identifier); 4604 if (var->type->is_numeric()) { 4605 /* Reduce cascading errors. */ 4606 var->constant_value = type->qualifier.flags.q.constant 4607 ? ir_constant::zero(state, var->type) : NULL__null; 4608 } 4609 } 4610 } else { 4611 rhs = constant_value; 4612 var->constant_value = type->qualifier.flags.q.constant 4613 ? constant_value : NULL__null; 4614 } 4615 } else { 4616 if (var->type->is_numeric()) { 4617 /* Reduce cascading errors. */ 4618 rhs = var->constant_value = type->qualifier.flags.q.constant 4619 ? ir_constant::zero(state, var->type) : NULL__null; 4620 } 4621 } 4622 } 4623 4624 if (rhs && !rhs->type->is_error()) { 4625 bool temp = var->data.read_only; 4626 if (type->qualifier.flags.q.constant) 4627 var->data.read_only = false; 4628 4629 /* Never emit code to initialize a uniform. 4630 */ 4631 const glsl_type *initializer_type; 4632 bool error_emitted = false; 4633 if (!type->qualifier.flags.q.uniform) { 4634 error_emitted = 4635 do_assignment(initializer_instructions, state, 4636 NULL__null, lhs, rhs, 4637 &result, true, true, 4638 type->get_location()); 4639 initializer_type = result->type; 4640 } else 4641 initializer_type = rhs->type; 4642 4643 if (!error_emitted) { 4644 var->constant_initializer = rhs->constant_expression_value(mem_ctx); 4645 var->data.has_initializer = true; 4646 4647 /* If the declared variable is an unsized array, it must inherrit 4648 * its full type from the initializer. A declaration such as 4649 * 4650 * uniform float a[] = float[](1.0, 2.0, 3.0, 3.0); 4651 * 4652 * becomes 4653 * 4654 * uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0); 4655 * 4656 * The assignment generated in the if-statement (below) will also 4657 * automatically handle this case for non-uniforms. 4658 * 4659 * If the declared variable is not an array, the types must 4660 * already match exactly. As a result, the type assignment 4661 * here can be done unconditionally. For non-uniforms the call 4662 * to do_assignment can change the type of the initializer (via 4663 * the implicit conversion rules). For uniforms the initializer 4664 * must be a constant expression, and the type of that expression 4665 * was validated above. 4666 */ 4667 var->type = initializer_type; 4668 } 4669 4670 var->data.read_only = temp; 4671 } 4672 4673 return result; 4674} 4675 4676static void 4677validate_layout_qualifier_vertex_count(struct _mesa_glsl_parse_state *state, 4678 YYLTYPE loc, ir_variable *var, 4679 unsigned num_vertices, 4680 unsigned *size, 4681 const char *var_category) 4682{ 4683 if (var->type->is_unsized_array()) { 4684 /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec says: 4685 * 4686 * All geometry shader input unsized array declarations will be 4687 * sized by an earlier input layout qualifier, when present, as per 4688 * the following table. 4689 * 4690 * Followed by a table mapping each allowed input layout qualifier to 4691 * the corresponding input length. 4692 * 4693 * Similarly for tessellation control shader outputs. 4694 */ 4695 if (num_vertices != 0) 4696 var->type = glsl_type::get_array_instance(var->type->fields.array, 4697 num_vertices); 4698 } else { 4699 /* Section 4.3.8.1 (Input Layout Qualifiers) of the GLSL 1.50 spec 4700 * includes the following examples of compile-time errors: 4701 * 4702 * // code sequence within one shader... 4703 * in vec4 Color1[]; // size unknown 4704 * ...Color1.length()...// illegal, length() unknown 4705 * in vec4 Color2[2]; // size is 2 4706 * ...Color1.length()...// illegal, Color1 still has no size 4707 * in vec4 Color3[3]; // illegal, input sizes are inconsistent 4708 * layout(lines) in; // legal, input size is 2, matching 4709 * in vec4 Color4[3]; // illegal, contradicts layout 4710 * ... 4711 * 4712 * To detect the case illustrated by Color3, we verify that the size of 4713 * an explicitly-sized array matches the size of any previously declared 4714 * explicitly-sized array. To detect the case illustrated by Color4, we 4715 * verify that the size of an explicitly-sized array is consistent with 4716 * any previously declared input layout. 4717 */ 4718 if (num_vertices != 0 && var->type->length != num_vertices) { 4719 _mesa_glsl_error(&loc, state, 4720 "%s size contradicts previously declared layout " 4721 "(size is %u, but layout requires a size of %u)", 4722 var_category, var->type->length, num_vertices); 4723 } else if (*size != 0 && var->type->length != *size) { 4724 _mesa_glsl_error(&loc, state, 4725 "%s sizes are inconsistent (size is %u, but a " 4726 "previous declaration has size %u)", 4727 var_category, var->type->length, *size); 4728 } else { 4729 *size = var->type->length; 4730 } 4731 } 4732} 4733 4734static void 4735handle_tess_ctrl_shader_output_decl(struct _mesa_glsl_parse_state *state, 4736 YYLTYPE loc, ir_variable *var) 4737{ 4738 unsigned num_vertices = 0; 4739 4740 if (state->tcs_output_vertices_specified) { 4741 if (!state->out_qualifier->vertices-> 4742 process_qualifier_constant(state, "vertices", 4743 &num_vertices, false)) { 4744 return; 4745 } 4746 4747 if (num_vertices > state->Const.MaxPatchVertices) { 4748 _mesa_glsl_error(&loc, state, "vertices (%d) exceeds " 4749 "GL_MAX_PATCH_VERTICES", num_vertices); 4750 return; 4751 } 4752 } 4753 4754 if (!var->type->is_array() && !var->data.patch) { 4755 _mesa_glsl_error(&loc, state, 4756 "tessellation control shader outputs must be arrays"); 4757 4758 /* To avoid cascading failures, short circuit the checks below. */ 4759 return; 4760 } 4761 4762 if (var->data.patch) 4763 return; 4764 4765 validate_layout_qualifier_vertex_count(state, loc, var, num_vertices, 4766 &state->tcs_output_size, 4767 "tessellation control shader output"); 4768} 4769 4770/** 4771 * Do additional processing necessary for tessellation control/evaluation shader 4772 * input declarations. This covers both interface block arrays and bare input 4773 * variables. 4774 */ 4775static void 4776handle_tess_shader_input_decl(struct _mesa_glsl_parse_state *state, 4777 YYLTYPE loc, ir_variable *var) 4778{ 4779 if (!var->type->is_array() && !var->data.patch) { 4780 _mesa_glsl_error(&loc, state, 4781 "per-vertex tessellation shader inputs must be arrays"); 4782 /* Avoid cascading failures. */ 4783 return; 4784 } 4785 4786 if (var->data.patch) 4787 return; 4788 4789 /* The ARB_tessellation_shader spec says: 4790 * 4791 * "Declaring an array size is optional. If no size is specified, it 4792 * will be taken from the implementation-dependent maximum patch size 4793 * (gl_MaxPatchVertices). If a size is specified, it must match the 4794 * maximum patch size; otherwise, a compile or link error will occur." 4795 * 4796 * This text appears twice, once for TCS inputs, and again for TES inputs. 4797 */ 4798 if (var->type->is_unsized_array()) { 4799 var->type = glsl_type::get_array_instance(var->type->fields.array, 4800 state->Const.MaxPatchVertices); 4801 } else if (var->type->length != state->Const.MaxPatchVertices) { 4802 _mesa_glsl_error(&loc, state, 4803 "per-vertex tessellation shader input arrays must be " 4804 "sized to gl_MaxPatchVertices (%d).", 4805 state->Const.MaxPatchVertices); 4806 } 4807} 4808 4809 4810/** 4811 * Do additional processing necessary for geometry shader input declarations 4812 * (this covers both interface blocks arrays and bare input variables). 4813 */ 4814static void 4815handle_geometry_shader_input_decl(struct _mesa_glsl_parse_state *state, 4816 YYLTYPE loc, ir_variable *var) 4817{ 4818 unsigned num_vertices = 0; 4819 4820 if (state->gs_input_prim_type_specified) { 4821 num_vertices = vertices_per_prim(state->in_qualifier->prim_type); 4822 } 4823 4824 /* Geometry shader input variables must be arrays. Caller should have 4825 * reported an error for this. 4826 */ 4827 if (!var->type->is_array()) { 4828 assert(state->error)(static_cast <bool> (state->error) ? void (0) : __assert_fail
("state->error", __builtin_FILE (), __builtin_LINE (), __extension__
__PRETTY_FUNCTION__)); 4829 4830 /* To avoid cascading failures, short circuit the checks below. */ 4831 return; 4832 } 4833 4834 validate_layout_qualifier_vertex_count(state, loc, var, num_vertices, 4835 &state->gs_input_size, 4836 "geometry shader input"); 4837} 4838 4839static void 4840validate_identifier(const char *identifier, YYLTYPE loc, 4841 struct _mesa_glsl_parse_state *state) 4842{ 4843 /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec, 4844 * 4845 * "Identifiers starting with "gl_" are reserved for use by 4846 * OpenGL, and may not be declared in a shader as either a 4847 * variable or a function." 4848 */ 4849 if (is_gl_identifier(identifier)) { 4850 _mesa_glsl_error(&loc, state, 4851 "identifier `%s' uses reserved `gl_' prefix", 4852 identifier); 4853 } else if (strstr(identifier, "__")) { 4854 /* From page 14 (page 20 of the PDF) of the GLSL 1.10 4855 * spec: 4856 * 4857 * "In addition, all identifiers containing two 4858 * consecutive underscores (__) are reserved as 4859 * possible future keywords." 4860 * 4861 * The intention is that names containing __ are reserved for internal 4862 * use by the implementation, and names prefixed with GL_ are reserved 4863 * for use by Khronos. Names simply containing __ are dangerous to use, 4864 * but should be allowed. 4865 * 4866 * A future version of the GLSL specification will clarify this. 4867 */ 4868 _mesa_glsl_warning(&loc, state, 4869 "identifier `%s' uses reserved `__' string", 4870 identifier); 4871 } 4872} 4873 4874ir_rvalue * 4875ast_declarator_list::hir(exec_list *instructions, 4876 struct _mesa_glsl_parse_state *state) 4877{ 4878 void *ctx = state; 4879 const struct glsl_type *decl_type; 4880 const char *type_name = NULL__null; 4881 ir_rvalue *result = NULL__null; 4882 YYLTYPE loc = this->get_location(); 4883 4884 /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec: 4885 * 4886 * "To ensure that a particular output variable is invariant, it is 4887 * necessary to use the invariant qualifier. It can either be used to 4888 * qualify a previously declared variable as being invariant 4889 * 4890 * invariant gl_Position; // make existing gl_Position be invariant" 4891 * 4892 * In these cases the parser will set the 'invariant' flag in the declarator 4893 * list, and the type will be NULL. 4894 */ 4895 if (this->invariant) { 4896 assert(this->type == NULL)(static_cast <bool> (this->type == __null) ? void (0
) : __assert_fail ("this->type == NULL", __builtin_FILE ()
, __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 4897 4898 if (state->current_function != NULL__null) { 4899 _mesa_glsl_error(& loc, state, 4900 "all uses of `invariant' keyword must be at global " 4901 "scope"); 4902 } 4903 4904 foreach_list_typed (ast_declaration, decl, link, &this->declarations)for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
this->declarations)->head_sentinel.next) ? ((ast_declaration
*) (((uintptr_t) (&this->declarations)->head_sentinel
.next) - (((char *) &((ast_declaration *) (&this->
declarations)->head_sentinel.next)->link) - ((char *) (
&this->declarations)->head_sentinel.next)))) : __null
); (decl) != __null; (decl) = (!exec_node_is_tail_sentinel((decl
)->link.next) ? ((ast_declaration *) (((uintptr_t) (decl)->
link.next) - (((char *) &((ast_declaration *) (decl)->
link.next)->link) - ((char *) (decl)->link.next)))) : __null
)) { 4905 assert(decl->array_specifier == NULL)(static_cast <bool> (decl->array_specifier == __null
) ? void (0) : __assert_fail ("decl->array_specifier == NULL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 4906 assert(decl->initializer == NULL)(static_cast <bool> (decl->initializer == __null) ? void
(0) : __assert_fail ("decl->initializer == NULL", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 4907 4908 ir_variable *const earlier = 4909 state->symbols->get_variable(decl->identifier); 4910 if (earlier == NULL__null) { 4911 _mesa_glsl_error(& loc, state, 4912 "undeclared variable `%s' cannot be marked " 4913 "invariant", decl->identifier); 4914 } else if (!is_allowed_invariant(earlier, state)) { 4915 _mesa_glsl_error(&loc, state, 4916 "`%s' cannot be marked invariant; interfaces between " 4917 "shader stages only.", decl->identifier); 4918 } else if (earlier->data.used) { 4919 _mesa_glsl_error(& loc, state, 4920 "variable `%s' may not be redeclared " 4921 "`invariant' after being used", 4922 earlier->name); 4923 } else { 4924 earlier->data.explicit_invariant = true; 4925 earlier->data.invariant = true; 4926 } 4927 } 4928 4929 /* Invariant redeclarations do not have r-values. 4930 */ 4931 return NULL__null; 4932 } 4933 4934 if (this->precise) { 4935 assert(this->type == NULL)(static_cast <bool> (this->type == __null) ? void (0
) : __assert_fail ("this->type == NULL", __builtin_FILE ()
, __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 4936 4937 foreach_list_typed (ast_declaration, decl, link, &this->declarations)for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
this->declarations)->head_sentinel.next) ? ((ast_declaration
*) (((uintptr_t) (&this->declarations)->head_sentinel
.next) - (((char *) &((ast_declaration *) (&this->
declarations)->head_sentinel.next)->link) - ((char *) (
&this->declarations)->head_sentinel.next)))) : __null
); (decl) != __null; (decl) = (!exec_node_is_tail_sentinel((decl
)->link.next) ? ((ast_declaration *) (((uintptr_t) (decl)->
link.next) - (((char *) &((ast_declaration *) (decl)->
link.next)->link) - ((char *) (decl)->link.next)))) : __null
)) { 4938 assert(decl->array_specifier == NULL)(static_cast <bool> (decl->array_specifier == __null
) ? void (0) : __assert_fail ("decl->array_specifier == NULL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 4939 assert(decl->initializer == NULL)(static_cast <bool> (decl->initializer == __null) ? void
(0) : __assert_fail ("decl->initializer == NULL", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 4940 4941 ir_variable *const earlier = 4942 state->symbols->get_variable(decl->identifier); 4943 if (earlier == NULL__null) { 4944 _mesa_glsl_error(& loc, state, 4945 "undeclared variable `%s' cannot be marked " 4946 "precise", decl->identifier); 4947 } else if (state->current_function != NULL__null && 4948 !state->symbols->name_declared_this_scope(decl->identifier)) { 4949 /* Note: we have to check if we're in a function, since 4950 * builtins are treated as having come from another scope. 4951 */ 4952 _mesa_glsl_error(& loc, state, 4953 "variable `%s' from an outer scope may not be " 4954 "redeclared `precise' in this scope", 4955 earlier->name); 4956 } else if (earlier->data.used) { 4957 _mesa_glsl_error(& loc, state, 4958 "variable `%s' may not be redeclared " 4959 "`precise' after being used", 4960 earlier->name); 4961 } else { 4962 earlier->data.precise = true; 4963 } 4964 } 4965 4966 /* Precise redeclarations do not have r-values either. */ 4967 return NULL__null; 4968 } 4969 4970 assert(this->type != NULL)(static_cast <bool> (this->type != __null) ? void (0
) : __assert_fail ("this->type != NULL", __builtin_FILE ()
, __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 4971 assert(!this->invariant)(static_cast <bool> (!this->invariant) ? void (0) : __assert_fail
("!this->invariant", __builtin_FILE (), __builtin_LINE ()
, __extension__ __PRETTY_FUNCTION__)); 4972 assert(!this->precise)(static_cast <bool> (!this->precise) ? void (0) : __assert_fail
("!this->precise", __builtin_FILE (), __builtin_LINE (), __extension__
__PRETTY_FUNCTION__)); 4973 4974 /* GL_EXT_shader_image_load_store base type uses GLSL_TYPE_VOID as a special value to 4975 * indicate that it needs to be updated later (see glsl_parser.yy). 4976 * This is done here, based on the layout qualifier and the type of the image var 4977 */ 4978 if (this->type->qualifier.flags.q.explicit_image_format && 4979 this->type->specifier->type->is_image() && 4980 this->type->qualifier.image_base_type == GLSL_TYPE_VOID) { 4981 /* "The ARB_shader_image_load_store says: 4982 * If both extensions are enabled in the shading language, the "size*" layout 4983 * qualifiers are treated as format qualifiers, and are mapped to equivalent 4984 * format qualifiers in the table below, according to the type of image 4985 * variable. 4986 * image* iimage* uimage* 4987 * -------- -------- -------- 4988 * size1x8 n/a r8i r8ui 4989 * size1x16 r16f r16i r16ui 4990 * size1x32 r32f r32i r32ui 4991 * size2x32 rg32f rg32i rg32ui 4992 * size4x32 rgba32f rgba32i rgba32ui" 4993 */ 4994 if (strncmp(this->type->specifier->type_name, "image", strlen("image")) == 0) { 4995 switch (this->type->qualifier.image_format) { 4996 case PIPE_FORMAT_R8_SINT: 4997 /* No valid qualifier in this case, driver will need to look at 4998 * the underlying image's format (just like no qualifier being 4999 * present). 5000 */ 5001 this->type->qualifier.image_format = PIPE_FORMAT_NONE; 5002 break; 5003 case PIPE_FORMAT_R16_SINT: 5004 this->type->qualifier.image_format = PIPE_FORMAT_R16_FLOAT; 5005 break; 5006 case PIPE_FORMAT_R32_SINT: 5007 this->type->qualifier.image_format = PIPE_FORMAT_R32_FLOAT; 5008 break; 5009 case PIPE_FORMAT_R32G32_SINT: 5010 this->type->qualifier.image_format = PIPE_FORMAT_R32G32_FLOAT; 5011 break; 5012 case PIPE_FORMAT_R32G32B32A32_SINT: 5013 this->type->qualifier.image_format = PIPE_FORMAT_R32G32B32A32_FLOAT; 5014 break; 5015 default: 5016 unreachable("Unknown image format")do { (static_cast <bool> (!"Unknown image format") ? void
(0) : __assert_fail ("!\"Unknown image format\"", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); __builtin_unreachable
(); } while (0); 5017 } 5018 this->type->qualifier.image_base_type = GLSL_TYPE_FLOAT; 5019 } else if (strncmp(this->type->specifier->type_name, "uimage", strlen("uimage")) == 0) { 5020 switch (this->type->qualifier.image_format) { 5021 case PIPE_FORMAT_R8_SINT: 5022 this->type->qualifier.image_format = PIPE_FORMAT_R8_UINT; 5023 break; 5024 case PIPE_FORMAT_R16_SINT: 5025 this->type->qualifier.image_format = PIPE_FORMAT_R16_UINT; 5026 break; 5027 case PIPE_FORMAT_R32_SINT: 5028 this->type->qualifier.image_format = PIPE_FORMAT_R32_UINT; 5029 break; 5030 case PIPE_FORMAT_R32G32_SINT: 5031 this->type->qualifier.image_format = PIPE_FORMAT_R32G32_UINT; 5032 break; 5033 case PIPE_FORMAT_R32G32B32A32_SINT: 5034 this->type->qualifier.image_format = PIPE_FORMAT_R32G32B32A32_UINT; 5035 break; 5036 default: 5037 unreachable("Unknown image format")do { (static_cast <bool> (!"Unknown image format") ? void
(0) : __assert_fail ("!\"Unknown image format\"", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); __builtin_unreachable
(); } while (0); 5038 } 5039 this->type->qualifier.image_base_type = GLSL_TYPE_UINT; 5040 } else if (strncmp(this->type->specifier->type_name, "iimage", strlen("iimage")) == 0) { 5041 this->type->qualifier.image_base_type = GLSL_TYPE_INT; 5042 } else { 5043 assert(false)(static_cast <bool> (false) ? void (0) : __assert_fail (
"false", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 5044 } 5045 } 5046 5047 /* The type specifier may contain a structure definition. Process that 5048 * before any of the variable declarations. 5049 */ 5050 (void) this->type->specifier->hir(instructions, state); 5051 5052 decl_type = this->type->glsl_type(& type_name, state); 5053 5054 /* Section 4.3.7 "Buffer Variables" of the GLSL 4.30 spec: 5055 * "Buffer variables may only be declared inside interface blocks 5056 * (section 4.3.9 “Interface Blocks”), which are then referred to as 5057 * shader storage blocks. It is a compile-time error to declare buffer 5058 * variables at global scope (outside a block)." 5059 */ 5060 if (type->qualifier.flags.q.buffer && !decl_type->is_interface()) { 5061 _mesa_glsl_error(&loc, state, 5062 "buffer variables cannot be declared outside " 5063 "interface blocks"); 5064 } 5065 5066 /* An offset-qualified atomic counter declaration sets the default 5067 * offset for the next declaration within the same atomic counter 5068 * buffer. 5069 */ 5070 if (decl_type && decl_type->contains_atomic()) { 5071 if (type->qualifier.flags.q.explicit_binding && 5072 type->qualifier.flags.q.explicit_offset) { 5073 unsigned qual_binding; 5074 unsigned qual_offset; 5075 if (process_qualifier_constant(state, &loc, "binding", 5076 type->qualifier.binding, 5077 &qual_binding) 5078 && process_qualifier_constant(state, &loc, "offset", 5079 type->qualifier.offset, 5080 &qual_offset)) { 5081 if (qual_binding < ARRAY_SIZE(state->atomic_counter_offsets)(sizeof(state->atomic_counter_offsets) / sizeof((state->
atomic_counter_offsets)[0]))) 5082 state->atomic_counter_offsets[qual_binding] = qual_offset; 5083 } 5084 } 5085 5086 ast_type_qualifier allowed_atomic_qual_mask; 5087 allowed_atomic_qual_mask.flags.i = 0; 5088 allowed_atomic_qual_mask.flags.q.explicit_binding = 1; 5089 allowed_atomic_qual_mask.flags.q.explicit_offset = 1; 5090 allowed_atomic_qual_mask.flags.q.uniform = 1; 5091 5092 type->qualifier.validate_flags(&loc, state, allowed_atomic_qual_mask, 5093 "invalid layout qualifier for", 5094 "atomic_uint"); 5095 } 5096 5097 if (this->declarations.is_empty()) { 5098 /* If there is no structure involved in the program text, there are two 5099 * possible scenarios: 5100 * 5101 * - The program text contained something like 'vec4;'. This is an 5102 * empty declaration. It is valid but weird. Emit a warning. 5103 * 5104 * - The program text contained something like 'S;' and 'S' is not the 5105 * name of a known structure type. This is both invalid and weird. 5106 * Emit an error. 5107 * 5108 * - The program text contained something like 'mediump float;' 5109 * when the programmer probably meant 'precision mediump 5110 * float;' Emit a warning with a description of what they 5111 * probably meant to do. 5112 * 5113 * Note that if decl_type is NULL and there is a structure involved, 5114 * there must have been some sort of error with the structure. In this 5115 * case we assume that an error was already generated on this line of 5116 * code for the structure. There is no need to generate an additional, 5117 * confusing error. 5118 */ 5119 assert(this->type->specifier->structure == NULL || decl_type != NULL(static_cast <bool> (this->type->specifier->structure
== __null || decl_type != __null || state->error) ? void (
0) : __assert_fail ("this->type->specifier->structure == NULL || decl_type != NULL || state->error"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)) 5120 || state->error)(static_cast <bool> (this->type->specifier->structure
== __null || decl_type != __null || state->error) ? void (
0) : __assert_fail ("this->type->specifier->structure == NULL || decl_type != NULL || state->error"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 5121 5122 if (decl_type == NULL__null) { 5123 _mesa_glsl_error(&loc, state, 5124 "invalid type `%s' in empty declaration", 5125 type_name); 5126 } else { 5127 if (decl_type->is_array()) { 5128 /* From Section 13.22 (Array Declarations) of the GLSL ES 3.2 5129 * spec: 5130 * 5131 * "... any declaration that leaves the size undefined is 5132 * disallowed as this would add complexity and there are no 5133 * use-cases." 5134 */ 5135 if (state->es_shader && decl_type->is_unsized_array()) { 5136 _mesa_glsl_error(&loc, state, "array size must be explicitly " 5137 "or implicitly defined"); 5138 } 5139 5140 /* From Section 4.12 (Empty Declarations) of the GLSL 4.5 spec: 5141 * 5142 * "The combinations of types and qualifiers that cause 5143 * compile-time or link-time errors are the same whether or not 5144 * the declaration is empty." 5145 */ 5146 validate_array_dimensions(decl_type, state, &loc); 5147 } 5148 5149 if (decl_type->is_atomic_uint()) { 5150 /* Empty atomic counter declarations are allowed and useful 5151 * to set the default offset qualifier. 5152 */ 5153 return NULL__null; 5154 } else if (this->type->qualifier.precision != ast_precision_none) { 5155 if (this->type->specifier->structure != NULL__null) { 5156 _mesa_glsl_error(&loc, state, 5157 "precision qualifiers can't be applied " 5158 "to structures"); 5159 } else { 5160 static const char *const precision_names[] = { 5161 "highp", 5162 "highp", 5163 "mediump", 5164 "lowp" 5165 }; 5166 5167 _mesa_glsl_warning(&loc, state, 5168 "empty declaration with precision " 5169 "qualifier, to set the default precision, " 5170 "use `precision %s %s;'", 5171 precision_names[this->type-> 5172 qualifier.precision], 5173 type_name); 5174 } 5175 } else if (this->type->specifier->structure == NULL__null) { 5176 _mesa_glsl_warning(&loc, state, "empty declaration"); 5177 } 5178 } 5179 } 5180 5181 foreach_list_typed (ast_declaration, decl, link, &this->declarations)for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
this->declarations)->head_sentinel.next) ? ((ast_declaration
*) (((uintptr_t) (&this->declarations)->head_sentinel
.next) - (((char *) &((ast_declaration *) (&this->
declarations)->head_sentinel.next)->link) - ((char *) (
&this->declarations)->head_sentinel.next)))) : __null
); (decl) != __null; (decl) = (!exec_node_is_tail_sentinel((decl
)->link.next) ? ((ast_declaration *) (((uintptr_t) (decl)->
link.next) - (((char *) &((ast_declaration *) (decl)->
link.next)->link) - ((char *) (decl)->link.next)))) : __null
)) { 5182 const struct glsl_type *var_type; 5183 ir_variable *var; 5184 const char *identifier = decl->identifier; 5185 /* FINISHME: Emit a warning if a variable declaration shadows a 5186 * FINISHME: declaration at a higher scope. 5187 */ 5188 5189 if ((decl_type == NULL__null) || decl_type->is_void()) { 5190 if (type_name != NULL__null) { 5191 _mesa_glsl_error(& loc, state, 5192 "invalid type `%s' in declaration of `%s'", 5193 type_name, decl->identifier); 5194 } else { 5195 _mesa_glsl_error(& loc, state, 5196 "invalid type in declaration of `%s'", 5197 decl->identifier); 5198 } 5199 continue; 5200 } 5201 5202 if (this->type->qualifier.is_subroutine_decl()) { 5203 const glsl_type *t; 5204 const char *name; 5205 5206 t = state->symbols->get_type(this->type->specifier->type_name); 5207 if (!t) 5208 _mesa_glsl_error(& loc, state, 5209 "invalid type in declaration of `%s'", 5210 decl->identifier); 5211 name = ralloc_asprintf(ctx, "%s_%s", _mesa_shader_stage_to_subroutine_prefix(state->stage), decl->identifier); 5212 5213 identifier = name; 5214 5215 } 5216 var_type = process_array_type(&loc, decl_type, decl->array_specifier, 5217 state); 5218 5219 var = new(ctx) ir_variable(var_type, identifier, ir_var_auto); 5220 5221 /* The 'varying in' and 'varying out' qualifiers can only be used with 5222 * ARB_geometry_shader4 and EXT_geometry_shader4, which we don't support 5223 * yet. 5224 */ 5225 if (this->type->qualifier.flags.q.varying) { 5226 if (this->type->qualifier.flags.q.in) { 5227 _mesa_glsl_error(& loc, state, 5228 "`varying in' qualifier in declaration of " 5229 "`%s' only valid for geometry shaders using " 5230 "ARB_geometry_shader4 or EXT_geometry_shader4", 5231 decl->identifier); 5232 } else if (this->type->qualifier.flags.q.out) { 5233 _mesa_glsl_error(& loc, state, 5234 "`varying out' qualifier in declaration of " 5235 "`%s' only valid for geometry shaders using " 5236 "ARB_geometry_shader4 or EXT_geometry_shader4", 5237 decl->identifier); 5238 } 5239 } 5240 5241 /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification; 5242 * 5243 * "Global variables can only use the qualifiers const, 5244 * attribute, uniform, or varying. Only one may be 5245 * specified. 5246 * 5247 * Local variables can only use the qualifier const." 5248 * 5249 * This is relaxed in GLSL 1.30 and GLSL ES 3.00. It is also relaxed by 5250 * any extension that adds the 'layout' keyword. 5251 */ 5252 if (!state->is_version(130, 300) 5253 && !state->has_explicit_attrib_location() 5254 && !state->has_separate_shader_objects() 5255 && !state->ARB_fragment_coord_conventions_enable) { 5256 /* GL_EXT_gpu_shader4 only allows "varying out" on fragment shader 5257 * outputs. (the varying flag is not set by the parser) 5258 */ 5259 if (this->type->qualifier.flags.q.out && 5260 (!state->EXT_gpu_shader4_enable || 5261 state->stage != MESA_SHADER_FRAGMENT)) { 5262 _mesa_glsl_error(& loc, state, 5263 "`out' qualifier in declaration of `%s' " 5264 "only valid for function parameters in %s", 5265 decl->identifier, state->get_version_string()); 5266 } 5267 if (this->type->qualifier.flags.q.in) { 5268 _mesa_glsl_error(& loc, state, 5269 "`in' qualifier in declaration of `%s' " 5270 "only valid for function parameters in %s", 5271 decl->identifier, state->get_version_string()); 5272 } 5273 /* FINISHME: Test for other invalid qualifiers. */ 5274 } 5275 5276 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, 5277 & loc, false); 5278 apply_layout_qualifier_to_variable(&this->type->qualifier, var, state, 5279 &loc); 5280 5281 if ((var->data.mode == ir_var_auto || var->data.mode == ir_var_temporary 5282 || var->data.mode == ir_var_shader_out) 5283 && (var->type->is_numeric() || var->type->is_boolean()) 5284 && state->zero_init) { 5285 const ir_constant_data data = { { 0 } }; 5286 var->data.has_initializer = true; 5287 var->constant_initializer = new(var) ir_constant(var->type, &data); 5288 } 5289 5290 if (this->type->qualifier.flags.q.invariant) { 5291 if (!is_allowed_invariant(var, state)) { 5292 _mesa_glsl_error(&loc, state, 5293 "`%s' cannot be marked invariant; interfaces between " 5294 "shader stages only", var->name); 5295 } 5296 } 5297 5298 if (state->current_function != NULL__null) { 5299 const char *mode = NULL__null; 5300 const char *extra = ""; 5301 5302 /* There is no need to check for 'inout' here because the parser will 5303 * only allow that in function parameter lists. 5304 */ 5305 if (this->type->qualifier.flags.q.attribute) { 5306 mode = "attribute"; 5307 } else if (this->type->qualifier.is_subroutine_decl()) { 5308 mode = "subroutine uniform"; 5309 } else if (this->type->qualifier.flags.q.uniform) { 5310 mode = "uniform"; 5311 } else if (this->type->qualifier.flags.q.varying) { 5312 mode = "varying"; 5313 } else if (this->type->qualifier.flags.q.in) { 5314 mode = "in"; 5315 extra = " or in function parameter list"; 5316 } else if (this->type->qualifier.flags.q.out) { 5317 mode = "out"; 5318 extra = " or in function parameter list"; 5319 } 5320 5321 if (mode) { 5322 _mesa_glsl_error(& loc, state, 5323 "%s variable `%s' must be declared at " 5324 "global scope%s", 5325 mode, var->name, extra); 5326 } 5327 } else if (var->data.mode == ir_var_shader_in) { 5328 var->data.read_only = true; 5329 5330 if (state->stage == MESA_SHADER_VERTEX) { 5331 bool error_emitted = false; 5332 5333 /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: 5334 * 5335 * "Vertex shader inputs can only be float, floating-point 5336 * vectors, matrices, signed and unsigned integers and integer 5337 * vectors. Vertex shader inputs can also form arrays of these 5338 * types, but not structures." 5339 * 5340 * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec: 5341 * 5342 * "Vertex shader inputs can only be float, floating-point 5343 * vectors, matrices, signed and unsigned integers and integer 5344 * vectors. They cannot be arrays or structures." 5345 * 5346 * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec: 5347 * 5348 * "The attribute qualifier can be used only with float, 5349 * floating-point vectors, and matrices. Attribute variables 5350 * cannot be declared as arrays or structures." 5351 * 5352 * From page 33 (page 39 of the PDF) of the GLSL ES 3.00 spec: 5353 * 5354 * "Vertex shader inputs can only be float, floating-point 5355 * vectors, matrices, signed and unsigned integers and integer 5356 * vectors. Vertex shader inputs cannot be arrays or 5357 * structures." 5358 * 5359 * From section 4.3.4 of the ARB_bindless_texture spec: 5360 * 5361 * "(modify third paragraph of the section to allow sampler and 5362 * image types) ... Vertex shader inputs can only be float, 5363 * single-precision floating-point scalars, single-precision 5364 * floating-point vectors, matrices, signed and unsigned 5365 * integers and integer vectors, sampler and image types." 5366 */ 5367 const glsl_type *check_type = var->type->without_array(); 5368 5369 switch (check_type->base_type) { 5370 case GLSL_TYPE_FLOAT: 5371 break; 5372 case GLSL_TYPE_UINT64: 5373 case GLSL_TYPE_INT64: 5374 break; 5375 case GLSL_TYPE_UINT: 5376 case GLSL_TYPE_INT: 5377 if (state->is_version(120, 300) || state->EXT_gpu_shader4_enable) 5378 break; 5379 case GLSL_TYPE_DOUBLE: 5380 if (check_type->is_double() && (state->is_version(410, 0) || state->ARB_vertex_attrib_64bit_enable)) 5381 break; 5382 case GLSL_TYPE_SAMPLER: 5383 if (check_type->is_sampler() && state->has_bindless()) 5384 break; 5385 case GLSL_TYPE_IMAGE: 5386 if (check_type->is_image() && state->has_bindless()) 5387 break; 5388 /* FALLTHROUGH */ 5389 default: 5390 _mesa_glsl_error(& loc, state, 5391 "vertex shader input / attribute cannot have " 5392 "type %s`%s'", 5393 var->type->is_array() ? "array of " : "", 5394 check_type->name); 5395 error_emitted = true; 5396 } 5397 5398 if (!error_emitted && var->type->is_array() && 5399 !state->check_version(150, 0, &loc, 5400 "vertex shader input / attribute " 5401 "cannot have array type")) { 5402 error_emitted = true; 5403 } 5404 } else if (state->stage == MESA_SHADER_GEOMETRY) { 5405 /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec: 5406 * 5407 * Geometry shader input variables get the per-vertex values 5408 * written out by vertex shader output variables of the same 5409 * names. Since a geometry shader operates on a set of 5410 * vertices, each input varying variable (or input block, see 5411 * interface blocks below) needs to be declared as an array. 5412 */ 5413 if (!var->type->is_array()) { 5414 _mesa_glsl_error(&loc, state, 5415 "geometry shader inputs must be arrays"); 5416 } 5417 5418 handle_geometry_shader_input_decl(state, loc, var); 5419 } else if (state->stage == MESA_SHADER_FRAGMENT) { 5420 /* From section 4.3.4 (Input Variables) of the GLSL ES 3.10 spec: 5421 * 5422 * It is a compile-time error to declare a fragment shader 5423 * input with, or that contains, any of the following types: 5424 * 5425 * * A boolean type 5426 * * An opaque type 5427 * * An array of arrays 5428 * * An array of structures 5429 * * A structure containing an array 5430 * * A structure containing a structure 5431 */ 5432 if (state->es_shader) { 5433 const glsl_type *check_type = var->type->without_array(); 5434 if (check_type->is_boolean() || 5435 check_type->contains_opaque()) { 5436 _mesa_glsl_error(&loc, state, 5437 "fragment shader input cannot have type %s", 5438 check_type->name); 5439 } 5440 if (var->type->is_array() && 5441 var->type->fields.array->is_array()) { 5442 _mesa_glsl_error(&loc, state, 5443 "%s shader output " 5444 "cannot have an array of arrays", 5445 _mesa_shader_stage_to_string(state->stage)); 5446 } 5447 if (var->type->is_array() && 5448 var->type->fields.array->is_struct()) { 5449 _mesa_glsl_error(&loc, state, 5450 "fragment shader input " 5451 "cannot have an array of structs"); 5452 } 5453 if (var->type->is_struct()) { 5454 for (unsigned i = 0; i < var->type->length; i++) { 5455 if (var->type->fields.structure[i].type->is_array() || 5456 var->type->fields.structure[i].type->is_struct()) 5457 _mesa_glsl_error(&loc, state, 5458 "fragment shader input cannot have " 5459 "a struct that contains an " 5460 "array or struct"); 5461 } 5462 } 5463 } 5464 } else if (state->stage == MESA_SHADER_TESS_CTRL || 5465 state->stage == MESA_SHADER_TESS_EVAL) { 5466 handle_tess_shader_input_decl(state, loc, var); 5467 } 5468 } else if (var->data.mode == ir_var_shader_out) { 5469 const glsl_type *check_type = var->type->without_array(); 5470 5471 /* From section 4.3.6 (Output variables) of the GLSL 4.40 spec: 5472 * 5473 * It is a compile-time error to declare a fragment shader output 5474 * that contains any of the following: 5475 * 5476 * * A Boolean type (bool, bvec2 ...) 5477 * * A double-precision scalar or vector (double, dvec2 ...) 5478 * * An opaque type 5479 * * Any matrix type 5480 * * A structure 5481 */ 5482 if (state->stage == MESA_SHADER_FRAGMENT) { 5483 if (check_type->is_struct() || check_type->is_matrix()) 5484 _mesa_glsl_error(&loc, state, 5485 "fragment shader output " 5486 "cannot have struct or matrix type"); 5487 switch (check_type->base_type) { 5488 case GLSL_TYPE_UINT: 5489 case GLSL_TYPE_INT: 5490 case GLSL_TYPE_FLOAT: 5491 break; 5492 default: 5493 _mesa_glsl_error(&loc, state, 5494 "fragment shader output cannot have " 5495 "type %s", check_type->name); 5496 } 5497 } 5498 5499 /* From section 4.3.6 (Output Variables) of the GLSL ES 3.10 spec: 5500 * 5501 * It is a compile-time error to declare a vertex shader output 5502 * with, or that contains, any of the following types: 5503 * 5504 * * A boolean type 5505 * * An opaque type 5506 * * An array of arrays 5507 * * An array of structures 5508 * * A structure containing an array 5509 * * A structure containing a structure 5510 * 5511 * It is a compile-time error to declare a fragment shader output 5512 * with, or that contains, any of the following types: 5513 * 5514 * * A boolean type 5515 * * An opaque type 5516 * * A matrix 5517 * * A structure 5518 * * An array of array 5519 * 5520 * ES 3.20 updates this to apply to tessellation and geometry shaders 5521 * as well. Because there are per-vertex arrays in the new stages, 5522 * it strikes the "array of..." rules and replaces them with these: 5523 * 5524 * * For per-vertex-arrayed variables (applies to tessellation 5525 * control, tessellation evaluation and geometry shaders): 5526 * 5527 * * Per-vertex-arrayed arrays of arrays 5528 * * Per-vertex-arrayed arrays of structures 5529 * 5530 * * For non-per-vertex-arrayed variables: 5531 * 5532 * * An array of arrays 5533 * * An array of structures 5534 * 5535 * which basically says to unwrap the per-vertex aspect and apply 5536 * the old rules. 5537 */ 5538 if (state->es_shader) { 5539 if (var->type->is_array() && 5540 var->type->fields.array->is_array()) { 5541 _mesa_glsl_error(&loc, state, 5542 "%s shader output " 5543 "cannot have an array of arrays", 5544 _mesa_shader_stage_to_string(state->stage)); 5545 } 5546 if (state->stage <= MESA_SHADER_GEOMETRY) { 5547 const glsl_type *type = var->type; 5548 5549 if (state->stage == MESA_SHADER_TESS_CTRL && 5550 !var->data.patch && var->type->is_array()) { 5551 type = var->type->fields.array; 5552 } 5553 5554 if (type->is_array() && type->fields.array->is_struct()) { 5555 _mesa_glsl_error(&loc, state, 5556 "%s shader output cannot have " 5557 "an array of structs", 5558 _mesa_shader_stage_to_string(state->stage)); 5559 } 5560 if (type->is_struct()) { 5561 for (unsigned i = 0; i < type->length; i++) { 5562 if (type->fields.structure[i].type->is_array() || 5563 type->fields.structure[i].type->is_struct()) 5564 _mesa_glsl_error(&loc, state, 5565 "%s shader output cannot have a " 5566 "struct that contains an " 5567 "array or struct", 5568 _mesa_shader_stage_to_string(state->stage)); 5569 } 5570 } 5571 } 5572 } 5573 5574 if (state->stage == MESA_SHADER_TESS_CTRL) { 5575 handle_tess_ctrl_shader_output_decl(state, loc, var); 5576 } 5577 } else if (var->type->contains_subroutine()) { 5578 /* declare subroutine uniforms as hidden */ 5579 var->data.how_declared = ir_var_hidden; 5580 } 5581 5582 /* From section 4.3.4 of the GLSL 4.00 spec: 5583 * "Input variables may not be declared using the patch in qualifier 5584 * in tessellation control or geometry shaders." 5585 * 5586 * From section 4.3.6 of the GLSL 4.00 spec: 5587 * "It is an error to use patch out in a vertex, tessellation 5588 * evaluation, or geometry shader." 5589 * 5590 * This doesn't explicitly forbid using them in a fragment shader, but 5591 * that's probably just an oversight. 5592 */ 5593 if (state->stage != MESA_SHADER_TESS_EVAL 5594 && this->type->qualifier.flags.q.patch 5595 && this->type->qualifier.flags.q.in) { 5596 5597 _mesa_glsl_error(&loc, state, "'patch in' can only be used in a " 5598 "tessellation evaluation shader"); 5599 } 5600 5601 if (state->stage != MESA_SHADER_TESS_CTRL 5602 && this->type->qualifier.flags.q.patch 5603 && this->type->qualifier.flags.q.out) { 5604 5605 _mesa_glsl_error(&loc, state, "'patch out' can only be used in a " 5606 "tessellation control shader"); 5607 } 5608 5609 /* Precision qualifiers exists only in GLSL versions 1.00 and >= 1.30. 5610 */ 5611 if (this->type->qualifier.precision != ast_precision_none) { 5612 state->check_precision_qualifiers_allowed(&loc); 5613 } 5614 5615 if (this->type->qualifier.precision != ast_precision_none && 5616 !precision_qualifier_allowed(var->type)) { 5617 _mesa_glsl_error(&loc, state, 5618 "precision qualifiers apply only to floating point" 5619 ", integer and opaque types"); 5620 } 5621 5622 /* From section 4.1.7 of the GLSL 4.40 spec: 5623 * 5624 * "[Opaque types] can only be declared as function 5625 * parameters or uniform-qualified variables." 5626 * 5627 * From section 4.1.7 of the ARB_bindless_texture spec: 5628 * 5629 * "Samplers may be declared as shader inputs and outputs, as uniform 5630 * variables, as temporary variables, and as function parameters." 5631 * 5632 * From section 4.1.X of the ARB_bindless_texture spec: 5633 * 5634 * "Images may be declared as shader inputs and outputs, as uniform 5635 * variables, as temporary variables, and as function parameters." 5636 */ 5637 if (!this->type->qualifier.flags.q.uniform && 5638 (var_type->contains_atomic() || 5639 (!state->has_bindless() && var_type->contains_opaque()))) { 5640 _mesa_glsl_error(&loc, state, 5641 "%s variables must be declared uniform", 5642 state->has_bindless() ? "atomic" : "opaque"); 5643 } 5644 5645 /* Process the initializer and add its instructions to a temporary 5646 * list. This list will be added to the instruction stream (below) after 5647 * the declaration is added. This is done because in some cases (such as 5648 * redeclarations) the declaration may not actually be added to the 5649 * instruction stream. 5650 */ 5651 exec_list initializer_instructions; 5652 5653 /* Examine var name here since var may get deleted in the next call */ 5654 bool var_is_gl_id = is_gl_identifier(var->name); 5655 5656 bool is_redeclaration; 5657 var = get_variable_being_redeclared(&var, decl->get_location(), state, 5658 false /* allow_all_redeclarations */, 5659 &is_redeclaration); 5660 if (is_redeclaration) { 5661 if (var_is_gl_id && 5662 var->data.how_declared == ir_var_declared_in_block) { 5663 _mesa_glsl_error(&loc, state, 5664 "`%s' has already been redeclared using " 5665 "gl_PerVertex", var->name); 5666 } 5667 var->data.how_declared = ir_var_declared_normally; 5668 } 5669 5670 if (decl->initializer != NULL__null) { 5671 result = process_initializer(var, 5672 decl, this->type, 5673 &initializer_instructions, state); 5674 } else { 5675 validate_array_dimensions(var_type, state, &loc); 5676 } 5677 5678 /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec: 5679 * 5680 * "It is an error to write to a const variable outside of 5681 * its declaration, so they must be initialized when 5682 * declared." 5683 */ 5684 if (this->type->qualifier.flags.q.constant && decl->initializer == NULL__null) { 5685 _mesa_glsl_error(& loc, state, 5686 "const declaration of `%s' must be initialized", 5687 decl->identifier); 5688 } 5689 5690 if (state->es_shader) { 5691 const glsl_type *const t = var->type; 5692 5693 /* Skip the unsized array check for TCS/TES/GS inputs & TCS outputs. 5694 * 5695 * The GL_OES_tessellation_shader spec says about inputs: 5696 * 5697 * "Declaring an array size is optional. If no size is specified, 5698 * it will be taken from the implementation-dependent maximum 5699 * patch size (gl_MaxPatchVertices)." 5700 * 5701 * and about TCS outputs: 5702 * 5703 * "If no size is specified, it will be taken from output patch 5704 * size declared in the shader." 5705 * 5706 * The GL_OES_geometry_shader spec says: 5707 * 5708 * "All geometry shader input unsized array declarations will be 5709 * sized by an earlier input primitive layout qualifier, when 5710 * present, as per the following table." 5711 */ 5712 const bool implicitly_sized = 5713 (var->data.mode == ir_var_shader_in && 5714 state->stage >= MESA_SHADER_TESS_CTRL && 5715 state->stage <= MESA_SHADER_GEOMETRY) || 5716 (var->data.mode == ir_var_shader_out && 5717 state->stage == MESA_SHADER_TESS_CTRL); 5718 5719 if (t->is_unsized_array() && !implicitly_sized) 5720 /* Section 10.17 of the GLSL ES 1.00 specification states that 5721 * unsized array declarations have been removed from the language. 5722 * Arrays that are sized using an initializer are still explicitly 5723 * sized. However, GLSL ES 1.00 does not allow array 5724 * initializers. That is only allowed in GLSL ES 3.00. 5725 * 5726 * Section 4.1.9 (Arrays) of the GLSL ES 3.00 spec says: 5727 * 5728 * "An array type can also be formed without specifying a size 5729 * if the definition includes an initializer: 5730 * 5731 * float x[] = float[2] (1.0, 2.0); // declares an array of size 2 5732 * float y[] = float[] (1.0, 2.0, 3.0); // declares an array of size 3 5733 * 5734 * float a[5]; 5735 * float b[] = a;" 5736 */ 5737 _mesa_glsl_error(& loc, state, 5738 "unsized array declarations are not allowed in " 5739 "GLSL ES"); 5740 } 5741 5742 /* Section 4.4.6.1 Atomic Counter Layout Qualifiers of the GLSL 4.60 spec: 5743 * 5744 * "It is a compile-time error to declare an unsized array of 5745 * atomic_uint" 5746 */ 5747 if (var->type->is_unsized_array() && 5748 var->type->without_array()->base_type == GLSL_TYPE_ATOMIC_UINT) { 5749 _mesa_glsl_error(& loc, state, 5750 "Unsized array of atomic_uint is not allowed"); 5751 } 5752 5753 /* If the declaration is not a redeclaration, there are a few additional 5754 * semantic checks that must be applied. In addition, variable that was 5755 * created for the declaration should be added to the IR stream. 5756 */ 5757 if (!is_redeclaration) { 5758 validate_identifier(decl->identifier, loc, state); 5759 5760 /* Add the variable to the symbol table. Note that the initializer's 5761 * IR was already processed earlier (though it hasn't been emitted 5762 * yet), without the variable in scope. 5763 * 5764 * This differs from most C-like languages, but it follows the GLSL 5765 * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50 5766 * spec: 5767 * 5768 * "Within a declaration, the scope of a name starts immediately 5769 * after the initializer if present or immediately after the name 5770 * being declared if not." 5771 */ 5772 if (!state->symbols->add_variable(var)) { 5773 YYLTYPE loc = this->get_location(); 5774 _mesa_glsl_error(&loc, state, "name `%s' already taken in the " 5775 "current scope", decl->identifier); 5776 continue; 5777 } 5778 5779 /* Push the variable declaration to the top. It means that all the 5780 * variable declarations will appear in a funny last-to-first order, 5781 * but otherwise we run into trouble if a function is prototyped, a 5782 * global var is decled, then the function is defined with usage of 5783 * the global var. See glslparsertest's CorrectModule.frag. 5784 * However, do not insert declarations before default precision statements 5785 * or type declarations. 5786 */ 5787 ir_instruction* before_node = (ir_instruction*)instructions->get_head(); 5788 while (before_node && (before_node->ir_type == ir_type_precision || before_node->ir_type == ir_type_typedecl)) 5789 before_node = (ir_instruction*)before_node->next; 5790 if (before_node) 5791 before_node->insert_before(var); 5792 else 5793 instructions->push_head(var); 5794 } 5795 5796 instructions->append_list(&initializer_instructions); 5797 } 5798 5799 5800 /* Generally, variable declarations do not have r-values. However, 5801 * one is used for the declaration in 5802 * 5803 * while (bool b = some_condition()) { 5804 * ... 5805 * } 5806 * 5807 * so we return the rvalue from the last seen declaration here. 5808 */ 5809 return result; 5810} 5811 5812 5813ir_rvalue * 5814ast_parameter_declarator::hir(exec_list *instructions, 5815 struct _mesa_glsl_parse_state *state) 5816{ 5817 void *ctx = state; 5818 const struct glsl_type *type; 5819 const char *name = NULL__null; 5820 YYLTYPE loc = this->get_location(); 5821 5822 type = this->type->glsl_type(& name, state); 5823 5824 if (type == NULL__null) { 5825 if (name != NULL__null) { 5826 _mesa_glsl_error(& loc, state, 5827 "invalid type `%s' in declaration of `%s'", 5828 name, this->identifier); 5829 } else { 5830 _mesa_glsl_error(& loc, state, 5831 "invalid type in declaration of `%s'", 5832 this->identifier); 5833 } 5834 5835 type = glsl_type::error_type; 5836 } 5837 5838 /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec: 5839 * 5840 * "Functions that accept no input arguments need not use void in the 5841 * argument list because prototypes (or definitions) are required and 5842 * therefore there is no ambiguity when an empty argument list "( )" is 5843 * declared. The idiom "(void)" as a parameter list is provided for 5844 * convenience." 5845 * 5846 * Placing this check here prevents a void parameter being set up 5847 * for a function, which avoids tripping up checks for main taking 5848 * parameters and lookups of an unnamed symbol. 5849 */ 5850 if (type->is_void()) { 5851 if (this->identifier != NULL__null) 5852 _mesa_glsl_error(& loc, state, 5853 "named parameter cannot have type `void'"); 5854 5855 is_void = true; 5856 return NULL__null; 5857 } 5858 5859 if (formal_parameter && (this->identifier == NULL__null)) { 5860 _mesa_glsl_error(& loc, state, "formal parameter lacks a name"); 5861 return NULL__null; 5862 } 5863 5864 /* This only handles "vec4 foo[..]". The earlier specifier->glsl_type(...) 5865 * call already handled the "vec4[..] foo" case. 5866 */ 5867 type = process_array_type(&loc, type, this->array_specifier, state); 5868 5869 if (!type->is_error() && type->is_unsized_array()) { 5870 _mesa_glsl_error(&loc, state, "arrays passed as parameters must have " 5871 "a declared size"); 5872 type = glsl_type::error_type; 5873 } 5874 5875 is_void = false; 5876 ir_variable *var = new(ctx) 5877 ir_variable(type, this->identifier, ir_var_function_in); 5878 5879 /* Apply any specified qualifiers to the parameter declaration. Note that 5880 * for function parameters the default mode is 'in'. 5881 */ 5882 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc, 5883 true); 5884 5885 /* From section 4.1.7 of the GLSL 4.40 spec: 5886 * 5887 * "Opaque variables cannot be treated as l-values; hence cannot 5888 * be used as out or inout function parameters, nor can they be 5889 * assigned into." 5890 * 5891 * From section 4.1.7 of the ARB_bindless_texture spec: 5892 * 5893 * "Samplers can be used as l-values, so can be assigned into and used 5894 * as "out" and "inout" function parameters." 5895 * 5896 * From section 4.1.X of the ARB_bindless_texture spec: 5897 * 5898 * "Images can be used as l-values, so can be assigned into and used as 5899 * "out" and "inout" function parameters." 5900 */ 5901 if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out) 5902 && (type->contains_atomic() || 5903 (!state->has_bindless() && type->contains_opaque()))) { 5904 _mesa_glsl_error(&loc, state, "out and inout parameters cannot " 5905 "contain %s variables", 5906 state->has_bindless() ? "atomic" : "opaque"); 5907 type = glsl_type::error_type; 5908 } 5909 5910 /* From page 39 (page 45 of the PDF) of the GLSL 1.10 spec: 5911 * 5912 * "When calling a function, expressions that do not evaluate to 5913 * l-values cannot be passed to parameters declared as out or inout." 5914 * 5915 * From page 32 (page 38 of the PDF) of the GLSL 1.10 spec: 5916 * 5917 * "Other binary or unary expressions, non-dereferenced arrays, 5918 * function names, swizzles with repeated fields, and constants 5919 * cannot be l-values." 5920 * 5921 * So for GLSL 1.10, passing an array as an out or inout parameter is not 5922 * allowed. This restriction is removed in GLSL 1.20, and in GLSL ES. 5923 */ 5924 if ((var->data.mode == ir_var_function_inout || var->data.mode == ir_var_function_out) 5925 && type->is_array() 5926 && !state->check_version(120, 100, &loc, 5927 "arrays cannot be out or inout parameters")) { 5928 type = glsl_type::error_type; 5929 } 5930 5931 instructions->push_tail(var); 5932 5933 /* Parameter declarations do not have r-values. 5934 */ 5935 return NULL__null; 5936} 5937 5938 5939void 5940ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters, 5941 bool formal, 5942 exec_list *ir_parameters, 5943 _mesa_glsl_parse_state *state) 5944{ 5945 ast_parameter_declarator *void_param = NULL__null; 5946 unsigned count = 0; 5947 5948 foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters)for (ast_parameter_declarator * param = (!exec_node_is_tail_sentinel
((ast_parameters)->head_sentinel.next) ? ((ast_parameter_declarator
*) (((uintptr_t) (ast_parameters)->head_sentinel.next) - (
((char *) &((ast_parameter_declarator *) (ast_parameters)
->head_sentinel.next)->link) - ((char *) (ast_parameters
)->head_sentinel.next)))) : __null); (param) != __null; (param
) = (!exec_node_is_tail_sentinel((param)->link.next) ? ((ast_parameter_declarator
*) (((uintptr_t) (param)->link.next) - (((char *) &((
ast_parameter_declarator *) (param)->link.next)->link) -
((char *) (param)->link.next)))) : __null)) { 5949 param->formal_parameter = formal; 5950 param->hir(ir_parameters, state); 5951 5952 if (param->is_void) 5953 void_param = param; 5954 5955 count++; 5956 } 5957 5958 if ((void_param != NULL__null) && (count > 1)) { 5959 YYLTYPE loc = void_param->get_location(); 5960 5961 _mesa_glsl_error(& loc, state, 5962 "`void' parameter must be only parameter"); 5963 } 5964} 5965 5966 5967void 5968emit_function(_mesa_glsl_parse_state *state, ir_function *f) 5969{ 5970 /* IR invariants disallow function declarations or definitions 5971 * nested within other function definitions. But there is no 5972 * requirement about the relative order of function declarations 5973 * and definitions with respect to one another. So simply insert 5974 * the new ir_function block at the end of the toplevel instruction 5975 * list. 5976 */ 5977 state->toplevel_ir->push_tail(f); 5978} 5979 5980 5981ir_rvalue * 5982ast_function::hir(exec_list *instructions, 5983 struct _mesa_glsl_parse_state *state) 5984{ 5985 void *ctx = state; 5986 ir_function *f = NULL__null; 5987 ir_function_signature *sig = NULL__null; 5988 exec_list hir_parameters; 5989 YYLTYPE loc = this->get_location(); 5990 5991 const char *const name = identifier; 5992 5993 /* New functions are always added to the top-level IR instruction stream, 5994 * so this instruction list pointer is ignored. See also emit_function 5995 * (called below). 5996 */ 5997 (void) instructions; 5998 5999 /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec, 6000 * 6001 * "Function declarations (prototypes) cannot occur inside of functions; 6002 * they must be at global scope, or for the built-in functions, outside 6003 * the global scope." 6004 * 6005 * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec, 6006 * 6007 * "User defined functions may only be defined within the global scope." 6008 * 6009 * Note that this language does not appear in GLSL 1.10. 6010 */ 6011 if ((state->current_function != NULL__null) && 6012 state->is_version(120, 100)) { 6013 YYLTYPE loc = this->get_location(); 6014 _mesa_glsl_error(&loc, state, 6015 "declaration of function `%s' not allowed within " 6016 "function body", name); 6017 } 6018 6019 validate_identifier(name, this->get_location(), state); 6020 6021 /* Convert the list of function parameters to HIR now so that they can be 6022 * used below to compare this function's signature with previously seen 6023 * signatures for functions with the same name. 6024 */ 6025 ast_parameter_declarator::parameters_to_hir(& this->parameters, 6026 is_definition, 6027 & hir_parameters, state); 6028 6029 const char *return_type_name; 6030 const glsl_type *return_type = 6031 this->return_type->glsl_type(& return_type_name, state); 6032 6033 if (!return_type) { 6034 YYLTYPE loc = this->get_location(); 6035 _mesa_glsl_error(&loc, state, 6036 "function `%s' has undeclared return type `%s'", 6037 name, return_type_name); 6038 return_type = glsl_type::error_type; 6039 } 6040 6041 /* ARB_shader_subroutine states: 6042 * "Subroutine declarations cannot be prototyped. It is an error to prepend 6043 * subroutine(...) to a function declaration." 6044 */ 6045 if (this->return_type->qualifier.subroutine_list && !is_definition) { 6046 YYLTYPE loc = this->get_location(); 6047 _mesa_glsl_error(&loc, state, 6048 "function declaration `%s' cannot have subroutine prepended", 6049 name); 6050 } 6051 6052 /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec: 6053 * "No qualifier is allowed on the return type of a function." 6054 */ 6055 if (this->return_type->has_qualifiers(state)) { 6056 YYLTYPE loc = this->get_location(); 6057 _mesa_glsl_error(& loc, state, 6058 "function `%s' return type has qualifiers", name); 6059 } 6060 6061 /* Section 6.1 (Function Definitions) of the GLSL 1.20 spec says: 6062 * 6063 * "Arrays are allowed as arguments and as the return type. In both 6064 * cases, the array must be explicitly sized." 6065 */ 6066 if (return_type->is_unsized_array()) { 6067 YYLTYPE loc = this->get_location(); 6068 _mesa_glsl_error(& loc, state, 6069 "function `%s' return type array must be explicitly " 6070 "sized", name); 6071 } 6072 6073 /* From Section 6.1 (Function Definitions) of the GLSL 1.00 spec: 6074 * 6075 * "Arrays are allowed as arguments, but not as the return type. [...] 6076 * The return type can also be a structure if the structure does not 6077 * contain an array." 6078 */ 6079 if (state->language_version == 100 && return_type->contains_array()) { 6080 YYLTYPE loc = this->get_location(); 6081 _mesa_glsl_error(& loc, state, 6082 "function `%s' return type contains an array", name); 6083 } 6084 6085 /* From section 4.1.7 of the GLSL 4.40 spec: 6086 * 6087 * "[Opaque types] can only be declared as function parameters 6088 * or uniform-qualified variables." 6089 * 6090 * The ARB_bindless_texture spec doesn't clearly state this, but as it says 6091 * "Replace Section 4.1.7 (Samplers), p. 25" and, "Replace Section 4.1.X, 6092 * (Images)", this should be allowed. 6093 */ 6094 if (return_type->contains_atomic() || 6095 (!state->has_bindless() && return_type->contains_opaque())) { 6096 YYLTYPE loc = this->get_location(); 6097 _mesa_glsl_error(&loc, state, 6098 "function `%s' return type can't contain an %s type", 6099 name, state->has_bindless() ? "atomic" : "opaque"); 6100 } 6101 6102 /**/ 6103 if (return_type->is_subroutine()) { 6104 YYLTYPE loc = this->get_location(); 6105 _mesa_glsl_error(&loc, state, 6106 "function `%s' return type can't be a subroutine type", 6107 name); 6108 } 6109 6110 /* Get the precision for the return type */ 6111 unsigned return_precision; 6112 6113 if (state->es_shader) { 6114 YYLTYPE loc = this->get_location(); 6115 return_precision = 6116 select_gles_precision(this->return_type->qualifier.precision, 6117 return_type, 6118 state, 6119 &loc); 6120 } else { 6121 return_precision = GLSL_PRECISION_NONE; 6122 } 6123 6124 /* Create an ir_function if one doesn't already exist. */ 6125 f = state->symbols->get_function(name); 6126 if (f == NULL__null) { 6127 f = new(ctx) ir_function(name); 6128 if (!this->return_type->qualifier.is_subroutine_decl()) { 6129 if (!state->symbols->add_function(f)) { 6130 /* This function name shadows a non-function use of the same name. */ 6131 YYLTYPE loc = this->get_location(); 6132 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with " 6133 "non-function", name); 6134 return NULL__null; 6135 } 6136 } 6137 emit_function(state, f); 6138 } 6139 6140 /* From GLSL ES 3.0 spec, chapter 6.1 "Function Definitions", page 71: 6141 * 6142 * "A shader cannot redefine or overload built-in functions." 6143 * 6144 * While in GLSL ES 1.0 specification, chapter 8 "Built-in Functions": 6145 * 6146 * "User code can overload the built-in functions but cannot redefine 6147 * them." 6148 */ 6149 if (state->es_shader) { 6150 /* Local shader has no exact candidates; check the built-ins. */ 6151 if (state->language_version >= 300 && 6152 _mesa_glsl_has_builtin_function(state, name)) { 6153 YYLTYPE loc = this->get_location(); 6154 _mesa_glsl_error(& loc, state, 6155 "A shader cannot redefine or overload built-in " 6156 "function `%s' in GLSL ES 3.00", name); 6157 return NULL__null; 6158 } 6159 6160 if (state->language_version == 100) { 6161 ir_function_signature *sig = 6162 _mesa_glsl_find_builtin_function(state, name, &hir_parameters); 6163 if (sig && sig->is_builtin()) { 6164 _mesa_glsl_error(& loc, state, 6165 "A shader cannot redefine built-in " 6166 "function `%s' in GLSL ES 1.00", name); 6167 } 6168 } 6169 } 6170 6171 /* Verify that this function's signature either doesn't match a previously 6172 * seen signature for a function with the same name, or, if a match is found, 6173 * that the previously seen signature does not have an associated definition. 6174 */ 6175 if (state->es_shader || f->has_user_signature()) { 6176 sig = f->exact_matching_signature(state, &hir_parameters); 6177 if (sig != NULL__null) { 6178 const char *badvar = sig->qualifiers_match(&hir_parameters); 6179 if (badvar != NULL__null) { 6180 YYLTYPE loc = this->get_location(); 6181 6182 _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' " 6183 "qualifiers don't match prototype", name, badvar); 6184 } 6185 6186 if (sig->return_type != return_type) { 6187 YYLTYPE loc = this->get_location(); 6188 6189 _mesa_glsl_error(&loc, state, "function `%s' return type doesn't " 6190 "match prototype", name); 6191 } 6192 6193 if (sig->return_precision != return_precision) { 6194 YYLTYPE loc = this->get_location(); 6195 6196 _mesa_glsl_error(&loc, state, "function `%s' return type precision " 6197 "doesn't match prototype", name); 6198 } 6199 6200 if (sig->is_defined) { 6201 if (is_definition) { 6202 YYLTYPE loc = this->get_location(); 6203 _mesa_glsl_error(& loc, state, "function `%s' redefined", name); 6204 } else { 6205 /* We just encountered a prototype that exactly matches a 6206 * function that's already been defined. This is redundant, 6207 * and we should ignore it. 6208 */ 6209 return NULL__null; 6210 } 6211 } else if (state->language_version == 100 && !is_definition) { 6212 /* From the GLSL 1.00 spec, section 4.2.7: 6213 * 6214 * "A particular variable, structure or function declaration 6215 * may occur at most once within a scope with the exception 6216 * that a single function prototype plus the corresponding 6217 * function definition are allowed." 6218 */ 6219 YYLTYPE loc = this->get_location(); 6220 _mesa_glsl_error(&loc, state, "function `%s' redeclared", name); 6221 } 6222 } 6223 } 6224 6225 /* Verify the return type of main() */ 6226 if (strcmp(name, "main") == 0) { 6227 if (! return_type->is_void()) { 6228 YYLTYPE loc = this->get_location(); 6229 6230 _mesa_glsl_error(& loc, state, "main() must return void"); 6231 } 6232 6233 if (!hir_parameters.is_empty()) { 6234 YYLTYPE loc = this->get_location(); 6235 6236 _mesa_glsl_error(& loc, state, "main() must not take any parameters"); 6237 } 6238 } 6239 6240 /* Finish storing the information about this new function in its signature. 6241 */ 6242 if (sig == NULL__null) { 6243 sig = new(ctx) ir_function_signature(return_type); 6244 sig->return_precision = return_precision; 6245 f->add_signature(sig); 6246 } 6247 6248 sig->replace_parameters(&hir_parameters); 6249 signature = sig; 6250 6251 if (this->return_type->qualifier.subroutine_list) { 6252 int idx; 6253 6254 if (this->return_type->qualifier.flags.q.explicit_index) { 6255 unsigned qual_index; 6256 if (process_qualifier_constant(state, &loc, "index", 6257 this->return_type->qualifier.index, 6258 &qual_index)) { 6259 if (!state->has_explicit_uniform_location()) { 6260 _mesa_glsl_error(&loc, state, "subroutine index requires " 6261 "GL_ARB_explicit_uniform_location or " 6262 "GLSL 4.30"); 6263 } else if (qual_index >= MAX_SUBROUTINES256) { 6264 _mesa_glsl_error(&loc, state, 6265 "invalid subroutine index (%d) index must " 6266 "be a number between 0 and " 6267 "GL_MAX_SUBROUTINES - 1 (%d)", qual_index, 6268 MAX_SUBROUTINES256 - 1); 6269 } else { 6270 f->subroutine_index = qual_index; 6271 } 6272 } 6273 } 6274 6275 f->num_subroutine_types = this->return_type->qualifier.subroutine_list->declarations.length(); 6276 f->subroutine_types = ralloc_array(state, const struct glsl_type *,((const struct glsl_type * *) ralloc_array_size(state, sizeof
(const struct glsl_type *), f->num_subroutine_types)) 6277 f->num_subroutine_types)((const struct glsl_type * *) ralloc_array_size(state, sizeof
(const struct glsl_type *), f->num_subroutine_types)); 6278 idx = 0; 6279 foreach_list_typed(ast_declaration, decl, link, &this->return_type->qualifier.subroutine_list->declarations)for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
this->return_type->qualifier.subroutine_list->declarations
)->head_sentinel.next) ? ((ast_declaration *) (((uintptr_t
) (&this->return_type->qualifier.subroutine_list->
declarations)->head_sentinel.next) - (((char *) &((ast_declaration
*) (&this->return_type->qualifier.subroutine_list->
declarations)->head_sentinel.next)->link) - ((char *) (
&this->return_type->qualifier.subroutine_list->declarations
)->head_sentinel.next)))) : __null); (decl) != __null; (decl
) = (!exec_node_is_tail_sentinel((decl)->link.next) ? ((ast_declaration
*) (((uintptr_t) (decl)->link.next) - (((char *) &((ast_declaration
*) (decl)->link.next)->link) - ((char *) (decl)->link
.next)))) : __null)) { 6280 const struct glsl_type *type; 6281 /* the subroutine type must be already declared */ 6282 type = state->symbols->get_type(decl->identifier); 6283 if (!type) { 6284 _mesa_glsl_error(& loc, state, "unknown type '%s' in subroutine function definition", decl->identifier); 6285 } 6286 6287 for (int i = 0; i < state->num_subroutine_types; i++) { 6288 ir_function *fn = state->subroutine_types[i]; 6289 ir_function_signature *tsig = NULL__null; 6290 6291 if (strcmp(fn->name, decl->identifier)) 6292 continue; 6293 6294 tsig = fn->matching_signature(state, &sig->parameters, 6295 false); 6296 if (!tsig) { 6297 _mesa_glsl_error(& loc, state, "subroutine type mismatch '%s' - signatures do not match\n", decl->identifier); 6298 } else { 6299 if (tsig->return_type != sig->return_type) { 6300 _mesa_glsl_error(& loc, state, "subroutine type mismatch '%s' - return types do not match\n", decl->identifier); 6301 } 6302 } 6303 } 6304 f->subroutine_types[idx++] = type; 6305 } 6306 state->subroutines = (ir_function **)reralloc(state, state->subroutines,((ir_function * *) reralloc_array_size(state, state->subroutines
, sizeof(ir_function *), state->num_subroutines + 1)) 6307 ir_function *,((ir_function * *) reralloc_array_size(state, state->subroutines
, sizeof(ir_function *), state->num_subroutines + 1)) 6308 state->num_subroutines + 1)((ir_function * *) reralloc_array_size(state, state->subroutines
, sizeof(ir_function *), state->num_subroutines + 1)); 6309 state->subroutines[state->num_subroutines] = f; 6310 state->num_subroutines++; 6311 6312 } 6313 6314 if (this->return_type->qualifier.is_subroutine_decl()) { 6315 if (!state->symbols->add_type(this->identifier, glsl_type::get_subroutine_instance(this->identifier))) { 6316 _mesa_glsl_error(& loc, state, "type '%s' previously defined", this->identifier); 6317 return NULL__null; 6318 } 6319 state->subroutine_types = (ir_function **)reralloc(state, state->subroutine_types,((ir_function * *) reralloc_array_size(state, state->subroutine_types
, sizeof(ir_function *), state->num_subroutine_types + 1)) 6320 ir_function *,((ir_function * *) reralloc_array_size(state, state->subroutine_types
, sizeof(ir_function *), state->num_subroutine_types + 1)) 6321 state->num_subroutine_types + 1)((ir_function * *) reralloc_array_size(state, state->subroutine_types
, sizeof(ir_function *), state->num_subroutine_types + 1)); 6322 state->subroutine_types[state->num_subroutine_types] = f; 6323 state->num_subroutine_types++; 6324 6325 f->is_subroutine = true; 6326 } 6327 6328 /* Function declarations (prototypes) do not have r-values. 6329 */ 6330 return NULL__null; 6331} 6332 6333 6334ir_rvalue * 6335ast_function_definition::hir(exec_list *instructions, 6336 struct _mesa_glsl_parse_state *state) 6337{ 6338 prototype->is_definition = true; 6339 prototype->hir(instructions, state); 6340 6341 ir_function_signature *signature = prototype->signature; 6342 if (signature == NULL__null) 6343 return NULL__null; 6344 6345 assert(state->current_function == NULL)(static_cast <bool> (state->current_function == __null
) ? void (0) : __assert_fail ("state->current_function == NULL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 6346 state->current_function = signature; 6347 state->found_return = false; 6348 state->found_begin_interlock = false; 6349 state->found_end_interlock = false; 6350 6351 /* Duplicate parameters declared in the prototype as concrete variables. 6352 * Add these to the symbol table. 6353 */ 6354 state->symbols->push_scope(); 6355 foreach_in_list(ir_variable, var, &signature->parameters)for (ir_variable *var = (!exec_node_is_tail_sentinel((&signature
->parameters)->head_sentinel.next) ? (ir_variable *) ((
&signature->parameters)->head_sentinel.next) : __null
); (var) != __null; (var) = (!exec_node_is_tail_sentinel((var
)->next) ? (ir_variable *) ((var)->next) : __null)) { 6356 assert(var->as_variable() != NULL)(static_cast <bool> (var->as_variable() != __null) ?
void (0) : __assert_fail ("var->as_variable() != NULL", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 6357 6358 /* The only way a parameter would "exist" is if two parameters have 6359 * the same name. 6360 */ 6361 if (state->symbols->name_declared_this_scope(var->name)) { 6362 YYLTYPE loc = this->get_location(); 6363 6364 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name); 6365 } else { 6366 state->symbols->add_variable(var); 6367 } 6368 } 6369 6370 /* Convert the body of the function to HIR. */ 6371 this->body->hir(&signature->body, state); 6372 signature->is_defined = true; 6373 6374 state->symbols->pop_scope(); 6375 6376 assert(state->current_function == signature)(static_cast <bool> (state->current_function == signature
) ? void (0) : __assert_fail ("state->current_function == signature"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 6377 state->current_function = NULL__null; 6378 6379 if (!signature->return_type->is_void() && !state->found_return) { 6380 YYLTYPE loc = this->get_location(); 6381 _mesa_glsl_error(& loc, state, "function `%s' has non-void return type " 6382 "%s, but no return statement", 6383 signature->function_name(), 6384 signature->return_type->name); 6385 } 6386 6387 /* Function definitions do not have r-values. 6388 */ 6389 return NULL__null; 6390} 6391 6392 6393ir_rvalue * 6394ast_jump_statement::hir(exec_list *instructions, 6395 struct _mesa_glsl_parse_state *state) 6396{ 6397 void *ctx = state; 6398 6399 switch (mode) { 6400 case ast_return: { 6401 ir_return *inst; 6402 assert(state->current_function)(static_cast <bool> (state->current_function) ? void
(0) : __assert_fail ("state->current_function", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 6403 6404 if (opt_return_value) { 6405 ir_rvalue *ret = opt_return_value->hir(instructions, state); 6406 6407 /* The value of the return type can be NULL if the shader says 6408 * 'return foo();' and foo() is a function that returns void. 6409 * 6410 * NOTE: The GLSL spec doesn't say that this is an error. The type 6411 * of the return value is void. If the return type of the function is 6412 * also void, then this should compile without error. Seriously. 6413 */ 6414 const glsl_type *const ret_type = 6415 (ret == NULL__null) ? glsl_type::void_type : ret->type; 6416 6417 /* Implicit conversions are not allowed for return values prior to 6418 * ARB_shading_language_420pack. 6419 */ 6420 if (state->current_function->return_type != ret_type) { 6421 YYLTYPE loc = this->get_location(); 6422 6423 if (state->has_420pack()) { 6424 if (!apply_implicit_conversion(state->current_function->return_type, 6425 ret, state) 6426 || (ret->type != state->current_function->return_type)) { 6427 _mesa_glsl_error(& loc, state, 6428 "could not implicitly convert return value " 6429 "to %s, in function `%s'", 6430 state->current_function->return_type->name, 6431 state->current_function->function_name()); 6432 } 6433 } else { 6434 _mesa_glsl_error(& loc, state, 6435 "`return' with wrong type %s, in function `%s' " 6436 "returning %s", 6437 ret_type->name, 6438 state->current_function->function_name(), 6439 state->current_function->return_type->name); 6440 } 6441 } else if (state->current_function->return_type->base_type == 6442 GLSL_TYPE_VOID) { 6443 YYLTYPE loc = this->get_location(); 6444 6445 /* The ARB_shading_language_420pack, GLSL ES 3.0, and GLSL 4.20 6446 * specs add a clarification: 6447 * 6448 * "A void function can only use return without a return argument, even if 6449 * the return argument has void type. Return statements only accept values: 6450 * 6451 * void func1() { } 6452 * void func2() { return func1(); } // illegal return statement" 6453 */ 6454 _mesa_glsl_error(& loc, state, 6455 "void functions can only use `return' without a " 6456 "return argument"); 6457 } 6458 6459 inst = new(ctx) ir_return(ret); 6460 } else { 6461 if (state->current_function->return_type->base_type != 6462 GLSL_TYPE_VOID) { 6463 YYLTYPE loc = this->get_location(); 6464 6465 _mesa_glsl_error(& loc, state, 6466 "`return' with no value, in function %s returning " 6467 "non-void", 6468 state->current_function->function_name()); 6469 } 6470 inst = new(ctx) ir_return; 6471 } 6472 6473 state->found_return = true; 6474 instructions->push_tail(inst); 6475 break; 6476 } 6477 6478 case ast_discard: 6479 if (state->stage != MESA_SHADER_FRAGMENT) { 6480 YYLTYPE loc = this->get_location(); 6481 6482 _mesa_glsl_error(& loc, state, 6483 "`discard' may only appear in a fragment shader"); 6484 } 6485 instructions->push_tail(new(ctx) ir_discard); 6486 break; 6487 6488 case ast_break: 6489 case ast_continue: 6490 if (mode == ast_continue && 6491 state->loop_nesting_ast == NULL__null) { 6492 YYLTYPE loc = this->get_location(); 6493 6494 _mesa_glsl_error(& loc, state, "continue may only appear in a loop"); 6495 } else if (mode == ast_break && 6496 state->loop_nesting_ast == NULL__null && 6497 state->switch_state.switch_nesting_ast == NULL__null) { 6498 YYLTYPE loc = this->get_location(); 6499 6500 _mesa_glsl_error(& loc, state, 6501 "break may only appear in a loop or a switch"); 6502 } else { 6503 /* For a loop, inline the for loop expression again, since we don't 6504 * know where near the end of the loop body the normal copy of it is 6505 * going to be placed. Same goes for the condition for a do-while 6506 * loop. 6507 */ 6508 if (state->loop_nesting_ast != NULL__null && 6509 mode == ast_continue) { 6510 if (state->loop_nesting_ast->rest_expression) { 6511 state->loop_nesting_ast->rest_expression->hir(instructions, 6512 state); 6513 } 6514 if (state->loop_nesting_ast->mode == 6515 ast_iteration_statement::ast_do_while) { 6516 state->loop_nesting_ast->condition_to_hir(instructions, state); 6517 } 6518 } 6519 6520 if (state->switch_state.is_switch_innermost && 6521 mode == ast_break) { 6522 /* Force break out of switch by setting is_break switch state. 6523 */ 6524 ir_variable *const is_break_var = state->switch_state.is_break_var; 6525 ir_dereference_variable *const deref_is_break_var = 6526 new(ctx) ir_dereference_variable(is_break_var); 6527 ir_constant *const true_val = new(ctx) ir_constant(true); 6528 ir_assignment *const set_break_var = 6529 new(ctx) ir_assignment(deref_is_break_var, true_val); 6530 6531 instructions->push_tail(set_break_var); 6532 } else { 6533 ir_loop_jump *const jump = 6534 new(ctx) ir_loop_jump((mode == ast_break) 6535 ? ir_loop_jump::jump_break 6536 : ir_loop_jump::jump_continue); 6537 instructions->push_tail(jump); 6538 } 6539 } 6540 6541 break; 6542 } 6543 6544 /* Jump instructions do not have r-values. 6545 */ 6546 return NULL__null; 6547} 6548 6549 6550ir_rvalue * 6551ast_demote_statement::hir(exec_list *instructions, 6552 struct _mesa_glsl_parse_state *state) 6553{ 6554 void *ctx = state; 6555 6556 if (state->stage != MESA_SHADER_FRAGMENT) { 6557 YYLTYPE loc = this->get_location(); 6558 6559 _mesa_glsl_error(& loc, state, 6560 "`demote' may only appear in a fragment shader"); 6561 } 6562 6563 instructions->push_tail(new(ctx) ir_demote); 6564 6565 return NULL__null; 6566} 6567 6568 6569ir_rvalue * 6570ast_selection_statement::hir(exec_list *instructions, 6571 struct _mesa_glsl_parse_state *state) 6572{ 6573 void *ctx = state; 6574 6575 ir_rvalue *const condition = this->condition->hir(instructions, state); 6576 6577 /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec: 6578 * 6579 * "Any expression whose type evaluates to a Boolean can be used as the 6580 * conditional expression bool-expression. Vector types are not accepted 6581 * as the expression to if." 6582 * 6583 * The checks are separated so that higher quality diagnostics can be 6584 * generated for cases where both rules are violated. 6585 */ 6586 if (!condition->type->is_boolean() || !condition->type->is_scalar()) { 6587 YYLTYPE loc = this->condition->get_location(); 6588 6589 _mesa_glsl_error(& loc, state, "if-statement condition must be scalar " 6590 "boolean"); 6591 } 6592 6593 ir_if *const stmt = new(ctx) ir_if(condition); 6594 6595 if (then_statement != NULL__null) { 6596 state->symbols->push_scope(); 6597 then_statement->hir(& stmt->then_instructions, state); 6598 state->symbols->pop_scope(); 6599 } 6600 6601 if (else_statement != NULL__null) { 6602 state->symbols->push_scope(); 6603 else_statement->hir(& stmt->else_instructions, state); 6604 state->symbols->pop_scope(); 6605 } 6606 6607 instructions->push_tail(stmt); 6608 6609 /* if-statements do not have r-values. 6610 */ 6611 return NULL__null; 6612} 6613 6614 6615struct case_label { 6616 /** Value of the case label. */ 6617 unsigned value; 6618 6619 /** Does this label occur after the default? */ 6620 bool after_default; 6621 6622 /** 6623 * AST for the case label. 6624 * 6625 * This is only used to generate error messages for duplicate labels. 6626 */ 6627 ast_expression *ast; 6628}; 6629 6630/* Used for detection of duplicate case values, compare 6631 * given contents directly. 6632 */ 6633static bool 6634compare_case_value(const void *a, const void *b) 6635{ 6636 return ((struct case_label *) a)->value == ((struct case_label *) b)->value; 6637} 6638 6639 6640/* Used for detection of duplicate case values, just 6641 * returns key contents as is. 6642 */ 6643static unsigned 6644key_contents(const void *key) 6645{ 6646 return ((struct case_label *) key)->value; 6647} 6648 6649 6650ir_rvalue * 6651ast_switch_statement::hir(exec_list *instructions, 6652 struct _mesa_glsl_parse_state *state) 6653{ 6654 void *ctx = state; 6655 6656 ir_rvalue *const test_expression = 6657 this->test_expression->hir(instructions, state); 6658 6659 /* From page 66 (page 55 of the PDF) of the GLSL 1.50 spec: 6660 * 6661 * "The type of init-expression in a switch statement must be a 6662 * scalar integer." 6663 */ 6664 if (!test_expression->type->is_scalar() || 6665 !test_expression->type->is_integer_32()) { 6666 YYLTYPE loc = this->test_expression->get_location(); 6667 6668 _mesa_glsl_error(& loc, 6669 state, 6670 "switch-statement expression must be scalar " 6671 "integer"); 6672 return NULL__null; 6673 } 6674 6675 /* Track the switch-statement nesting in a stack-like manner. 6676 */ 6677 struct glsl_switch_state saved = state->switch_state; 6678 6679 state->switch_state.is_switch_innermost = true; 6680 state->switch_state.switch_nesting_ast = this; 6681 state->switch_state.labels_ht = 6682 _mesa_hash_table_create(NULL__null, key_contents, 6683 compare_case_value); 6684 state->switch_state.previous_default = NULL__null; 6685 6686 /* Initalize is_fallthru state to false. 6687 */ 6688 ir_rvalue *const is_fallthru_val = new (ctx) ir_constant(false); 6689 state->switch_state.is_fallthru_var = 6690 new(ctx) ir_variable(glsl_type::bool_type, 6691 "switch_is_fallthru_tmp", 6692 ir_var_temporary); 6693 instructions->push_tail(state->switch_state.is_fallthru_var); 6694 6695 ir_dereference_variable *deref_is_fallthru_var = 6696 new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var); 6697 instructions->push_tail(new(ctx) ir_assignment(deref_is_fallthru_var, 6698 is_fallthru_val)); 6699 6700 /* Initialize is_break state to false. 6701 */ 6702 ir_rvalue *const is_break_val = new (ctx) ir_constant(false); 6703 state->switch_state.is_break_var = 6704 new(ctx) ir_variable(glsl_type::bool_type, 6705 "switch_is_break_tmp", 6706 ir_var_temporary); 6707 instructions->push_tail(state->switch_state.is_break_var); 6708 6709 ir_dereference_variable *deref_is_break_var = 6710 new(ctx) ir_dereference_variable(state->switch_state.is_break_var); 6711 instructions->push_tail(new(ctx) ir_assignment(deref_is_break_var, 6712 is_break_val)); 6713 6714 state->switch_state.run_default = 6715 new(ctx) ir_variable(glsl_type::bool_type, 6716 "run_default_tmp", 6717 ir_var_temporary); 6718 instructions->push_tail(state->switch_state.run_default); 6719 6720 /* Cache test expression. 6721 */ 6722 test_to_hir(instructions, state); 6723 6724 /* Emit code for body of switch stmt. 6725 */ 6726 body->hir(instructions, state); 6727 6728 _mesa_hash_table_destroy(state->switch_state.labels_ht, NULL__null); 6729 6730 state->switch_state = saved; 6731 6732 /* Switch statements do not have r-values. */ 6733 return NULL__null; 6734} 6735 6736 6737void 6738ast_switch_statement::test_to_hir(exec_list *instructions, 6739 struct _mesa_glsl_parse_state *state) 6740{ 6741 void *ctx = state; 6742 6743 /* set to true to avoid a duplicate "use of uninitialized variable" warning 6744 * on the switch test case. The first one would be already raised when 6745 * getting the test_expression at ast_switch_statement::hir 6746 */ 6747 test_expression->set_is_lhs(true); 6748 /* Cache value of test expression. */ 6749 ir_rvalue *const test_val = test_expression->hir(instructions, state); 6750 6751 state->switch_state.test_var = new(ctx) ir_variable(test_val->type, 6752 "switch_test_tmp", 6753 ir_var_temporary); 6754 ir_dereference_variable *deref_test_var = 6755 new(ctx) ir_dereference_variable(state->switch_state.test_var); 6756 6757 instructions->push_tail(state->switch_state.test_var); 6758 instructions->push_tail(new(ctx) ir_assignment(deref_test_var, test_val)); 6759} 6760 6761 6762ir_rvalue * 6763ast_switch_body::hir(exec_list *instructions, 6764 struct _mesa_glsl_parse_state *state) 6765{ 6766 if (stmts != NULL__null) 6767 stmts->hir(instructions, state); 6768 6769 /* Switch bodies do not have r-values. */ 6770 return NULL__null; 6771} 6772 6773ir_rvalue * 6774ast_case_statement_list::hir(exec_list *instructions, 6775 struct _mesa_glsl_parse_state *state) 6776{ 6777 exec_list default_case, after_default, tmp; 6778 6779 foreach_list_typed (ast_case_statement, case_stmt, link, & this->cases)for (ast_case_statement * case_stmt = (!exec_node_is_tail_sentinel
((& this->cases)->head_sentinel.next) ? ((ast_case_statement
*) (((uintptr_t) (& this->cases)->head_sentinel.next
) - (((char *) &((ast_case_statement *) (& this->cases
)->head_sentinel.next)->link) - ((char *) (& this->
cases)->head_sentinel.next)))) : __null); (case_stmt) != __null
; (case_stmt) = (!exec_node_is_tail_sentinel((case_stmt)->
link.next) ? ((ast_case_statement *) (((uintptr_t) (case_stmt
)->link.next) - (((char *) &((ast_case_statement *) (case_stmt
)->link.next)->link) - ((char *) (case_stmt)->link.next
)))) : __null)) { 6780 case_stmt->hir(&tmp, state); 6781 6782 /* Default case. */ 6783 if (state->switch_state.previous_default && default_case.is_empty()) { 6784 default_case.append_list(&tmp); 6785 continue; 6786 } 6787 6788 /* If default case found, append 'after_default' list. */ 6789 if (!default_case.is_empty()) 6790 after_default.append_list(&tmp); 6791 else 6792 instructions->append_list(&tmp); 6793 } 6794 6795 /* Handle the default case. This is done here because default might not be 6796 * the last case. We need to add checks against following cases first to see 6797 * if default should be chosen or not. 6798 */ 6799 if (!default_case.is_empty()) { 6800 ir_factory body(instructions, state); 6801 6802 ir_expression *cmp = NULL__null; 6803 6804 hash_table_foreach(state->switch_state.labels_ht, entry)for (struct hash_entry *entry = _mesa_hash_table_next_entry(state
->switch_state.labels_ht, __null); entry != __null; entry =
_mesa_hash_table_next_entry(state->switch_state.labels_ht
, entry)) { 6805 const struct case_label *const l = (struct case_label *) entry->data; 6806 6807 /* If the switch init-value is the value of one of the labels that 6808 * occurs after the default case, disable execution of the default 6809 * case. 6810 */ 6811 if (l->after_default) { 6812 ir_constant *const cnst = 6813 state->switch_state.test_var->type->base_type == GLSL_TYPE_UINT 6814 ? body.constant(unsigned(l->value)) 6815 : body.constant(int(l->value)); 6816 6817 cmp = cmp == NULL__null 6818 ? equal(cnst, state->switch_state.test_var) 6819 : logic_or(cmp, equal(cnst, state->switch_state.test_var)); 6820 } 6821 } 6822 6823 if (cmp != NULL__null) 6824 body.emit(assign(state->switch_state.run_default, logic_not(cmp))); 6825 else 6826 body.emit(assign(state->switch_state.run_default, body.constant(true))); 6827 6828 /* Append default case and all cases after it. */ 6829 instructions->append_list(&default_case); 6830 instructions->append_list(&after_default); 6831 } 6832 6833 /* Case statements do not have r-values. */ 6834 return NULL__null; 6835} 6836 6837ir_rvalue * 6838ast_case_statement::hir(exec_list *instructions, 6839 struct _mesa_glsl_parse_state *state) 6840{ 6841 labels->hir(instructions, state); 6842 6843 /* Conditionally set fallthru state based on break state. */ 6844 ir_factory reset_fallthru(instructions, state); 6845 reset_fallthru.emit(assign(state->switch_state.is_fallthru_var, 6846 logic_and(state->switch_state.is_fallthru_var, 6847 logic_not(state->switch_state.is_break_var)))); 6848 6849 /* Guard case statements depending on fallthru state. */ 6850 ir_dereference_variable *const deref_fallthru_guard = 6851 new(state) ir_dereference_variable(state->switch_state.is_fallthru_var); 6852 ir_if *const test_fallthru = new(state) ir_if(deref_fallthru_guard); 6853 6854 foreach_list_typed (ast_node, stmt, link, & this->stmts)for (ast_node * stmt = (!exec_node_is_tail_sentinel((& this
->stmts)->head_sentinel.next) ? ((ast_node *) (((uintptr_t
) (& this->stmts)->head_sentinel.next) - (((char *)
&((ast_node *) (& this->stmts)->head_sentinel.
next)->link) - ((char *) (& this->stmts)->head_sentinel
.next)))) : __null); (stmt) != __null; (stmt) = (!exec_node_is_tail_sentinel
((stmt)->link.next) ? ((ast_node *) (((uintptr_t) (stmt)->
link.next) - (((char *) &((ast_node *) (stmt)->link.next
)->link) - ((char *) (stmt)->link.next)))) : __null)) 6855 stmt->hir(& test_fallthru->then_instructions, state); 6856 6857 instructions->push_tail(test_fallthru); 6858 6859 /* Case statements do not have r-values. */ 6860 return NULL__null; 6861} 6862 6863 6864ir_rvalue * 6865ast_case_label_list::hir(exec_list *instructions, 6866 struct _mesa_glsl_parse_state *state) 6867{ 6868 foreach_list_typed (ast_case_label, label, link, & this->labels)for (ast_case_label * label = (!exec_node_is_tail_sentinel((&
this->labels)->head_sentinel.next) ? ((ast_case_label *
) (((uintptr_t) (& this->labels)->head_sentinel.next
) - (((char *) &((ast_case_label *) (& this->labels
)->head_sentinel.next)->link) - ((char *) (& this->
labels)->head_sentinel.next)))) : __null); (label) != __null
; (label) = (!exec_node_is_tail_sentinel((label)->link.next
) ? ((ast_case_label *) (((uintptr_t) (label)->link.next) -
(((char *) &((ast_case_label *) (label)->link.next)->
link) - ((char *) (label)->link.next)))) : __null)) 6869 label->hir(instructions, state); 6870 6871 /* Case labels do not have r-values. */ 6872 return NULL__null; 6873} 6874 6875ir_rvalue * 6876ast_case_label::hir(exec_list *instructions, 6877 struct _mesa_glsl_parse_state *state) 6878{ 6879 ir_factory body(instructions, state); 6880 6881 ir_variable *const fallthru_var = state->switch_state.is_fallthru_var; 6882 6883 /* If not default case, ... */ 6884 if (this->test_value != NULL__null) { 6885 /* Conditionally set fallthru state based on 6886 * comparison of cached test expression value to case label. 6887 */ 6888 ir_rvalue *const label_rval = this->test_value->hir(instructions, state); 6889 ir_constant *label_const = 6890 label_rval->constant_expression_value(body.mem_ctx); 6891 6892 if (!label_const) { 6893 YYLTYPE loc = this->test_value->get_location(); 6894 6895 _mesa_glsl_error(& loc, state, 6896 "switch statement case label must be a " 6897 "constant expression"); 6898 6899 /* Stuff a dummy value in to allow processing to continue. */ 6900 label_const = body.constant(0); 6901 } else { 6902 hash_entry *entry = 6903 _mesa_hash_table_search(state->switch_state.labels_ht, 6904 &label_const->value.u[0]); 6905 6906 if (entry) { 6907 const struct case_label *const l = 6908 (struct case_label *) entry->data; 6909 const ast_expression *const previous_label = l->ast; 6910 YYLTYPE loc = this->test_value->get_location(); 6911 6912 _mesa_glsl_error(& loc, state, "duplicate case value"); 6913 6914 loc = previous_label->get_location(); 6915 _mesa_glsl_error(& loc, state, "this is the previous case label"); 6916 } else { 6917 struct case_label *l = ralloc(state->switch_state.labels_ht,((struct case_label *) ralloc_size(state->switch_state.labels_ht
, sizeof(struct case_label))) 6918 struct case_label)((struct case_label *) ralloc_size(state->switch_state.labels_ht
, sizeof(struct case_label))); 6919 6920 l->value = label_const->value.u[0]; 6921 l->after_default = state->switch_state.previous_default != NULL__null; 6922 l->ast = this->test_value; 6923 6924 _mesa_hash_table_insert(state->switch_state.labels_ht, 6925 &label_const->value.u[0], 6926 l); 6927 } 6928 } 6929 6930 /* Create an r-value version of the ir_constant label here (after we may 6931 * have created a fake one in error cases) that can be passed to 6932 * apply_implicit_conversion below. 6933 */ 6934 ir_rvalue *label = label_const; 6935 6936 ir_rvalue *deref_test_var = 6937 new(body.mem_ctx) ir_dereference_variable(state->switch_state.test_var); 6938 6939 /* 6940 * From GLSL 4.40 specification section 6.2 ("Selection"): 6941 * 6942 * "The type of the init-expression value in a switch statement must 6943 * be a scalar int or uint. The type of the constant-expression value 6944 * in a case label also must be a scalar int or uint. When any pair 6945 * of these values is tested for "equal value" and the types do not 6946 * match, an implicit conversion will be done to convert the int to a 6947 * uint (see section 4.1.10 “Implicit Conversions”) before the compare 6948 * is done." 6949 */ 6950 if (label->type != state->switch_state.test_var->type) { 6951 YYLTYPE loc = this->test_value->get_location(); 6952 6953 const glsl_type *type_a = label->type; 6954 const glsl_type *type_b = state->switch_state.test_var->type; 6955 6956 /* Check if int->uint implicit conversion is supported. */ 6957 bool integer_conversion_supported = 6958 glsl_type::int_type->can_implicitly_convert_to(glsl_type::uint_type, 6959 state); 6960 6961 if ((!type_a->is_integer_32() || !type_b->is_integer_32()) || 6962 !integer_conversion_supported) { 6963 _mesa_glsl_error(&loc, state, "type mismatch with switch " 6964 "init-expression and case label (%s != %s)", 6965 type_a->name, type_b->name); 6966 } else { 6967 /* Conversion of the case label. */ 6968 if (type_a->base_type == GLSL_TYPE_INT) { 6969 if (!apply_implicit_conversion(glsl_type::uint_type, 6970 label, state)) 6971 _mesa_glsl_error(&loc, state, "implicit type conversion error"); 6972 } else { 6973 /* Conversion of the init-expression value. */ 6974 if (!apply_implicit_conversion(glsl_type::uint_type, 6975 deref_test_var, state)) 6976 _mesa_glsl_error(&loc, state, "implicit type conversion error"); 6977 } 6978 } 6979 6980 /* If the implicit conversion was allowed, the types will already be 6981 * the same. If the implicit conversion wasn't allowed, smash the 6982 * type of the label anyway. This will prevent the expression 6983 * constructor (below) from failing an assertion. 6984 */ 6985 label->type = deref_test_var->type; 6986 } 6987 6988 body.emit(assign(fallthru_var, 6989 logic_or(fallthru_var, equal(label, deref_test_var)))); 6990 } else { /* default case */ 6991 if (state->switch_state.previous_default) { 6992 YYLTYPE loc = this->get_location(); 6993 _mesa_glsl_error(& loc, state, 6994 "multiple default labels in one switch"); 6995 6996 loc = state->switch_state.previous_default->get_location(); 6997 _mesa_glsl_error(& loc, state, "this is the first default label"); 6998 } 6999 state->switch_state.previous_default = this; 7000 7001 /* Set fallthru condition on 'run_default' bool. */ 7002 body.emit(assign(fallthru_var, 7003 logic_or(fallthru_var, 7004 state->switch_state.run_default))); 7005 } 7006 7007 /* Case statements do not have r-values. */ 7008 return NULL__null; 7009} 7010 7011void 7012ast_iteration_statement::condition_to_hir(exec_list *instructions, 7013 struct _mesa_glsl_parse_state *state) 7014{ 7015 void *ctx = state; 7016 7017 if (condition != NULL__null) { 7018 ir_rvalue *const cond = 7019 condition->hir(instructions, state); 7020 7021 if ((cond == NULL__null) 7022 || !cond->type->is_boolean() || !cond->type->is_scalar()) { 7023 YYLTYPE loc = condition->get_location(); 7024 7025 _mesa_glsl_error(& loc, state, 7026 "loop condition must be scalar boolean"); 7027 } else { 7028 /* As the first code in the loop body, generate a block that looks 7029 * like 'if (!condition) break;' as the loop termination condition. 7030 */ 7031 ir_rvalue *const not_cond = 7032 new(ctx) ir_expression(ir_unop_logic_not, cond); 7033 7034 ir_if *const if_stmt = new(ctx) ir_if(not_cond); 7035 7036 ir_jump *const break_stmt = 7037 new(ctx) ir_loop_jump(ir_loop_jump::jump_break); 7038 7039 if_stmt->then_instructions.push_tail(break_stmt); 7040 instructions->push_tail(if_stmt); 7041 } 7042 } 7043} 7044 7045 7046ir_rvalue * 7047ast_iteration_statement::hir(exec_list *instructions, 7048 struct _mesa_glsl_parse_state *state) 7049{ 7050 void *ctx = state; 7051 7052 /* For-loops and while-loops start a new scope, but do-while loops do not. 7053 */ 7054 if (mode != ast_do_while) 7055 state->symbols->push_scope(); 7056 7057 if (init_statement != NULL__null) 7058 init_statement->hir(instructions, state); 7059 7060 ir_loop *const stmt = new(ctx) ir_loop(); 7061 instructions->push_tail(stmt); 7062 7063 /* Track the current loop nesting. */ 7064 ast_iteration_statement *nesting_ast = state->loop_nesting_ast; 7065 7066 state->loop_nesting_ast = this; 7067 7068 /* Likewise, indicate that following code is closest to a loop, 7069 * NOT closest to a switch. 7070 */ 7071 bool saved_is_switch_innermost = state->switch_state.is_switch_innermost; 7072 state->switch_state.is_switch_innermost = false; 7073 7074 if (mode != ast_do_while) 7075 condition_to_hir(&stmt->body_instructions, state); 7076 7077 if (body != NULL__null) 7078 body->hir(& stmt->body_instructions, state); 7079 7080 if (rest_expression != NULL__null) 7081 rest_expression->hir(& stmt->body_instructions, state); 7082 7083 if (mode == ast_do_while) 7084 condition_to_hir(&stmt->body_instructions, state); 7085 7086 if (mode != ast_do_while) 7087 state->symbols->pop_scope(); 7088 7089 /* Restore previous nesting before returning. */ 7090 state->loop_nesting_ast = nesting_ast; 7091 state->switch_state.is_switch_innermost = saved_is_switch_innermost; 7092 7093 /* Loops do not have r-values. 7094 */ 7095 return NULL__null; 7096} 7097 7098 7099/** 7100 * Determine if the given type is valid for establishing a default precision 7101 * qualifier. 7102 * 7103 * From GLSL ES 3.00 section 4.5.4 ("Default Precision Qualifiers"): 7104 * 7105 * "The precision statement 7106 * 7107 * precision precision-qualifier type; 7108 * 7109 * can be used to establish a default precision qualifier. The type field 7110 * can be either int or float or any of the sampler types, and the 7111 * precision-qualifier can be lowp, mediump, or highp." 7112 * 7113 * GLSL ES 1.00 has similar language. GLSL 1.30 doesn't allow precision 7114 * qualifiers on sampler types, but this seems like an oversight (since the 7115 * intention of including these in GLSL 1.30 is to allow compatibility with ES 7116 * shaders). So we allow int, float, and all sampler types regardless of GLSL 7117 * version. 7118 */ 7119static bool 7120is_valid_default_precision_type(const struct glsl_type *const type) 7121{ 7122 if (type == NULL__null) 7123 return false; 7124 7125 switch (type->base_type) { 7126 case GLSL_TYPE_INT: 7127 case GLSL_TYPE_FLOAT: 7128 /* "int" and "float" are valid, but vectors and matrices are not. */ 7129 return type->vector_elements == 1 && type->matrix_columns == 1; 7130 case GLSL_TYPE_SAMPLER: 7131 case GLSL_TYPE_IMAGE: 7132 case GLSL_TYPE_ATOMIC_UINT: 7133 return true; 7134 default: 7135 return false; 7136 } 7137} 7138 7139 7140ir_rvalue * 7141ast_type_specifier::hir(exec_list *instructions, 7142 struct _mesa_glsl_parse_state *state) 7143{ 7144 if (this->default_precision == ast_precision_none && this->structure == NULL__null) 7145 return NULL__null; 7146 7147 YYLTYPE loc = this->get_location(); 7148 7149 /* If this is a precision statement, check that the type to which it is 7150 * applied is either float or int. 7151 * 7152 * From section 4.5.3 of the GLSL 1.30 spec: 7153 * "The precision statement 7154 * precision precision-qualifier type; 7155 * can be used to establish a default precision qualifier. The type 7156 * field can be either int or float [...]. Any other types or 7157 * qualifiers will result in an error. 7158 */ 7159 if (this->default_precision != ast_precision_none) { 7160 if (!state->check_precision_qualifiers_allowed(&loc)) 7161 return NULL__null; 7162 7163 if (this->structure != NULL__null) { 7164 _mesa_glsl_error(&loc, state, 7165 "precision qualifiers do not apply to structures"); 7166 return NULL__null; 7167 } 7168 7169 if (this->array_specifier != NULL__null) { 7170 _mesa_glsl_error(&loc, state, 7171 "default precision statements do not apply to " 7172 "arrays"); 7173 return NULL__null; 7174 } 7175 7176 const struct glsl_type *const type = 7177 state->symbols->get_type(this->type_name); 7178 if (!is_valid_default_precision_type(type)) { 7179 _mesa_glsl_error(&loc, state, 7180 "default precision statements apply only to " 7181 "float, int, and opaque types"); 7182 return NULL__null; 7183 } 7184 7185 if (state->es_shader) { 7186 /* Section 4.5.3 (Default Precision Qualifiers) of the GLSL ES 1.00 7187 * spec says: 7188 * 7189 * "Non-precision qualified declarations will use the precision 7190 * qualifier specified in the most recent precision statement 7191 * that is still in scope. The precision statement has the same 7192 * scoping rules as variable declarations. If it is declared 7193 * inside a compound statement, its effect stops at the end of 7194 * the innermost statement it was declared in. Precision 7195 * statements in nested scopes override precision statements in 7196 * outer scopes. Multiple precision statements for the same basic 7197 * type can appear inside the same scope, with later statements 7198 * overriding earlier statements within that scope." 7199 * 7200 * Default precision specifications follow the same scope rules as 7201 * variables. So, we can track the state of the default precision 7202 * qualifiers in the symbol table, and the rules will just work. This 7203 * is a slight abuse of the symbol table, but it has the semantics 7204 * that we want. 7205 */ 7206 state->symbols->add_default_precision_qualifier(this->type_name, 7207 this->default_precision); 7208 } 7209 7210 { 7211 void *ctx = state; 7212 7213 const char* precision_type = NULL__null; 7214 switch (this->default_precision) { 7215 case GLSL_PRECISION_HIGH: 7216 precision_type = "highp"; 7217 break; 7218 case GLSL_PRECISION_MEDIUM: 7219 precision_type = "mediump"; 7220 break; 7221 case GLSL_PRECISION_LOW: 7222 precision_type = "lowp"; 7223 break; 7224 case GLSL_PRECISION_NONE: 7225 precision_type = ""; 7226 break; 7227 } 7228 7229 char* precision_statement = ralloc_asprintf(ctx, "precision %s %s", precision_type, this->type_name); 7230 ir_precision_statement *const stmt = new(ctx) ir_precision_statement(precision_statement); 7231 7232 instructions->push_head(stmt); 7233 } 7234 7235 return NULL__null; 7236 } 7237 7238 /* _mesa_ast_set_aggregate_type() sets the <structure> field so that 7239 * process_record_constructor() can do type-checking on C-style initializer 7240 * expressions of structs, but ast_struct_specifier should only be translated 7241 * to HIR if it is declaring the type of a structure. 7242 * 7243 * The ->is_declaration field is false for initializers of variables 7244 * declared separately from the struct's type definition. 7245 * 7246 * struct S { ... }; (is_declaration = true) 7247 * struct T { ... } t = { ... }; (is_declaration = true) 7248 * S s = { ... }; (is_declaration = false) 7249 */ 7250 if (this->structure != NULL__null && this->structure->is_declaration) 7251 return this->structure->hir(instructions, state); 7252 7253 return NULL__null; 7254} 7255 7256 7257/** 7258 * Process a structure or interface block tree into an array of structure fields 7259 * 7260 * After parsing, where there are some syntax differnces, structures and 7261 * interface blocks are almost identical. They are similar enough that the 7262 * AST for each can be processed the same way into a set of 7263 * \c glsl_struct_field to describe the members. 7264 * 7265 * If we're processing an interface block, var_mode should be the type of the 7266 * interface block (ir_var_shader_in, ir_var_shader_out, ir_var_uniform or 7267 * ir_var_shader_storage). If we're processing a structure, var_mode should be 7268 * ir_var_auto. 7269 * 7270 * \return 7271 * The number of fields processed. A pointer to the array structure fields is 7272 * stored in \c *fields_ret. 7273 */ 7274static unsigned 7275ast_process_struct_or_iface_block_members(exec_list *instructions, 7276 struct _mesa_glsl_parse_state *state, 7277 exec_list *declarations, 7278 glsl_struct_field **fields_ret, 7279 bool is_interface, 7280 enum glsl_matrix_layout matrix_layout, 7281 bool allow_reserved_names, 7282 ir_variable_mode var_mode, 7283 ast_type_qualifier *layout, 7284 unsigned block_stream, 7285 unsigned block_xfb_buffer, 7286 unsigned block_xfb_offset, 7287 unsigned expl_location, 7288 unsigned expl_align) 7289{ 7290 unsigned decl_count = 0; 7291 unsigned next_offset = 0; 7292 7293 /* Make an initial pass over the list of fields to determine how 7294 * many there are. Each element in this list is an ast_declarator_list. 7295 * This means that we actually need to count the number of elements in the 7296 * 'declarations' list in each of the elements. 7297 */ 7298 foreach_list_typed (ast_declarator_list, decl_list, link, declarations)for (ast_declarator_list * decl_list = (!exec_node_is_tail_sentinel
((declarations)->head_sentinel.next) ? ((ast_declarator_list
*) (((uintptr_t) (declarations)->head_sentinel.next) - ((
(char *) &((ast_declarator_list *) (declarations)->head_sentinel
.next)->link) - ((char *) (declarations)->head_sentinel
.next)))) : __null); (decl_list) != __null; (decl_list) = (!exec_node_is_tail_sentinel
((decl_list)->link.next) ? ((ast_declarator_list *) (((uintptr_t
) (decl_list)->link.next) - (((char *) &((ast_declarator_list
*) (decl_list)->link.next)->link) - ((char *) (decl_list
)->link.next)))) : __null)) { 7299 decl_count += decl_list->declarations.length(); 7300 } 7301 7302 /* Allocate storage for the fields and process the field 7303 * declarations. As the declarations are processed, try to also convert 7304 * the types to HIR. This ensures that structure definitions embedded in 7305 * other structure definitions or in interface blocks are processed. 7306 */ 7307 glsl_struct_field *const fields = rzalloc_array(state, glsl_struct_field,((glsl_struct_field *) rzalloc_array_size(state, sizeof(glsl_struct_field
), decl_count)) 7308 decl_count)((glsl_struct_field *) rzalloc_array_size(state, sizeof(glsl_struct_field
), decl_count)); 7309 7310 bool first_member = true; 7311 bool first_member_has_explicit_location = false; 7312 7313 unsigned i = 0; 7314 foreach_list_typed (ast_declarator_list, decl_list, link, declarations)for (ast_declarator_list * decl_list = (!exec_node_is_tail_sentinel
((declarations)->head_sentinel.next) ? ((ast_declarator_list
*) (((uintptr_t) (declarations)->head_sentinel.next) - ((
(char *) &((ast_declarator_list *) (declarations)->head_sentinel
.next)->link) - ((char *) (declarations)->head_sentinel
.next)))) : __null); (decl_list) != __null; (decl_list) = (!exec_node_is_tail_sentinel
((decl_list)->link.next) ? ((ast_declarator_list *) (((uintptr_t
) (decl_list)->link.next) - (((char *) &((ast_declarator_list
*) (decl_list)->link.next)->link) - ((char *) (decl_list
)->link.next)))) : __null)) { 7315 const char *type_name; 7316 YYLTYPE loc = decl_list->get_location(); 7317 7318 decl_list->type->specifier->hir(instructions, state); 7319 7320 /* Section 4.1.8 (Structures) of the GLSL 1.10 spec says: 7321 * 7322 * "Anonymous structures are not supported; so embedded structures 7323 * must have a declarator. A name given to an embedded struct is 7324 * scoped at the same level as the struct it is embedded in." 7325 * 7326 * The same section of the GLSL 1.20 spec says: 7327 * 7328 * "Anonymous structures are not supported. Embedded structures are 7329 * not supported." 7330 * 7331 * The GLSL ES 1.00 and 3.00 specs have similar langauge. So, we allow 7332 * embedded structures in 1.10 only. 7333 */ 7334 if (state->language_version != 110 && 7335 decl_list->type->specifier->structure != NULL__null) 7336 _mesa_glsl_error(&loc, state, 7337 "embedded structure declarations are not allowed"); 7338 7339 const glsl_type *decl_type = 7340 decl_list->type->glsl_type(& type_name, state); 7341 7342 const struct ast_type_qualifier *const qual = 7343 &decl_list->type->qualifier; 7344 7345 /* From section 4.3.9 of the GLSL 4.40 spec: 7346 * 7347 * "[In interface blocks] opaque types are not allowed." 7348 * 7349 * It should be impossible for decl_type to be NULL here. Cases that 7350 * might naturally lead to decl_type being NULL, especially for the 7351 * is_interface case, will have resulted in compilation having 7352 * already halted due to a syntax error. 7353 */ 7354 assert(decl_type)(static_cast <bool> (decl_type) ? void (0) : __assert_fail
("decl_type", __builtin_FILE (), __builtin_LINE (), __extension__
__PRETTY_FUNCTION__)); 7355 7356 if (is_interface) { 7357 /* From section 4.3.7 of the ARB_bindless_texture spec: 7358 * 7359 * "(remove the following bullet from the last list on p. 39, 7360 * thereby permitting sampler types in interface blocks; image 7361 * types are also permitted in blocks by this extension)" 7362 * 7363 * * sampler types are not allowed 7364 */ 7365 if (decl_type->contains_atomic() || 7366 (!state->has_bindless() && decl_type->contains_opaque())) { 7367 _mesa_glsl_error(&loc, state, "uniform/buffer in non-default " 7368 "interface block contains %s variable", 7369 state->has_bindless() ? "atomic" : "opaque"); 7370 } 7371 } else { 7372 if (decl_type->contains_atomic()) { 7373 /* From section 4.1.7.3 of the GLSL 4.40 spec: 7374 * 7375 * "Members of structures cannot be declared as atomic counter 7376 * types." 7377 */ 7378 _mesa_glsl_error(&loc, state, "atomic counter in structure"); 7379 } 7380 7381 if (!state->has_bindless() && decl_type->contains_image()) { 7382 /* FINISHME: Same problem as with atomic counters. 7383 * FINISHME: Request clarification from Khronos and add 7384 * FINISHME: spec quotation here. 7385 */ 7386 _mesa_glsl_error(&loc, state, "image in structure"); 7387 } 7388 } 7389 7390 if (qual->flags.q.explicit_binding) { 7391 _mesa_glsl_error(&loc, state, 7392 "binding layout qualifier cannot be applied " 7393 "to struct or interface block members"); 7394 } 7395 7396 if (is_interface) { 7397 if (!first_member) { 7398 if (!layout->flags.q.explicit_location && 7399 ((first_member_has_explicit_location && 7400 !qual->flags.q.explicit_location) || 7401 (!first_member_has_explicit_location && 7402 qual->flags.q.explicit_location))) { 7403 _mesa_glsl_error(&loc, state, 7404 "when block-level location layout qualifier " 7405 "is not supplied either all members must " 7406 "have a location layout qualifier or all " 7407 "members must not have a location layout " 7408 "qualifier"); 7409 } 7410 } else { 7411 first_member = false; 7412 first_member_has_explicit_location = 7413 qual->flags.q.explicit_location; 7414 } 7415 } 7416 7417 if (qual->flags.q.std140 || 7418 qual->flags.q.std430 || 7419 qual->flags.q.packed || 7420 qual->flags.q.shared) { 7421 _mesa_glsl_error(&loc, state, 7422 "uniform/shader storage block layout qualifiers " 7423 "std140, std430, packed, and shared can only be " 7424 "applied to uniform/shader storage blocks, not " 7425 "members"); 7426 } 7427 7428 if (qual->flags.q.constant) { 7429 _mesa_glsl_error(&loc, state, 7430 "const storage qualifier cannot be applied " 7431 "to struct or interface block members"); 7432 } 7433 7434 validate_memory_qualifier_for_type(state, &loc, qual, decl_type); 7435 validate_image_format_qualifier_for_type(state, &loc, qual, decl_type); 7436 7437 /* From Section 4.4.2.3 (Geometry Outputs) of the GLSL 4.50 spec: 7438 * 7439 * "A block member may be declared with a stream identifier, but 7440 * the specified stream must match the stream associated with the 7441 * containing block." 7442 */ 7443 if (qual->flags.q.explicit_stream) { 7444 unsigned qual_stream; 7445 if (process_qualifier_constant(state, &loc, "stream", 7446 qual->stream, &qual_stream) && 7447 qual_stream != block_stream) { 7448 _mesa_glsl_error(&loc, state, "stream layout qualifier on " 7449 "interface block member does not match " 7450 "the interface block (%u vs %u)", qual_stream, 7451 block_stream); 7452 } 7453 } 7454 7455 int xfb_buffer; 7456 unsigned explicit_xfb_buffer = 0; 7457 if (qual->flags.q.explicit_xfb_buffer) { 7458 unsigned qual_xfb_buffer; 7459 if (process_qualifier_constant(state, &loc, "xfb_buffer", 7460 qual->xfb_buffer, &qual_xfb_buffer)) { 7461 explicit_xfb_buffer = 1; 7462 if (qual_xfb_buffer != block_xfb_buffer) 7463 _mesa_glsl_error(&loc, state, "xfb_buffer layout qualifier on " 7464 "interface block member does not match " 7465 "the interface block (%u vs %u)", 7466 qual_xfb_buffer, block_xfb_buffer); 7467 } 7468 xfb_buffer = (int) qual_xfb_buffer; 7469 } else { 7470 if (layout) 7471 explicit_xfb_buffer = layout->flags.q.explicit_xfb_buffer; 7472 xfb_buffer = (int) block_xfb_buffer; 7473 } 7474 7475 int xfb_stride = -1; 7476 if (qual->flags.q.explicit_xfb_stride) { 7477 unsigned qual_xfb_stride; 7478 if (process_qualifier_constant(state, &loc, "xfb_stride", 7479 qual->xfb_stride, &qual_xfb_stride)) { 7480 xfb_stride = (int) qual_xfb_stride; 7481 } 7482 } 7483 7484 if (qual->flags.q.uniform && qual->has_interpolation()) { 7485 _mesa_glsl_error(&loc, state, 7486 "interpolation qualifiers cannot be used " 7487 "with uniform interface blocks"); 7488 } 7489 7490 if ((qual->flags.q.uniform || !is_interface) && 7491 qual->has_auxiliary_storage()) { 7492 _mesa_glsl_error(&loc, state, 7493 "auxiliary storage qualifiers cannot be used " 7494 "in uniform blocks or structures."); 7495 } 7496 7497 if (qual->flags.q.row_major || qual->flags.q.column_major) { 7498 if (!qual->flags.q.uniform && !qual->flags.q.buffer) { 7499 _mesa_glsl_error(&loc, state, 7500 "row_major and column_major can only be " 7501 "applied to interface blocks"); 7502 } else 7503 validate_matrix_layout_for_type(state, &loc, decl_type, NULL__null); 7504 } 7505 7506 foreach_list_typed (ast_declaration, decl, link,for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
decl_list->declarations)->head_sentinel.next) ? ((ast_declaration
*) (((uintptr_t) (&decl_list->declarations)->head_sentinel
.next) - (((char *) &((ast_declaration *) (&decl_list
->declarations)->head_sentinel.next)->link) - ((char
*) (&decl_list->declarations)->head_sentinel.next)
))) : __null); (decl) != __null; (decl) = (!exec_node_is_tail_sentinel
((decl)->link.next) ? ((ast_declaration *) (((uintptr_t) (
decl)->link.next) - (((char *) &((ast_declaration *) (
decl)->link.next)->link) - ((char *) (decl)->link.next
)))) : __null)) 7507 &decl_list->declarations)for (ast_declaration * decl = (!exec_node_is_tail_sentinel((&
decl_list->declarations)->head_sentinel.next) ? ((ast_declaration
*) (((uintptr_t) (&decl_list->declarations)->head_sentinel
.next) - (((char *) &((ast_declaration *) (&decl_list
->declarations)->head_sentinel.next)->link) - ((char
*) (&decl_list->declarations)->head_sentinel.next)
))) : __null); (decl) != __null; (decl) = (!exec_node_is_tail_sentinel
((decl)->link.next) ? ((ast_declaration *) (((uintptr_t) (
decl)->link.next) - (((char *) &((ast_declaration *) (
decl)->link.next)->link) - ((char *) (decl)->link.next
)))) : __null)) { 7508 YYLTYPE loc = decl->get_location(); 7509 7510 if (!allow_reserved_names) 7511 validate_identifier(decl->identifier, loc, state); 7512 7513 const struct glsl_type *field_type = 7514 process_array_type(&loc, decl_type, decl->array_specifier, state); 7515 validate_array_dimensions(field_type, state, &loc); 7516 fields[i].type = field_type; 7517 fields[i].name = decl->identifier; 7518 fields[i].interpolation = 7519 interpret_interpolation_qualifier(qual, field_type, 7520 var_mode, state, &loc); 7521 fields[i].centroid = qual->flags.q.centroid ? 1 : 0; 7522 fields[i].sample = qual->flags.q.sample ? 1 : 0; 7523 fields[i].patch = qual->flags.q.patch ? 1 : 0; 7524 fields[i].offset = -1; 7525 fields[i].explicit_xfb_buffer = explicit_xfb_buffer; 7526 fields[i].xfb_buffer = xfb_buffer; 7527 fields[i].xfb_stride = xfb_stride; 7528 7529 if (qual->flags.q.explicit_location) { 7530 unsigned qual_location; 7531 if (process_qualifier_constant(state, &loc, "location", 7532 qual->location, &qual_location)) { 7533 fields[i].location = qual_location + 7534 (fields[i].patch ? VARYING_SLOT_PATCH0((VARYING_SLOT_VAR0 + 32)) : VARYING_SLOT_VAR0); 7535 expl_location = fields[i].location + 7536 fields[i].type->count_attribute_slots(false); 7537 } 7538 } else { 7539 if (layout && layout->flags.q.explicit_location) { 7540 fields[i].location = expl_location; 7541 expl_location += fields[i].type->count_attribute_slots(false); 7542 } else { 7543 fields[i].location = -1; 7544 } 7545 } 7546 7547 /* Offset can only be used with std430 and std140 layouts an initial 7548 * value of 0 is used for error detection. 7549 */ 7550 unsigned align = 0; 7551 unsigned size = 0; 7552 if (layout) { 7553 bool row_major; 7554 if (qual->flags.q.row_major || 7555 matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { 7556 row_major = true; 7557 } else { 7558 row_major = false; 7559 } 7560 7561 if(layout->flags.q.std140) { 7562 align = field_type->std140_base_alignment(row_major); 7563 size = field_type->std140_size(row_major); 7564 } else if (layout->flags.q.std430) { 7565 align = field_type->std430_base_alignment(row_major); 7566 size = field_type->std430_size(row_major); 7567 } 7568 } 7569 7570 if (qual->flags.q.explicit_offset) { 7571 unsigned qual_offset; 7572 if (process_qualifier_constant(state, &loc, "offset", 7573 qual->offset, &qual_offset)) { 7574 if (align != 0 && size != 0) { 7575 if (next_offset > qual_offset) 7576 _mesa_glsl_error(&loc, state, "layout qualifier " 7577 "offset overlaps previous member"); 7578 7579 if (qual_offset % align) { 7580 _mesa_glsl_error(&loc, state, "layout qualifier offset " 7581 "must be a multiple of the base " 7582 "alignment of %s", field_type->name); 7583 } 7584 fields[i].offset = qual_offset; 7585 next_offset = qual_offset + size; 7586 } else { 7587 _mesa_glsl_error(&loc, state, "offset can only be used " 7588 "with std430 and std140 layouts"); 7589 } 7590 } 7591 } 7592 7593 if (qual->flags.q.explicit_align || expl_align != 0) { 7594 unsigned offset = fields[i].offset != -1 ? fields[i].offset : 7595 next_offset; 7596 if (align == 0 || size == 0) { 7597 _mesa_glsl_error(&loc, state, "align can only be used with " 7598 "std430 and std140 layouts"); 7599 } else if (qual->flags.q.explicit_align) { 7600 unsigned member_align; 7601 if (process_qualifier_constant(state, &loc, "align", 7602 qual->align, &member_align)) { 7603 if (member_align == 0 || 7604 member_align & (member_align - 1)) { 7605 _mesa_glsl_error(&loc, state, "align layout qualifier " 7606 "is not a power of 2"); 7607 } else { 7608 fields[i].offset = glsl_align(offset, member_align); 7609 next_offset = fields[i].offset + size; 7610 } 7611 } 7612 } else { 7613 fields[i].offset = glsl_align(offset, expl_align); 7614 next_offset = fields[i].offset + size; 7615 } 7616 } else if (!qual->flags.q.explicit_offset) { 7617 if (align != 0 && size != 0) 7618 next_offset = glsl_align(next_offset, align) + size; 7619 } 7620 7621 /* From the ARB_enhanced_layouts spec: 7622 * 7623 * "The given offset applies to the first component of the first 7624 * member of the qualified entity. Then, within the qualified 7625 * entity, subsequent components are each assigned, in order, to 7626 * the next available offset aligned to a multiple of that 7627 * component's size. Aggregate types are flattened down to the 7628 * component level to get this sequence of components." 7629 */ 7630 if (qual->flags.q.explicit_xfb_offset) { 7631 unsigned xfb_offset; 7632 if (process_qualifier_constant(state, &loc, "xfb_offset", 7633 qual->offset, &xfb_offset)) { 7634 fields[i].offset = xfb_offset; 7635 block_xfb_offset = fields[i].offset + 7636 4 * field_type->component_slots(); 7637 } 7638 } else { 7639 if (layout && layout->flags.q.explicit_xfb_offset) { 7640 unsigned align = field_type->is_64bit() ? 8 : 4; 7641 fields[i].offset = glsl_align(block_xfb_offset, align); 7642 block_xfb_offset += 4 * field_type->component_slots(); 7643 } 7644 } 7645 7646 /* Propogate row- / column-major information down the fields of the 7647 * structure or interface block. Structures need this data because 7648 * the structure may contain a structure that contains ... a matrix 7649 * that need the proper layout. 7650 */ 7651 if (is_interface && layout && 7652 (layout->flags.q.uniform || layout->flags.q.buffer) && 7653 (field_type->without_array()->is_matrix() 7654 || field_type->without_array()->is_struct())) { 7655 /* If no layout is specified for the field, inherit the layout 7656 * from the block. 7657 */ 7658 fields[i].matrix_layout = matrix_layout; 7659 7660 if (qual->flags.q.row_major) 7661 fields[i].matrix_layout = GLSL_MATRIX_LAYOUT_ROW_MAJOR; 7662 else if (qual->flags.q.column_major) 7663 fields[i].matrix_layout = GLSL_MATRIX_LAYOUT_COLUMN_MAJOR; 7664 7665 /* If we're processing an uniform or buffer block, the matrix 7666 * layout must be decided by this point. 7667 */ 7668 assert(fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR(static_cast <bool> (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR
|| fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR
) ? void (0) : __assert_fail ("fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR || fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)) 7669 || fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR)(static_cast <bool> (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR
|| fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR
) ? void (0) : __assert_fail ("fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR || fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 7670 } 7671 7672 /* Memory qualifiers are allowed on buffer and image variables, while 7673 * the format qualifier is only accepted for images. 7674 */ 7675 if (var_mode == ir_var_shader_storage || 7676 field_type->without_array()->is_image()) { 7677 /* For readonly and writeonly qualifiers the field definition, 7678 * if set, overwrites the layout qualifier. 7679 */ 7680 if (qual->flags.q.read_only || qual->flags.q.write_only) { 7681 fields[i].memory_read_only = qual->flags.q.read_only; 7682 fields[i].memory_write_only = qual->flags.q.write_only; 7683 } else { 7684 fields[i].memory_read_only = 7685 layout ? layout->flags.q.read_only : 0; 7686 fields[i].memory_write_only = 7687 layout ? layout->flags.q.write_only : 0; 7688 } 7689 7690 /* For other qualifiers, we set the flag if either the layout 7691 * qualifier or the field qualifier are set 7692 */ 7693 fields[i].memory_coherent = qual->flags.q.coherent || 7694 (layout && layout->flags.q.coherent); 7695 fields[i].memory_volatile = qual->flags.q._volatile || 7696 (layout && layout->flags.q._volatile); 7697 fields[i].memory_restrict = qual->flags.q.restrict_flag || 7698 (layout && layout->flags.q.restrict_flag); 7699 7700 if (field_type->without_array()->is_image()) { 7701 if (qual->flags.q.explicit_image_format) { 7702 if (qual->image_base_type != 7703 field_type->without_array()->sampled_type) { 7704 _mesa_glsl_error(&loc, state, "format qualifier doesn't " 7705 "match the base data type of the image"); 7706 } 7707 7708 fields[i].image_format = qual->image_format; 7709 } else { 7710 if (!qual->flags.q.write_only) { 7711 _mesa_glsl_error(&loc, state, "image not qualified with " 7712 "`writeonly' must have a format layout " 7713 "qualifier"); 7714 } 7715 7716 fields[i].image_format = PIPE_FORMAT_NONE; 7717 } 7718 } 7719 } 7720 7721 /* Precision qualifiers do not hold any meaning in Desktop GLSL */ 7722 if (state->es_shader) { 7723 fields[i].precision = select_gles_precision(qual->precision, 7724 field_type, 7725 state, 7726 &loc); 7727 } else { 7728 fields[i].precision = qual->precision; 7729 } 7730 7731 i++; 7732 } 7733 } 7734 7735 assert(i == decl_count)(static_cast <bool> (i == decl_count) ? void (0) : __assert_fail
("i == decl_count", __builtin_FILE (), __builtin_LINE (), __extension__
__PRETTY_FUNCTION__)); 7736 7737 *fields_ret = fields; 7738 return decl_count; 7739} 7740 7741 7742ir_rvalue * 7743ast_struct_specifier::hir(exec_list *instructions, 7744 struct _mesa_glsl_parse_state *state) 7745{ 7746 YYLTYPE loc = this->get_location(); 7747 7748 unsigned expl_location = 0; 7749 if (layout && layout->flags.q.explicit_location) { 7750 if (!process_qualifier_constant(state, &loc, "location", 7751 layout->location, &expl_location)) { 7752 return NULL__null; 7753 } else { 7754 expl_location = VARYING_SLOT_VAR0 + expl_location; 7755 } 7756 } 7757 7758 glsl_struct_field *fields; 7759 unsigned decl_count = 7760 ast_process_struct_or_iface_block_members(instructions, 7761 state, 7762 &this->declarations, 7763 &fields, 7764 false, 7765 GLSL_MATRIX_LAYOUT_INHERITED, 7766 false /* allow_reserved_names */, 7767 ir_var_auto, 7768 layout, 7769 0, /* for interface only */ 7770 0, /* for interface only */ 7771 0, /* for interface only */ 7772 expl_location, 7773 0 /* for interface only */); 7774 7775 validate_identifier(this->name, loc, state); 7776 7777 type = glsl_type::get_struct_instance(fields, decl_count, this->name); 7778 7779 if (!type->is_anonymous() && !state->symbols->add_type(name, type)) { 7780 const glsl_type *match = state->symbols->get_type(name); 7781 /* allow struct matching for desktop GL - older UE4 does this */ 7782 if (match != NULL__null && state->is_version(130, 0) && match->record_compare(type, true, false)) 7783 _mesa_glsl_warning(& loc, state, "struct `%s' previously defined", name); 7784 else 7785 _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name); 7786 } else { 7787 const glsl_type **s = reralloc(state, state->user_structures,((const glsl_type * *) reralloc_array_size(state, state->user_structures
, sizeof(const glsl_type *), state->num_user_structures + 1
)) 7788 const glsl_type *,((const glsl_type * *) reralloc_array_size(state, state->user_structures
, sizeof(const glsl_type *), state->num_user_structures + 1
)) 7789 state->num_user_structures + 1)((const glsl_type * *) reralloc_array_size(state, state->user_structures
, sizeof(const glsl_type *), state->num_user_structures + 1
)); 7790 if (s != NULL__null) { 7791 s[state->num_user_structures] = type; 7792 state->user_structures = s; 7793 state->num_user_structures++; 7794 7795 ir_typedecl_statement* stmt = new(state) ir_typedecl_statement(type); 7796 /* Push the struct declarations to the top. 7797 * However, do not insert declarations before default precision 7798 * statements or other declarations 7799 */ 7800 ir_instruction* before_node = (ir_instruction*)instructions->get_head(); 7801 while (before_node && 7802 (before_node->ir_type == ir_type_precision || 7803 before_node->ir_type == ir_type_typedecl)) 7804 before_node = (ir_instruction*)before_node->next; 7805 if (before_node) 7806 before_node->insert_before(stmt); 7807 else 7808 instructions->push_head(stmt); 7809 } 7810 } 7811 7812 /* Structure type definitions do not have r-values. 7813 */ 7814 return NULL__null; 7815} 7816 7817 7818/** 7819 * Visitor class which detects whether a given interface block has been used. 7820 */ 7821class interface_block_usage_visitor : public ir_hierarchical_visitor 7822{ 7823public: 7824 interface_block_usage_visitor(ir_variable_mode mode, const glsl_type *block) 7825 : mode(mode), block(block), found(false) 7826 { 7827 } 7828 7829 virtual ir_visitor_status visit(ir_dereference_variable *ir) 7830 { 7831 if (ir->var->data.mode == mode && ir->var->get_interface_type() == block) { 7832 found = true; 7833 return visit_stop; 7834 } 7835 return visit_continue; 7836 } 7837 7838 bool usage_found() const 7839 { 7840 return this->found; 7841 } 7842 7843private: 7844 ir_variable_mode mode; 7845 const glsl_type *block; 7846 bool found; 7847}; 7848 7849static bool 7850is_unsized_array_last_element(ir_variable *v) 7851{ 7852 const glsl_type *interface_type = v->get_interface_type(); 7853 int length = interface_type->length; 7854 7855 assert(v->type->is_unsized_array())(static_cast <bool> (v->type->is_unsized_array())
? void (0) : __assert_fail ("v->type->is_unsized_array()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 7856 7857 /* Check if it is the last element of the interface */ 7858 if (strcmp(interface_type->fields.structure[length-1].name, v->name) == 0) 7859 return true; 7860 return false; 7861} 7862 7863static void 7864apply_memory_qualifiers(ir_variable *var, glsl_struct_field field) 7865{ 7866 var->data.memory_read_only = field.memory_read_only; 7867 var->data.memory_write_only = field.memory_write_only; 7868 var->data.memory_coherent = field.memory_coherent; 7869 var->data.memory_volatile = field.memory_volatile; 7870 var->data.memory_restrict = field.memory_restrict; 7871} 7872 7873ir_rvalue * 7874ast_interface_block::hir(exec_list *instructions, 7875 struct _mesa_glsl_parse_state *state) 7876{ 7877 YYLTYPE loc = this->get_location(); 7878 7879 /* Interface blocks must be declared at global scope */ 7880 if (state->current_function != NULL__null) { 7881 _mesa_glsl_error(&loc, state, 7882 "Interface block `%s' must be declared " 7883 "at global scope", 7884 this->block_name); 7885 } 7886 7887 /* Validate qualifiers: 7888 * 7889 * - Layout Qualifiers as per the table in Section 4.4 7890 * ("Layout Qualifiers") of the GLSL 4.50 spec. 7891 * 7892 * - Memory Qualifiers as per Section 4.10 ("Memory Qualifiers") of the 7893 * GLSL 4.50 spec: 7894 * 7895 * "Additionally, memory qualifiers may also be used in the declaration 7896 * of shader storage blocks" 7897 * 7898 * Note the table in Section 4.4 says std430 is allowed on both uniform and 7899 * buffer blocks however Section 4.4.5 (Uniform and Shader Storage Block 7900 * Layout Qualifiers) of the GLSL 4.50 spec says: 7901 * 7902 * "The std430 qualifier is supported only for shader storage blocks; 7903 * using std430 on a uniform block will result in a compile-time error." 7904 */ 7905 ast_type_qualifier allowed_blk_qualifiers; 7906 allowed_blk_qualifiers.flags.i = 0; 7907 if (this->layout.flags.q.buffer || this->layout.flags.q.uniform) { 7908 allowed_blk_qualifiers.flags.q.shared = 1; 7909 allowed_blk_qualifiers.flags.q.packed = 1; 7910 allowed_blk_qualifiers.flags.q.std140 = 1; 7911 allowed_blk_qualifiers.flags.q.row_major = 1; 7912 allowed_blk_qualifiers.flags.q.column_major = 1; 7913 allowed_blk_qualifiers.flags.q.explicit_align = 1; 7914 allowed_blk_qualifiers.flags.q.explicit_binding = 1; 7915 if (this->layout.flags.q.buffer) { 7916 allowed_blk_qualifiers.flags.q.buffer = 1; 7917 allowed_blk_qualifiers.flags.q.std430 = 1; 7918 allowed_blk_qualifiers.flags.q.coherent = 1; 7919 allowed_blk_qualifiers.flags.q._volatile = 1; 7920 allowed_blk_qualifiers.flags.q.restrict_flag = 1; 7921 allowed_blk_qualifiers.flags.q.read_only = 1; 7922 allowed_blk_qualifiers.flags.q.write_only = 1; 7923 } else { 7924 allowed_blk_qualifiers.flags.q.uniform = 1; 7925 } 7926 } else { 7927 /* Interface block */ 7928 assert(this->layout.flags.q.in || this->layout.flags.q.out)(static_cast <bool> (this->layout.flags.q.in || this
->layout.flags.q.out) ? void (0) : __assert_fail ("this->layout.flags.q.in || this->layout.flags.q.out"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 7929 7930 allowed_blk_qualifiers.flags.q.explicit_location = 1; 7931 if (this->layout.flags.q.out) { 7932 allowed_blk_qualifiers.flags.q.out = 1; 7933 if (state->stage == MESA_SHADER_GEOMETRY || 7934 state->stage == MESA_SHADER_TESS_CTRL || 7935 state->stage == MESA_SHADER_TESS_EVAL || 7936 state->stage == MESA_SHADER_VERTEX ) { 7937 allowed_blk_qualifiers.flags.q.explicit_xfb_offset = 1; 7938 allowed_blk_qualifiers.flags.q.explicit_xfb_buffer = 1; 7939 allowed_blk_qualifiers.flags.q.xfb_buffer = 1; 7940 allowed_blk_qualifiers.flags.q.explicit_xfb_stride = 1; 7941 allowed_blk_qualifiers.flags.q.xfb_stride = 1; 7942 if (state->stage == MESA_SHADER_GEOMETRY) { 7943 allowed_blk_qualifiers.flags.q.stream = 1; 7944 allowed_blk_qualifiers.flags.q.explicit_stream = 1; 7945 } 7946 if (state->stage == MESA_SHADER_TESS_CTRL) { 7947 allowed_blk_qualifiers.flags.q.patch = 1; 7948 } 7949 } 7950 } else { 7951 allowed_blk_qualifiers.flags.q.in = 1; 7952 if (state->stage == MESA_SHADER_TESS_EVAL) { 7953 allowed_blk_qualifiers.flags.q.patch = 1; 7954 } 7955 } 7956 } 7957 7958 this->layout.validate_flags(&loc, state, allowed_blk_qualifiers, 7959 "invalid qualifier for block", 7960 this->block_name); 7961 7962 enum glsl_interface_packing packing; 7963 if (this->layout.flags.q.std140) { 7964 packing = GLSL_INTERFACE_PACKING_STD140; 7965 } else if (this->layout.flags.q.packed) { 7966 packing = GLSL_INTERFACE_PACKING_PACKED; 7967 } else if (this->layout.flags.q.std430) { 7968 packing = GLSL_INTERFACE_PACKING_STD430; 7969 } else { 7970 /* The default layout is shared. 7971 */ 7972 packing = GLSL_INTERFACE_PACKING_SHARED; 7973 } 7974 7975 ir_variable_mode var_mode; 7976 const char *iface_type_name; 7977 if (this->layout.flags.q.in) { 7978 var_mode = ir_var_shader_in; 7979 iface_type_name = "in"; 7980 } else if (this->layout.flags.q.out) { 7981 var_mode = ir_var_shader_out; 7982 iface_type_name = "out"; 7983 } else if (this->layout.flags.q.uniform) { 7984 var_mode = ir_var_uniform; 7985 iface_type_name = "uniform"; 7986 } else if (this->layout.flags.q.buffer) { 7987 var_mode = ir_var_shader_storage; 7988 iface_type_name = "buffer"; 7989 } else { 7990 var_mode = ir_var_auto; 7991 iface_type_name = "UNKNOWN"; 7992 assert(!"interface block layout qualifier not found!")(static_cast <bool> (!"interface block layout qualifier not found!"
) ? void (0) : __assert_fail ("!\"interface block layout qualifier not found!\""
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 7993 } 7994 7995 enum glsl_matrix_layout matrix_layout = GLSL_MATRIX_LAYOUT_INHERITED; 7996 if (this->layout.flags.q.row_major) 7997 matrix_layout = GLSL_MATRIX_LAYOUT_ROW_MAJOR; 7998 else if (this->layout.flags.q.column_major) 7999 matrix_layout = GLSL_MATRIX_LAYOUT_COLUMN_MAJOR; 8000 8001 bool redeclaring_per_vertex = strcmp(this->block_name, "gl_PerVertex") == 0; 8002 exec_list declared_variables; 8003 glsl_struct_field *fields; 8004 8005 /* For blocks that accept memory qualifiers (i.e. shader storage), verify 8006 * that we don't have incompatible qualifiers 8007 */ 8008 if (this->layout.flags.q.read_only && this->layout.flags.q.write_only) { 8009 _mesa_glsl_error(&loc, state, 8010 "Interface block sets both readonly and writeonly"); 8011 } 8012 8013 unsigned qual_stream; 8014 if (!process_qualifier_constant(state, &loc, "stream", this->layout.stream, 8015 &qual_stream) || 8016 !validate_stream_qualifier(&loc, state, qual_stream)) { 8017 /* If the stream qualifier is invalid it doesn't make sense to continue 8018 * on and try to compare stream layouts on member variables against it 8019 * so just return early. 8020 */ 8021 return NULL__null; 8022 } 8023 8024 unsigned qual_xfb_buffer; 8025 if (!process_qualifier_constant(state, &loc, "xfb_buffer", 8026 layout.xfb_buffer, &qual_xfb_buffer) || 8027 !validate_xfb_buffer_qualifier(&loc, state, qual_xfb_buffer)) { 8028 return NULL__null; 8029 } 8030 8031 unsigned qual_xfb_offset; 8032 if (layout.flags.q.explicit_xfb_offset) { 8033 if (!process_qualifier_constant(state, &loc, "xfb_offset", 8034 layout.offset, &qual_xfb_offset)) { 8035 return NULL__null; 8036 } 8037 } 8038 8039 unsigned qual_xfb_stride; 8040 if (layout.flags.q.explicit_xfb_stride) { 8041 if (!process_qualifier_constant(state, &loc, "xfb_stride", 8042 layout.xfb_stride, &qual_xfb_stride)) { 8043 return NULL__null; 8044 } 8045 } 8046 8047 unsigned expl_location = 0; 8048 if (layout.flags.q.explicit_location) { 8049 if (!process_qualifier_constant(state, &loc, "location", 8050 layout.location, &expl_location)) { 8051 return NULL__null; 8052 } else { 8053 expl_location += this->layout.flags.q.patch ? VARYING_SLOT_PATCH0((VARYING_SLOT_VAR0 + 32)) 8054 : VARYING_SLOT_VAR0; 8055 } 8056 } 8057 8058 unsigned expl_align = 0; 8059 if (layout.flags.q.explicit_align) { 8060 if (!process_qualifier_constant(state, &loc, "align", 8061 layout.align, &expl_align)) { 8062 return NULL__null; 8063 } else { 8064 if (expl_align == 0 || expl_align & (expl_align - 1)) { 8065 _mesa_glsl_error(&loc, state, "align layout qualifier is not a " 8066 "power of 2."); 8067 return NULL__null; 8068 } 8069 } 8070 } 8071 8072 unsigned int num_variables = 8073 ast_process_struct_or_iface_block_members(&declared_variables, 8074 state, 8075 &this->declarations, 8076 &fields, 8077 true, 8078 matrix_layout, 8079 redeclaring_per_vertex, 8080 var_mode, 8081 &this->layout, 8082 qual_stream, 8083 qual_xfb_buffer, 8084 qual_xfb_offset, 8085 expl_location, 8086 expl_align); 8087 8088 if (!redeclaring_per_vertex) { 8089 validate_identifier(this->block_name, loc, state); 8090 8091 /* From section 4.3.9 ("Interface Blocks") of the GLSL 4.50 spec: 8092 * 8093 * "Block names have no other use within a shader beyond interface 8094 * matching; it is a compile-time error to use a block name at global 8095 * scope for anything other than as a block name." 8096 */ 8097 ir_variable *var = state->symbols->get_variable(this->block_name); 8098 if (var && !var->type->is_interface()) { 8099 _mesa_glsl_error(&loc, state, "Block name `%s' is " 8100 "already used in the scope.", 8101 this->block_name); 8102 } 8103 } 8104 8105 const glsl_type *earlier_per_vertex = NULL__null; 8106 if (redeclaring_per_vertex) { 8107 /* Find the previous declaration of gl_PerVertex. If we're redeclaring 8108 * the named interface block gl_in, we can find it by looking at the 8109 * previous declaration of gl_in. Otherwise we can find it by looking 8110 * at the previous decalartion of any of the built-in outputs, 8111 * e.g. gl_Position. 8112 * 8113 * Also check that the instance name and array-ness of the redeclaration 8114 * are correct. 8115 */ 8116 switch (var_mode) { 8117 case ir_var_shader_in: 8118 if (ir_variable *earlier_gl_in = 8119 state->symbols->get_variable("gl_in")) { 8120 earlier_per_vertex = earlier_gl_in->get_interface_type(); 8121 } else { 8122 _mesa_glsl_error(&loc, state, 8123 "redeclaration of gl_PerVertex input not allowed " 8124 "in the %s shader", 8125 _mesa_shader_stage_to_string(state->stage)); 8126 } 8127 if (this->instance_name == NULL__null || 8128 strcmp(this->instance_name, "gl_in") != 0 || this->array_specifier == NULL__null || 8129 !this->array_specifier->is_single_dimension()) { 8130 _mesa_glsl_error(&loc, state, 8131 "gl_PerVertex input must be redeclared as " 8132 "gl_in[]"); 8133 } 8134 break; 8135 case ir_var_shader_out: 8136 if (ir_variable *earlier_gl_Position = 8137 state->symbols->get_variable("gl_Position")) { 8138 earlier_per_vertex = earlier_gl_Position->get_interface_type(); 8139 } else if (ir_variable *earlier_gl_out = 8140 state->symbols->get_variable("gl_out")) { 8141 earlier_per_vertex = earlier_gl_out->get_interface_type(); 8142 } else { 8143 _mesa_glsl_error(&loc, state, 8144 "redeclaration of gl_PerVertex output not " 8145 "allowed in the %s shader", 8146 _mesa_shader_stage_to_string(state->stage)); 8147 } 8148 if (state->stage == MESA_SHADER_TESS_CTRL) { 8149 if (this->instance_name == NULL__null || 8150 strcmp(this->instance_name, "gl_out") != 0 || this->array_specifier == NULL__null) { 8151 _mesa_glsl_error(&loc, state, 8152 "gl_PerVertex output must be redeclared as " 8153 "gl_out[]"); 8154 } 8155 } else { 8156 if (this->instance_name != NULL__null) { 8157 _mesa_glsl_error(&loc, state, 8158 "gl_PerVertex output may not be redeclared with " 8159 "an instance name"); 8160 } 8161 } 8162 break; 8163 default: 8164 _mesa_glsl_error(&loc, state, 8165 "gl_PerVertex must be declared as an input or an " 8166 "output"); 8167 break; 8168 } 8169 8170 if (earlier_per_vertex == NULL__null) { 8171 /* An error has already been reported. Bail out to avoid null 8172 * dereferences later in this function. 8173 */ 8174 return NULL__null; 8175 } 8176 8177 /* Copy locations from the old gl_PerVertex interface block. */ 8178 for (unsigned i = 0; i < num_variables; i++) { 8179 int j = earlier_per_vertex->field_index(fields[i].name); 8180 if (j == -1) { 8181 _mesa_glsl_error(&loc, state, 8182 "redeclaration of gl_PerVertex must be a subset " 8183 "of the built-in members of gl_PerVertex"); 8184 } else { 8185 fields[i].location = 8186 earlier_per_vertex->fields.structure[j].location; 8187 fields[i].offset = 8188 earlier_per_vertex->fields.structure[j].offset; 8189 fields[i].interpolation = 8190 earlier_per_vertex->fields.structure[j].interpolation; 8191 fields[i].centroid = 8192 earlier_per_vertex->fields.structure[j].centroid; 8193 fields[i].sample = 8194 earlier_per_vertex->fields.structure[j].sample; 8195 fields[i].patch = 8196 earlier_per_vertex->fields.structure[j].patch; 8197 fields[i].precision = 8198 earlier_per_vertex->fields.structure[j].precision; 8199 fields[i].explicit_xfb_buffer = 8200 earlier_per_vertex->fields.structure[j].explicit_xfb_buffer; 8201 fields[i].xfb_buffer = 8202 earlier_per_vertex->fields.structure[j].xfb_buffer; 8203 fields[i].xfb_stride = 8204 earlier_per_vertex->fields.structure[j].xfb_stride; 8205 } 8206 } 8207 8208 /* From section 7.1 ("Built-in Language Variables") of the GLSL 4.10 8209 * spec: 8210 * 8211 * If a built-in interface block is redeclared, it must appear in 8212 * the shader before any use of any member included in the built-in 8213 * declaration, or a compilation error will result. 8214 * 8215 * This appears to be a clarification to the behaviour established for 8216 * gl_PerVertex by GLSL 1.50, therefore we implement this behaviour 8217 * regardless of GLSL version. 8218 */ 8219 interface_block_usage_visitor v(var_mode, earlier_per_vertex); 8220 v.run(instructions); 8221 if (v.usage_found()) { 8222 _mesa_glsl_error(&loc, state, 8223 "redeclaration of a built-in interface block must " 8224 "appear before any use of any member of the " 8225 "interface block"); 8226 } 8227 } 8228 8229 const glsl_type *block_type = 8230 glsl_type::get_interface_instance(fields, 8231 num_variables, 8232 packing, 8233 matrix_layout == 8234 GLSL_MATRIX_LAYOUT_ROW_MAJOR, 8235 this->block_name); 8236 8237 unsigned component_size = block_type->contains_double() ? 8 : 4; 8238 int xfb_offset = 8239 layout.flags.q.explicit_xfb_offset ? (int) qual_xfb_offset : -1; 8240 validate_xfb_offset_qualifier(&loc, state, xfb_offset, block_type, 8241 component_size); 8242 8243 if (!state->symbols->add_interface(block_type->name, block_type, var_mode)) { 8244 YYLTYPE loc = this->get_location(); 8245 _mesa_glsl_error(&loc, state, "interface block `%s' with type `%s' " 8246 "already taken in the current scope", 8247 this->block_name, iface_type_name); 8248 } 8249 8250 /* Since interface blocks cannot contain statements, it should be 8251 * impossible for the block to generate any instructions. 8252 */ 8253 assert(declared_variables.is_empty())(static_cast <bool> (declared_variables.is_empty()) ? void
(0) : __assert_fail ("declared_variables.is_empty()", __builtin_FILE
(), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); 8254 8255 /* From section 4.3.4 (Inputs) of the GLSL 1.50 spec: 8256 * 8257 * Geometry shader input variables get the per-vertex values written 8258 * out by vertex shader output variables of the same names. Since a 8259 * geometry shader operates on a set of vertices, each input varying 8260 * variable (or input block, see interface blocks below) needs to be 8261 * declared as an array. 8262 */ 8263 if (state->stage == MESA_SHADER_GEOMETRY && this->array_specifier == NULL__null && 8264 var_mode == ir_var_shader_in) { 8265 _mesa_glsl_error(&loc, state, "geometry shader inputs must be arrays"); 8266 } else if ((state->stage == MESA_SHADER_TESS_CTRL || 8267 state->stage == MESA_SHADER_TESS_EVAL) && 8268 !this->layout.flags.q.patch && 8269 this->array_specifier == NULL__null && 8270 var_mode == ir_var_shader_in) { 8271 _mesa_glsl_error(&loc, state, "per-vertex tessellation shader inputs must be arrays"); 8272 } else if (state->stage == MESA_SHADER_TESS_CTRL && 8273 !this->layout.flags.q.patch && 8274 this->array_specifier == NULL__null && 8275 var_mode == ir_var_shader_out) { 8276 _mesa_glsl_error(&loc, state, "tessellation control shader outputs must be arrays"); 8277 } 8278 8279 8280 ir_typedecl_statement* stmt = new(state) ir_typedecl_statement(block_type); 8281 /* Push the interface declarations to the top. 8282 * However, do not insert declarations before default precision 8283 * statements or other declarations 8284 */ 8285 ir_instruction* before_node = (ir_instruction*)instructions->get_head(); 8286 while (before_node && 8287 (before_node->ir_type == ir_type_precision || 8288 before_node->ir_type == ir_type_typedecl)) 8289 before_node = (ir_instruction*)before_node->next; 8290 if (before_node) 8291 before_node->insert_before(stmt); 8292 else 8293 instructions->push_head(stmt); 8294 8295 /* Page 39 (page 45 of the PDF) of section 4.3.7 in the GLSL ES 3.00 spec 8296 * says: 8297 * 8298 * "If an instance name (instance-name) is used, then it puts all the 8299 * members inside a scope within its own name space, accessed with the 8300 * field selector ( . ) operator (analogously to structures)." 8301 */ 8302 if (this->instance_name) { 8303 if (redeclaring_per_vertex) { 8304 /* When a built-in in an unnamed interface block is redeclared, 8305 * get_variable_being_redeclared() calls 8306 * check_builtin_array_max_size() to make sure that built-in array 8307 * variables aren't redeclared to illegal sizes. But we're looking 8308 * at a redeclaration of a named built-in interface block. So we 8309 * have to manually call check_builtin_array_max_size() for all parts 8310 * of the interface that are arrays. 8311 */ 8312 for (unsigned i = 0; i < num_variables; i++) { 8313 if (fields[i].type->is_array()) { 8314 const unsigned size = fields[i].type->array_size(); 8315 check_builtin_array_max_size(fields[i].name, size, loc, state); 8316 } 8317 } 8318 } else { 8319 validate_identifier(this->instance_name, loc, state); 8320 } 8321 8322 ir_variable *var; 8323 8324 if (this->array_specifier != NULL__null) { 8325 const glsl_type *block_array_type = 8326 process_array_type(&loc, block_type, this->array_specifier, state); 8327 8328 /* Section 4.3.7 (Interface Blocks) of the GLSL 1.50 spec says: 8329 * 8330 * For uniform blocks declared an array, each individual array 8331 * element corresponds to a separate buffer object backing one 8332 * instance of the block. As the array size indicates the number 8333 * of buffer objects needed, uniform block array declarations 8334 * must specify an array size. 8335 * 8336 * And a few paragraphs later: 8337 * 8338 * Geometry shader input blocks must be declared as arrays and 8339 * follow the array declaration and linking rules for all 8340 * geometry shader inputs. All other input and output block 8341 * arrays must specify an array size. 8342 * 8343 * The same applies to tessellation shaders. 8344 * 8345 * The upshot of this is that the only circumstance where an 8346 * interface array size *doesn't* need to be specified is on a 8347 * geometry shader input, tessellation control shader input, 8348 * tessellation control shader output, and tessellation evaluation 8349 * shader input. 8350 */ 8351 if (block_array_type->is_unsized_array()) { 8352 bool allow_inputs = state->stage == MESA_SHADER_GEOMETRY || 8353 state->stage == MESA_SHADER_TESS_CTRL || 8354 state->stage == MESA_SHADER_TESS_EVAL; 8355 bool allow_outputs = state->stage == MESA_SHADER_TESS_CTRL; 8356 8357 if (this->layout.flags.q.in) { 8358 if (!allow_inputs) 8359 _mesa_glsl_error(&loc, state, 8360 "unsized input block arrays not allowed in " 8361 "%s shader", 8362 _mesa_shader_stage_to_string(state->stage)); 8363 } else if (this->layout.flags.q.out) { 8364 if (!allow_outputs) 8365 _mesa_glsl_error(&loc, state, 8366 "unsized output block arrays not allowed in " 8367 "%s shader", 8368 _mesa_shader_stage_to_string(state->stage)); 8369 } else { 8370 /* by elimination, this is a uniform block array */ 8371 _mesa_glsl_error(&loc, state, 8372 "unsized uniform block arrays not allowed in " 8373 "%s shader", 8374 _mesa_shader_stage_to_string(state->stage)); 8375 } 8376 } 8377 8378 /* From section 4.3.9 (Interface Blocks) of the GLSL ES 3.10 spec: 8379 * 8380 * * Arrays of arrays of blocks are not allowed 8381 */ 8382 if (state->es_shader && block_array_type->is_array() && 8383 block_array_type->fields.array->is_array()) { 8384 _mesa_glsl_error(&loc, state, 8385 "arrays of arrays interface blocks are " 8386 "not allowed"); 8387 } 8388 8389 var = new(state) ir_variable(block_array_type, 8390 this->instance_name, 8391 var_mode); 8392 } else { 8393 var = new(state) ir_variable(block_type, 8394 this->instance_name, 8395 var_mode); 8396 } 8397 8398 var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED 8399 ? GLSL_MATRIX_LAYOUT_COLUMN_MAJOR : matrix_layout; 8400 8401 if (var_mode == ir_var_shader_in || var_mode == ir_var_uniform) 8402 var->data.read_only = true; 8403 8404 var->data.patch = this->layout.flags.q.patch; 8405 8406 if (state->stage == MESA_SHADER_GEOMETRY && var_mode == ir_var_shader_in) 8407 handle_geometry_shader_input_decl(state, loc, var); 8408 else if ((state->stage == MESA_SHADER_TESS_CTRL || 8409 state->stage == MESA_SHADER_TESS_EVAL) && var_mode == ir_var_shader_in) 8410 handle_tess_shader_input_decl(state, loc, var); 8411 else if (state->stage == MESA_SHADER_TESS_CTRL && var_mode == ir_var_shader_out) 8412 handle_tess_ctrl_shader_output_decl(state, loc, var); 8413 8414 for (unsigned i = 0; i < num_variables; i++) { 8415 if (var->data.mode == ir_var_shader_storage) 8416 apply_memory_qualifiers(var, fields[i]); 8417 } 8418 8419 if (ir_variable *earlier = 8420 state->symbols->get_variable(this->instance_name)) { 8421 if (!redeclaring_per_vertex) { 8422 _mesa_glsl_error(&loc, state, "`%s' redeclared", 8423 this->instance_name); 8424 } 8425 earlier->data.how_declared = ir_var_declared_normally; 8426 earlier->type = var->type; 8427 earlier->reinit_interface_type(block_type); 8428 delete var; 8429 } else { 8430 if (this->layout.flags.q.explicit_binding) { 8431 apply_explicit_binding(state, &loc, var, var->type, 8432 &this->layout); 8433 } 8434 8435 var->data.stream = qual_stream; 8436 if (layout.flags.q.explicit_location) { 8437 var->data.location = expl_location; 8438 var->data.explicit_location = true; 8439 } 8440 8441 state->symbols->add_variable(var); 8442 instructions->push_tail(var); 8443 } 8444 } else { 8445 /* In order to have an array size, the block must also be declared with 8446 * an instance name. 8447 */ 8448 assert(this->array_specifier == NULL)(static_cast <bool> (this->array_specifier == __null
) ? void (0) : __assert_fail ("this->array_specifier == NULL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 8449 8450 for (unsigned i = 0; i < num_variables; i++) { 8451 ir_variable *var = 8452 new(state) ir_variable(fields[i].type, 8453 ralloc_strdup(state, fields[i].name), 8454 var_mode); 8455 var->data.interpolation = fields[i].interpolation; 8456 var->data.centroid = fields[i].centroid; 8457 var->data.sample = fields[i].sample; 8458 var->data.patch = fields[i].patch; 8459 var->data.stream = qual_stream; 8460 var->data.location = fields[i].location; 8461 8462 if (fields[i].location != -1) 8463 var->data.explicit_location = true; 8464 8465 var->data.explicit_xfb_buffer = fields[i].explicit_xfb_buffer; 8466 var->data.xfb_buffer = fields[i].xfb_buffer; 8467 8468 if (fields[i].offset != -1) 8469 var->data.explicit_xfb_offset = true; 8470 var->data.offset = fields[i].offset; 8471 8472 var->init_interface_type(block_type); 8473 8474 if (var_mode == ir_var_shader_in || var_mode == ir_var_uniform) 8475 var->data.read_only = true; 8476 8477 /* Precision qualifiers do not have any meaning in Desktop GLSL */ 8478 if (state->es_shader) { 8479 var->data.precision = 8480 select_gles_precision(fields[i].precision, fields[i].type, 8481 state, &loc); 8482 } 8483 8484 if (fields[i].matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED) { 8485 var->data.matrix_layout = matrix_layout == GLSL_MATRIX_LAYOUT_INHERITED 8486 ? GLSL_MATRIX_LAYOUT_COLUMN_MAJOR : matrix_layout; 8487 } else { 8488 var->data.matrix_layout = fields[i].matrix_layout; 8489 } 8490 8491 if (var->data.mode == ir_var_shader_storage) 8492 apply_memory_qualifiers(var, fields[i]); 8493 8494 /* Examine var name here since var may get deleted in the next call */ 8495 bool var_is_gl_id = is_gl_identifier(var->name); 8496 8497 if (redeclaring_per_vertex) { 8498 bool is_redeclaration; 8499 var = 8500 get_variable_being_redeclared(&var, loc, state, 8501 true /* allow_all_redeclarations */, 8502 &is_redeclaration); 8503 if (!var_is_gl_id || !is_redeclaration) { 8504 _mesa_glsl_error(&loc, state, 8505 "redeclaration of gl_PerVertex can only " 8506 "include built-in variables"); 8507 } else if (var->data.how_declared == ir_var_declared_normally) { 8508 _mesa_glsl_error(&loc, state, 8509 "`%s' has already been redeclared", 8510 var->name); 8511 } else { 8512 var->data.how_declared = ir_var_declared_in_block; 8513 var->reinit_interface_type(block_type); 8514 } 8515 continue; 8516 } 8517 8518 if (state->symbols->get_variable(var->name) != NULL__null) 8519 _mesa_glsl_error(&loc, state, "`%s' redeclared", var->name); 8520 8521 /* Propagate the "binding" keyword into this UBO/SSBO's fields. 8522 * The UBO declaration itself doesn't get an ir_variable unless it 8523 * has an instance name. This is ugly. 8524 */ 8525 if (this->layout.flags.q.explicit_binding) { 8526 apply_explicit_binding(state, &loc, var, 8527 var->get_interface_type(), &this->layout); 8528 } 8529 8530 if (var->type->is_unsized_array()) { 8531 if (var->is_in_shader_storage_block() && 8532 is_unsized_array_last_element(var)) { 8533 var->data.from_ssbo_unsized_array = true; 8534 } else { 8535 /* From GLSL ES 3.10 spec, section 4.1.9 "Arrays": 8536 * 8537 * "If an array is declared as the last member of a shader storage 8538 * block and the size is not specified at compile-time, it is 8539 * sized at run-time. In all other cases, arrays are sized only 8540 * at compile-time." 8541 * 8542 * In desktop GLSL it is allowed to have unsized-arrays that are 8543 * not last, as long as we can determine that they are implicitly 8544 * sized. 8545 */ 8546 if (state->es_shader) { 8547 _mesa_glsl_error(&loc, state, "unsized array `%s' " 8548 "definition: only last member of a shader " 8549 "storage block can be defined as unsized " 8550 "array", fields[i].name); 8551 } 8552 } 8553 } 8554 8555 state->symbols->add_variable(var); 8556 instructions->push_tail(var); 8557 } 8558 8559 if (redeclaring_per_vertex && block_type != earlier_per_vertex) { 8560 /* From section 7.1 ("Built-in Language Variables") of the GLSL 4.10 spec: 8561 * 8562 * It is also a compilation error ... to redeclare a built-in 8563 * block and then use a member from that built-in block that was 8564 * not included in the redeclaration. 8565 * 8566 * This appears to be a clarification to the behaviour established 8567 * for gl_PerVertex by GLSL 1.50, therefore we implement this 8568 * behaviour regardless of GLSL version. 8569 * 8570 * To prevent the shader from using a member that was not included in 8571 * the redeclaration, we disable any ir_variables that are still 8572 * associated with the old declaration of gl_PerVertex (since we've 8573 * already updated all of the variables contained in the new 8574 * gl_PerVertex to point to it). 8575 * 8576 * As a side effect this will prevent 8577 * validate_intrastage_interface_blocks() from getting confused and 8578 * thinking there are conflicting definitions of gl_PerVertex in the 8579 * shader. 8580 */ 8581 foreach_in_list_safe(ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null), *__next = (node) ? (!exec_node_is_tail_sentinel
((instructions)->head_sentinel.next->next) ? (ir_instruction
*) ((instructions)->head_sentinel.next->next) : __null
) : __null; (node) != __null; (node) = __next, __next = __next
? (!exec_node_is_tail_sentinel(__next->next) ? (ir_instruction
*) (__next->next) : __null) : __null) { 8582 ir_variable *const var = node->as_variable(); 8583 if (var != NULL__null && 8584 var->get_interface_type() == earlier_per_vertex && 8585 var->data.mode == var_mode) { 8586 if (var->data.how_declared == ir_var_declared_normally) { 8587 _mesa_glsl_error(&loc, state, 8588 "redeclaration of gl_PerVertex cannot " 8589 "follow a redeclaration of `%s'", 8590 var->name); 8591 } 8592 state->symbols->disable_variable(var->name); 8593 var->remove(); 8594 } 8595 } 8596 } 8597 } 8598 8599 return NULL__null; 8600} 8601 8602 8603ir_rvalue * 8604ast_tcs_output_layout::hir(exec_list *instructions, 8605 struct _mesa_glsl_parse_state *state) 8606{ 8607 YYLTYPE loc = this->get_location(); 8608 8609 unsigned num_vertices; 8610 if (!state->out_qualifier->vertices-> 8611 process_qualifier_constant(state, "vertices", &num_vertices, 8612 false)) { 8613 /* return here to stop cascading incorrect error messages */ 8614 return NULL__null; 8615 } 8616 8617 /* If any shader outputs occurred before this declaration and specified an 8618 * array size, make sure the size they specified is consistent with the 8619 * primitive type. 8620 */ 8621 if (state->tcs_output_size != 0 && state->tcs_output_size != num_vertices) { 8622 _mesa_glsl_error(&loc, state, 8623 "this tessellation control shader output layout " 8624 "specifies %u vertices, but a previous output " 8625 "is declared with size %u", 8626 num_vertices, state->tcs_output_size); 8627 return NULL__null; 8628 } 8629 8630 state->tcs_output_vertices_specified = true; 8631 8632 /* If any shader outputs occurred before this declaration and did not 8633 * specify an array size, their size is determined now. 8634 */ 8635 foreach_in_list (ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null); (node) != __null; (node)
= (!exec_node_is_tail_sentinel((node)->next) ? (ir_instruction
*) ((node)->next) : __null)) { 8636 ir_variable *var = node->as_variable(); 8637 if (var == NULL__null || var->data.mode != ir_var_shader_out) 8638 continue; 8639 8640 /* Note: Not all tessellation control shader output are arrays. */ 8641 if (!var->type->is_unsized_array() || var->data.patch) 8642 continue; 8643 8644 if (var->data.max_array_access >= (int)num_vertices) { 8645 _mesa_glsl_error(&loc, state, 8646 "this tessellation control shader output layout " 8647 "specifies %u vertices, but an access to element " 8648 "%u of output `%s' already exists", num_vertices, 8649 var->data.max_array_access, var->name); 8650 } else { 8651 var->type = glsl_type::get_array_instance(var->type->fields.array, 8652 num_vertices); 8653 } 8654 } 8655 8656 return NULL__null; 8657} 8658 8659 8660ir_rvalue * 8661ast_gs_input_layout::hir(exec_list *instructions, 8662 struct _mesa_glsl_parse_state *state) 8663{ 8664 YYLTYPE loc = this->get_location(); 8665 8666 /* Should have been prevented by the parser. */ 8667 assert(!state->gs_input_prim_type_specified(static_cast <bool> (!state->gs_input_prim_type_specified
|| state->in_qualifier->prim_type == this->prim_type
) ? void (0) : __assert_fail ("!state->gs_input_prim_type_specified || state->in_qualifier->prim_type == this->prim_type"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)) 8668 || state->in_qualifier->prim_type == this->prim_type)(static_cast <bool> (!state->gs_input_prim_type_specified
|| state->in_qualifier->prim_type == this->prim_type
) ? void (0) : __assert_fail ("!state->gs_input_prim_type_specified || state->in_qualifier->prim_type == this->prim_type"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); 8669 8670 /* If any shader inputs occurred before this declaration and specified an 8671 * array size, make sure the size they specified is consistent with the 8672 * primitive type. 8673 */ 8674 unsigned num_vertices = vertices_per_prim(this->prim_type); 8675 if (state->gs_input_size != 0 && state->gs_input_size != num_vertices) { 8676 _mesa_glsl_error(&loc, state, 8677 "this geometry shader input layout implies %u vertices" 8678 " per primitive, but a previous input is declared" 8679 " with size %u", num_vertices, state->gs_input_size); 8680 return NULL__null; 8681 } 8682 8683 state->gs_input_prim_type_specified = true; 8684 8685 /* If any shader inputs occurred before this declaration and did not 8686 * specify an array size, their size is determined now. 8687 */ 8688 foreach_in_list(ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null); (node) != __null; (node)
= (!exec_node_is_tail_sentinel((node)->next) ? (ir_instruction
*) ((node)->next) : __null)) { 8689 ir_variable *var = node->as_variable(); 8690 if (var == NULL__null || var->data.mode != ir_var_shader_in) 8691 continue; 8692 8693 /* Note: gl_PrimitiveIDIn has mode ir_var_shader_in, but it's not an 8694 * array; skip it. 8695 */ 8696 8697 if (var->type->is_unsized_array()) { 8698 if (var->data.max_array_access >= (int)num_vertices) { 8699 _mesa_glsl_error(&loc, state, 8700 "this geometry shader input layout implies %u" 8701 " vertices, but an access to element %u of input" 8702 " `%s' already exists", num_vertices, 8703 var->data.max_array_access, var->name); 8704 } else { 8705 var->type = glsl_type::get_array_instance(var->type->fields.array, 8706 num_vertices); 8707 } 8708 } 8709 } 8710 8711 return NULL__null; 8712} 8713 8714 8715ir_rvalue * 8716ast_cs_input_layout::hir(exec_list *instructions, 8717 struct _mesa_glsl_parse_state *state) 8718{ 8719 YYLTYPE loc = this->get_location(); 8720 8721 /* From the ARB_compute_shader specification: 8722 * 8723 * If the local size of the shader in any dimension is greater 8724 * than the maximum size supported by the implementation for that 8725 * dimension, a compile-time error results. 8726 * 8727 * It is not clear from the spec how the error should be reported if 8728 * the total size of the work group exceeds 8729 * MAX_COMPUTE_WORK_GROUP_INVOCATIONS, but it seems reasonable to 8730 * report it at compile time as well. 8731 */ 8732 GLuint64 total_invocations = 1; 8733 unsigned qual_local_size[3]; 8734 for (int i = 0; i < 3; i++) { 8735 8736 char *local_size_str = ralloc_asprintf(NULL__null, "invalid local_size_%c", 8737 'x' + i); 8738 /* Infer a local_size of 1 for unspecified dimensions */ 8739 if (this->local_size[i] == NULL__null) { 8740 qual_local_size[i] = 1; 8741 } else if (!this->local_size[i]-> 8742 process_qualifier_constant(state, local_size_str, 8743 &qual_local_size[i], false)) { 8744 ralloc_free(local_size_str); 8745 return NULL__null; 8746 } 8747 ralloc_free(local_size_str); 8748 8749 if (qual_local_size[i] > state->ctx->Const.MaxComputeWorkGroupSize[i]) { 8750 _mesa_glsl_error(&loc, state, 8751 "local_size_%c exceeds MAX_COMPUTE_WORK_GROUP_SIZE" 8752 " (%d)", 'x' + i, 8753 state->ctx->Const.MaxComputeWorkGroupSize[i]); 8754 break; 8755 } 8756 total_invocations *= qual_local_size[i]; 8757 if (total_invocations > 8758 state->ctx->Const.MaxComputeWorkGroupInvocations) { 8759 _mesa_glsl_error(&loc, state, 8760 "product of local_sizes exceeds " 8761 "MAX_COMPUTE_WORK_GROUP_INVOCATIONS (%d)", 8762 state->ctx->Const.MaxComputeWorkGroupInvocations); 8763 break; 8764 } 8765 } 8766 8767 /* If any compute input layout declaration preceded this one, make sure it 8768 * was consistent with this one. 8769 */ 8770 if (state->cs_input_local_size_specified) { 8771 for (int i = 0; i < 3; i++) { 8772 if (state->cs_input_local_size[i] != qual_local_size[i]) { 8773 _mesa_glsl_error(&loc, state, 8774 "compute shader input layout does not match" 8775 " previous declaration"); 8776 return NULL__null; 8777 } 8778 } 8779 } 8780 8781 /* The ARB_compute_variable_group_size spec says: 8782 * 8783 * If a compute shader including a *local_size_variable* qualifier also 8784 * declares a fixed local group size using the *local_size_x*, 8785 * *local_size_y*, or *local_size_z* qualifiers, a compile-time error 8786 * results 8787 */ 8788 if (state->cs_input_local_size_variable_specified) { 8789 _mesa_glsl_error(&loc, state, 8790 "compute shader can't include both a variable and a " 8791 "fixed local group size"); 8792 return NULL__null; 8793 } 8794 8795 state->cs_input_local_size_specified = true; 8796 for (int i = 0; i < 3; i++) 8797 state->cs_input_local_size[i] = qual_local_size[i]; 8798 8799 /* We may now declare the built-in constant gl_WorkGroupSize (see 8800 * builtin_variable_generator::generate_constants() for why we didn't 8801 * declare it earlier). 8802 */ 8803 ir_variable *var = new(state->symbols) 8804 ir_variable(glsl_type::uvec3_type, "gl_WorkGroupSize", ir_var_auto); 8805 var->data.how_declared = ir_var_declared_implicitly; 8806 var->data.read_only = true; 8807 instructions->push_tail(var); 8808 state->symbols->add_variable(var); 8809 ir_constant_data data; 8810 memset(&data, 0, sizeof(data)); 8811 for (int i = 0; i < 3; i++) 8812 data.u[i] = qual_local_size[i]; 8813 var->constant_value = new(var) ir_constant(glsl_type::uvec3_type, &data); 8814 var->constant_initializer = 8815 new(var) ir_constant(glsl_type::uvec3_type, &data); 8816 var->data.has_initializer = true; 8817 8818 return NULL__null; 8819} 8820 8821 8822static void 8823detect_conflicting_assignments(struct _mesa_glsl_parse_state *state, 8824 exec_list *instructions) 8825{ 8826 bool gl_FragColor_assigned = false; 8827 bool gl_FragData_assigned = false; 8828 bool gl_FragSecondaryColor_assigned = false; 8829 bool gl_FragSecondaryData_assigned = false; 8830 bool user_defined_fs_output_assigned = false; 8831 ir_variable *user_defined_fs_output = NULL__null; 8832 8833 /* It would be nice to have proper location information. */ 8834 YYLTYPE loc; 8835 memset(&loc, 0, sizeof(loc)); 8836 8837 foreach_in_list(ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null); (node) != __null; (node)
= (!exec_node_is_tail_sentinel((node)->next) ? (ir_instruction
*) ((node)->next) : __null)) { 8838 ir_variable *var = node->as_variable(); 8839 8840 if (!var || !var->data.assigned) 8841 continue; 8842 8843 if (strcmp(var->name, "gl_FragColor") == 0) 8844 gl_FragColor_assigned = true; 8845 else if (strcmp(var->name, "gl_FragData") == 0) 8846 gl_FragData_assigned = true; 8847 else if (strcmp(var->name, "gl_SecondaryFragColorEXT") == 0) 8848 gl_FragSecondaryColor_assigned = true; 8849 else if (strcmp(var->name, "gl_SecondaryFragDataEXT") == 0) 8850 gl_FragSecondaryData_assigned = true; 8851 else if (!is_gl_identifier(var->name)) { 8852 if (state->stage == MESA_SHADER_FRAGMENT && 8853 var->data.mode == ir_var_shader_out) { 8854 user_defined_fs_output_assigned = true; 8855 user_defined_fs_output = var; 8856 } 8857 } 8858 } 8859 8860 /* From the GLSL 1.30 spec: 8861 * 8862 * "If a shader statically assigns a value to gl_FragColor, it 8863 * may not assign a value to any element of gl_FragData. If a 8864 * shader statically writes a value to any element of 8865 * gl_FragData, it may not assign a value to 8866 * gl_FragColor. That is, a shader may assign values to either 8867 * gl_FragColor or gl_FragData, but not both. Multiple shaders 8868 * linked together must also consistently write just one of 8869 * these variables. Similarly, if user declared output 8870 * variables are in use (statically assigned to), then the 8871 * built-in variables gl_FragColor and gl_FragData may not be 8872 * assigned to. These incorrect usages all generate compile 8873 * time errors." 8874 */ 8875 if (gl_FragColor_assigned && gl_FragData_assigned) { 8876 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8877 "`gl_FragColor' and `gl_FragData'"); 8878 } else if (gl_FragColor_assigned && user_defined_fs_output_assigned) { 8879 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8880 "`gl_FragColor' and `%s'", 8881 user_defined_fs_output->name); 8882 } else if (gl_FragSecondaryColor_assigned && gl_FragSecondaryData_assigned) { 8883 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8884 "`gl_FragSecondaryColorEXT' and" 8885 " `gl_FragSecondaryDataEXT'"); 8886 } else if (gl_FragColor_assigned && gl_FragSecondaryData_assigned) { 8887 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8888 "`gl_FragColor' and" 8889 " `gl_FragSecondaryDataEXT'"); 8890 } else if (gl_FragData_assigned && gl_FragSecondaryColor_assigned) { 8891 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8892 "`gl_FragData' and" 8893 " `gl_FragSecondaryColorEXT'"); 8894 } else if (gl_FragData_assigned && user_defined_fs_output_assigned) { 8895 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 8896 "`gl_FragData' and `%s'", 8897 user_defined_fs_output->name); 8898 } 8899 8900 if ((gl_FragSecondaryColor_assigned || gl_FragSecondaryData_assigned) && 8901 !state->EXT_blend_func_extended_enable) { 8902 _mesa_glsl_error(&loc, state, 8903 "Dual source blending requires EXT_blend_func_extended"); 8904 } 8905} 8906 8907static void 8908verify_subroutine_associated_funcs(struct _mesa_glsl_parse_state *state) 8909{ 8910 YYLTYPE loc; 8911 memset(&loc, 0, sizeof(loc)); 8912 8913 /* Section 6.1.2 (Subroutines) of the GLSL 4.00 spec says: 8914 * 8915 * "A program will fail to compile or link if any shader 8916 * or stage contains two or more functions with the same 8917 * name if the name is associated with a subroutine type." 8918 */ 8919 8920 for (int i = 0; i < state->num_subroutines; i++) { 8921 unsigned definitions = 0; 8922 ir_function *fn = state->subroutines[i]; 8923 /* Calculate number of function definitions with the same name */ 8924 foreach_in_list(ir_function_signature, sig, &fn->signatures)for (ir_function_signature *sig = (!exec_node_is_tail_sentinel
((&fn->signatures)->head_sentinel.next) ? (ir_function_signature
*) ((&fn->signatures)->head_sentinel.next) : __null
); (sig) != __null; (sig) = (!exec_node_is_tail_sentinel((sig
)->next) ? (ir_function_signature *) ((sig)->next) : __null
)) { 8925 if (sig->is_defined) { 8926 if (++definitions > 1) { 8927 _mesa_glsl_error(&loc, state, 8928 "%s shader contains two or more function " 8929 "definitions with name `%s', which is " 8930 "associated with a subroutine type.\n", 8931 _mesa_shader_stage_to_string(state->stage), 8932 fn->name); 8933 return; 8934 } 8935 } 8936 } 8937 } 8938} 8939 8940static void 8941remove_per_vertex_blocks(exec_list *instructions, 8942 _mesa_glsl_parse_state *state, ir_variable_mode mode) 8943{ 8944 /* Find the gl_PerVertex interface block of the appropriate (in/out) mode, 8945 * if it exists in this shader type. 8946 */ 8947 const glsl_type *per_vertex = NULL__null; 8948 switch (mode) { 8949 case ir_var_shader_in: 8950 if (ir_variable *gl_in = state->symbols->get_variable("gl_in")) 8951 per_vertex = gl_in->get_interface_type(); 8952 break; 8953 case ir_var_shader_out: 8954 if (ir_variable *gl_Position = 8955 state->symbols->get_variable("gl_Position")) { 8956 per_vertex = gl_Position->get_interface_type(); 8957 } 8958 break; 8959 default: 8960 assert(!"Unexpected mode")(static_cast <bool> (!"Unexpected mode") ? void (0) : __assert_fail
("!\"Unexpected mode\"", __builtin_FILE (), __builtin_LINE (
), __extension__ __PRETTY_FUNCTION__)); 8961 break; 8962 } 8963 8964 /* If we didn't find a built-in gl_PerVertex interface block, then we don't 8965 * need to do anything. 8966 */ 8967 if (per_vertex == NULL__null) 8968 return; 8969 8970 /* If the interface block is used by the shader, then we don't need to do 8971 * anything. 8972 */ 8973 interface_block_usage_visitor v(mode, per_vertex); 8974 v.run(instructions); 8975 if (v.usage_found()) 8976 return; 8977 8978 /* Remove any ir_variable declarations that refer to the interface block 8979 * we're removing. 8980 */ 8981 foreach_in_list_safe(ir_instruction, node, instructions)for (ir_instruction *node = (!exec_node_is_tail_sentinel((instructions
)->head_sentinel.next) ? (ir_instruction *) ((instructions
)->head_sentinel.next) : __null), *__next = (node) ? (!exec_node_is_tail_sentinel
((instructions)->head_sentinel.next->next) ? (ir_instruction
*) ((instructions)->head_sentinel.next->next) : __null
) : __null; (node) != __null; (node) = __next, __next = __next
? (!exec_node_is_tail_sentinel(__next->next) ? (ir_instruction
*) (__next->next) : __null) : __null) { 8982 ir_variable *const var = node->as_variable(); 8983 if (var != NULL__null && var->get_interface_type() == per_vertex && 8984 var->data.mode == mode) { 8985 state->symbols->disable_variable(var->name); 8986 var->remove(); 8987 } 8988 } 8989} 8990 8991ir_rvalue * 8992ast_warnings_toggle::hir(exec_list *, 8993 struct _mesa_glsl_parse_state *state) 8994{ 8995 state->warnings_enabled = enable; 8996 return NULL__null; 8997}