• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2010 Intel Corporation
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  */
23 
24 /**
25  * \file ast_to_hir.c
26  * Convert abstract syntax to to high-level intermediate reprensentation (HIR).
27  *
28  * During the conversion to HIR, the majority of the symantic checking is
29  * preformed on the program.  This includes:
30  *
31  *    * Symbol table management
32  *    * Type checking
33  *    * Function binding
34  *
35  * The majority of this work could be done during parsing, and the parser could
36  * probably generate HIR directly.  However, this results in frequent changes
37  * to the parser code.  Since we do not assume that every system this complier
38  * is built on will have Flex and Bison installed, we have to store the code
39  * generated by these tools in our version control system.  In other parts of
40  * the system we've seen problems where a parser was changed but the generated
41  * code was not committed, merge conflicts where created because two developers
42  * had slightly different versions of Bison installed, etc.
43  *
44  * I have also noticed that running Bison generated parsers in GDB is very
45  * irritating.  When you get a segfault on '$$ = $1->foo', you can't very
46  * well 'print $1' in GDB.
47  *
48  * As a result, my preference is to put as little C code as possible in the
49  * parser (and lexer) sources.
50  */
51 
52 #include "main/core.h" /* for struct gl_extensions */
53 #include "glsl_symbol_table.h"
54 #include "glsl_parser_extras.h"
55 #include "ast.h"
56 #include "glsl_types.h"
57 #include "ir.h"
58 
59 void
_mesa_ast_to_hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)60 _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
61 {
62    _mesa_glsl_initialize_variables(instructions, state);
63    _mesa_glsl_initialize_functions(instructions, state);
64 
65    state->symbols->language_version = state->language_version;
66 
67    state->current_function = NULL;
68 
69    /* Section 4.2 of the GLSL 1.20 specification states:
70     * "The built-in functions are scoped in a scope outside the global scope
71     *  users declare global variables in.  That is, a shader's global scope,
72     *  available for user-defined functions and global variables, is nested
73     *  inside the scope containing the built-in functions."
74     *
75     * Since built-in functions like ftransform() access built-in variables,
76     * it follows that those must be in the outer scope as well.
77     *
78     * We push scope here to create this nesting effect...but don't pop.
79     * This way, a shader's globals are still in the symbol table for use
80     * by the linker.
81     */
82    state->symbols->push_scope();
83 
84    foreach_list_typed (ast_node, ast, link, & state->translation_unit)
85       ast->hir(instructions, state);
86 }
87 
88 
89 /**
90  * If a conversion is available, convert one operand to a different type
91  *
92  * The \c from \c ir_rvalue is converted "in place".
93  *
94  * \param to     Type that the operand it to be converted to
95  * \param from   Operand that is being converted
96  * \param state  GLSL compiler state
97  *
98  * \return
99  * If a conversion is possible (or unnecessary), \c true is returned.
100  * Otherwise \c false is returned.
101  */
102 bool
apply_implicit_conversion(const glsl_type * to,ir_rvalue * & from,struct _mesa_glsl_parse_state * state)103 apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
104 			  struct _mesa_glsl_parse_state *state)
105 {
106    void *ctx = state;
107    if (to->base_type == from->type->base_type)
108       return true;
109 
110    /* This conversion was added in GLSL 1.20.  If the compilation mode is
111     * GLSL 1.10, the conversion is skipped.
112     */
113    if (state->language_version < 120)
114       return false;
115 
116    /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
117     *
118     *    "There are no implicit array or structure conversions. For
119     *    example, an array of int cannot be implicitly converted to an
120     *    array of float. There are no implicit conversions between
121     *    signed and unsigned integers."
122     */
123    /* FINISHME: The above comment is partially a lie.  There is int/uint
124     * FINISHME: conversion for immediate constants.
125     */
126    if (!to->is_float() || !from->type->is_numeric())
127       return false;
128 
129    /* Convert to a floating point type with the same number of components
130     * as the original type - i.e. int to float, not int to vec4.
131     */
132    to = glsl_type::get_instance(GLSL_TYPE_FLOAT, from->type->vector_elements,
133 			        from->type->matrix_columns);
134 
135    switch (from->type->base_type) {
136    case GLSL_TYPE_INT:
137       from = new(ctx) ir_expression(ir_unop_i2f, to, from, NULL);
138       break;
139    case GLSL_TYPE_UINT:
140       from = new(ctx) ir_expression(ir_unop_u2f, to, from, NULL);
141       break;
142    case GLSL_TYPE_BOOL:
143       from = new(ctx) ir_expression(ir_unop_b2f, to, from, NULL);
144       break;
145    default:
146       assert(0);
147    }
148 
149    return true;
150 }
151 
152 
153 static const struct glsl_type *
arithmetic_result_type(ir_rvalue * & value_a,ir_rvalue * & value_b,bool multiply,struct _mesa_glsl_parse_state * state,YYLTYPE * loc)154 arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
155 		       bool multiply,
156 		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
157 {
158    const glsl_type *type_a = value_a->type;
159    const glsl_type *type_b = value_b->type;
160 
161    /* From GLSL 1.50 spec, page 56:
162     *
163     *    "The arithmetic binary operators add (+), subtract (-),
164     *    multiply (*), and divide (/) operate on integer and
165     *    floating-point scalars, vectors, and matrices."
166     */
167    if (!type_a->is_numeric() || !type_b->is_numeric()) {
168       _mesa_glsl_error(loc, state,
169 		       "Operands to arithmetic operators must be numeric");
170       return glsl_type::error_type;
171    }
172 
173 
174    /*    "If one operand is floating-point based and the other is
175     *    not, then the conversions from Section 4.1.10 "Implicit
176     *    Conversions" are applied to the non-floating-point-based operand."
177     */
178    if (!apply_implicit_conversion(type_a, value_b, state)
179        && !apply_implicit_conversion(type_b, value_a, state)) {
180       _mesa_glsl_error(loc, state,
181 		       "Could not implicitly convert operands to "
182 		       "arithmetic operator");
183       return glsl_type::error_type;
184    }
185    type_a = value_a->type;
186    type_b = value_b->type;
187 
188    /*    "If the operands are integer types, they must both be signed or
189     *    both be unsigned."
190     *
191     * From this rule and the preceeding conversion it can be inferred that
192     * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
193     * The is_numeric check above already filtered out the case where either
194     * type is not one of these, so now the base types need only be tested for
195     * equality.
196     */
197    if (type_a->base_type != type_b->base_type) {
198       _mesa_glsl_error(loc, state,
199 		       "base type mismatch for arithmetic operator");
200       return glsl_type::error_type;
201    }
202 
203    /*    "All arithmetic binary operators result in the same fundamental type
204     *    (signed integer, unsigned integer, or floating-point) as the
205     *    operands they operate on, after operand type conversion. After
206     *    conversion, the following cases are valid
207     *
208     *    * The two operands are scalars. In this case the operation is
209     *      applied, resulting in a scalar."
210     */
211    if (type_a->is_scalar() && type_b->is_scalar())
212       return type_a;
213 
214    /*   "* One operand is a scalar, and the other is a vector or matrix.
215     *      In this case, the scalar operation is applied independently to each
216     *      component of the vector or matrix, resulting in the same size
217     *      vector or matrix."
218     */
219    if (type_a->is_scalar()) {
220       if (!type_b->is_scalar())
221 	 return type_b;
222    } else if (type_b->is_scalar()) {
223       return type_a;
224    }
225 
226    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
227     * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
228     * handled.
229     */
230    assert(!type_a->is_scalar());
231    assert(!type_b->is_scalar());
232 
233    /*   "* The two operands are vectors of the same size. In this case, the
234     *      operation is done component-wise resulting in the same size
235     *      vector."
236     */
237    if (type_a->is_vector() && type_b->is_vector()) {
238       if (type_a == type_b) {
239 	 return type_a;
240       } else {
241 	 _mesa_glsl_error(loc, state,
242 			  "vector size mismatch for arithmetic operator");
243 	 return glsl_type::error_type;
244       }
245    }
246 
247    /* All of the combinations of <scalar, scalar>, <vector, scalar>,
248     * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
249     * <vector, vector> have been handled.  At least one of the operands must
250     * be matrix.  Further, since there are no integer matrix types, the base
251     * type of both operands must be float.
252     */
253    assert(type_a->is_matrix() || type_b->is_matrix());
254    assert(type_a->base_type == GLSL_TYPE_FLOAT);
255    assert(type_b->base_type == GLSL_TYPE_FLOAT);
256 
257    /*   "* The operator is add (+), subtract (-), or divide (/), and the
258     *      operands are matrices with the same number of rows and the same
259     *      number of columns. In this case, the operation is done component-
260     *      wise resulting in the same size matrix."
261     *    * The operator is multiply (*), where both operands are matrices or
262     *      one operand is a vector and the other a matrix. A right vector
263     *      operand is treated as a column vector and a left vector operand as a
264     *      row vector. In all these cases, it is required that the number of
265     *      columns of the left operand is equal to the number of rows of the
266     *      right operand. Then, the multiply (*) operation does a linear
267     *      algebraic multiply, yielding an object that has the same number of
268     *      rows as the left operand and the same number of columns as the right
269     *      operand. Section 5.10 "Vector and Matrix Operations" explains in
270     *      more detail how vectors and matrices are operated on."
271     */
272    if (! multiply) {
273       if (type_a == type_b)
274 	 return type_a;
275    } else {
276       if (type_a->is_matrix() && type_b->is_matrix()) {
277 	 /* Matrix multiply.  The columns of A must match the rows of B.  Given
278 	  * the other previously tested constraints, this means the vector type
279 	  * of a row from A must be the same as the vector type of a column from
280 	  * B.
281 	  */
282 	 if (type_a->row_type() == type_b->column_type()) {
283 	    /* The resulting matrix has the number of columns of matrix B and
284 	     * the number of rows of matrix A.  We get the row count of A by
285 	     * looking at the size of a vector that makes up a column.  The
286 	     * transpose (size of a row) is done for B.
287 	     */
288 	    const glsl_type *const type =
289 	       glsl_type::get_instance(type_a->base_type,
290 				       type_a->column_type()->vector_elements,
291 				       type_b->row_type()->vector_elements);
292 	    assert(type != glsl_type::error_type);
293 
294 	    return type;
295 	 }
296       } else if (type_a->is_matrix()) {
297 	 /* A is a matrix and B is a column vector.  Columns of A must match
298 	  * rows of B.  Given the other previously tested constraints, this
299 	  * means the vector type of a row from A must be the same as the
300 	  * vector the type of B.
301 	  */
302 	 if (type_a->row_type() == type_b) {
303 	    /* The resulting vector has a number of elements equal to
304 	     * the number of rows of matrix A. */
305 	    const glsl_type *const type =
306 	       glsl_type::get_instance(type_a->base_type,
307 				       type_a->column_type()->vector_elements,
308 				       1);
309 	    assert(type != glsl_type::error_type);
310 
311 	    return type;
312 	 }
313       } else {
314 	 assert(type_b->is_matrix());
315 
316 	 /* A is a row vector and B is a matrix.  Columns of A must match rows
317 	  * of B.  Given the other previously tested constraints, this means
318 	  * the type of A must be the same as the vector type of a column from
319 	  * B.
320 	  */
321 	 if (type_a == type_b->column_type()) {
322 	    /* The resulting vector has a number of elements equal to
323 	     * the number of columns of matrix B. */
324 	    const glsl_type *const type =
325 	       glsl_type::get_instance(type_a->base_type,
326 				       type_b->row_type()->vector_elements,
327 				       1);
328 	    assert(type != glsl_type::error_type);
329 
330 	    return type;
331 	 }
332       }
333 
334       _mesa_glsl_error(loc, state, "size mismatch for matrix multiplication");
335       return glsl_type::error_type;
336    }
337 
338 
339    /*    "All other cases are illegal."
340     */
341    _mesa_glsl_error(loc, state, "type mismatch");
342    return glsl_type::error_type;
343 }
344 
345 
346 static const struct glsl_type *
unary_arithmetic_result_type(const struct glsl_type * type,struct _mesa_glsl_parse_state * state,YYLTYPE * loc)347 unary_arithmetic_result_type(const struct glsl_type *type,
348 			     struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
349 {
350    /* From GLSL 1.50 spec, page 57:
351     *
352     *    "The arithmetic unary operators negate (-), post- and pre-increment
353     *     and decrement (-- and ++) operate on integer or floating-point
354     *     values (including vectors and matrices). All unary operators work
355     *     component-wise on their operands. These result with the same type
356     *     they operated on."
357     */
358    if (!type->is_numeric()) {
359       _mesa_glsl_error(loc, state,
360 		       "Operands to arithmetic operators must be numeric");
361       return glsl_type::error_type;
362    }
363 
364    return type;
365 }
366 
367 /**
368  * \brief Return the result type of a bit-logic operation.
369  *
370  * If the given types to the bit-logic operator are invalid, return
371  * glsl_type::error_type.
372  *
373  * \param type_a Type of LHS of bit-logic op
374  * \param type_b Type of RHS of bit-logic op
375  */
376 static const struct glsl_type *
bit_logic_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)377 bit_logic_result_type(const struct glsl_type *type_a,
378                       const struct glsl_type *type_b,
379                       ast_operators op,
380                       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
381 {
382     if (state->language_version < 130) {
383        _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30");
384        return glsl_type::error_type;
385     }
386 
387     /* From page 50 (page 56 of PDF) of GLSL 1.30 spec:
388      *
389      *     "The bitwise operators and (&), exclusive-or (^), and inclusive-or
390      *     (|). The operands must be of type signed or unsigned integers or
391      *     integer vectors."
392      */
393     if (!type_a->is_integer()) {
394        _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer",
395                          ast_expression::operator_string(op));
396        return glsl_type::error_type;
397     }
398     if (!type_b->is_integer()) {
399        _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer",
400                         ast_expression::operator_string(op));
401        return glsl_type::error_type;
402     }
403 
404     /*     "The fundamental types of the operands (signed or unsigned) must
405      *     match,"
406      */
407     if (type_a->base_type != type_b->base_type) {
408        _mesa_glsl_error(loc, state, "operands of `%s' must have the same "
409                         "base type", ast_expression::operator_string(op));
410        return glsl_type::error_type;
411     }
412 
413     /*     "The operands cannot be vectors of differing size." */
414     if (type_a->is_vector() &&
415         type_b->is_vector() &&
416         type_a->vector_elements != type_b->vector_elements) {
417        _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of "
418                         "different sizes", ast_expression::operator_string(op));
419        return glsl_type::error_type;
420     }
421 
422     /*     "If one operand is a scalar and the other a vector, the scalar is
423      *     applied component-wise to the vector, resulting in the same type as
424      *     the vector. The fundamental types of the operands [...] will be the
425      *     resulting fundamental type."
426      */
427     if (type_a->is_scalar())
428         return type_b;
429     else
430         return type_a;
431 }
432 
433 static const struct glsl_type *
modulus_result_type(const struct glsl_type * type_a,const struct glsl_type * type_b,struct _mesa_glsl_parse_state * state,YYLTYPE * loc)434 modulus_result_type(const struct glsl_type *type_a,
435 		    const struct glsl_type *type_b,
436 		    struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
437 {
438    /* From GLSL 1.50 spec, page 56:
439     *    "The operator modulus (%) operates on signed or unsigned integers or
440     *    integer vectors. The operand types must both be signed or both be
441     *    unsigned."
442     */
443    if (!type_a->is_integer() || !type_b->is_integer()
444        || (type_a->base_type != type_b->base_type)) {
445       _mesa_glsl_error(loc, state, "type mismatch");
446       return glsl_type::error_type;
447    }
448 
449    /*    "The operands cannot be vectors of differing size. If one operand is
450     *    a scalar and the other vector, then the scalar is applied component-
451     *    wise to the vector, resulting in the same type as the vector. If both
452     *    are vectors of the same size, the result is computed component-wise."
453     */
454    if (type_a->is_vector()) {
455       if (!type_b->is_vector()
456 	  || (type_a->vector_elements == type_b->vector_elements))
457 	 return type_a;
458    } else
459       return type_b;
460 
461    /*    "The operator modulus (%) is not defined for any other data types
462     *    (non-integer types)."
463     */
464    _mesa_glsl_error(loc, state, "type mismatch");
465    return glsl_type::error_type;
466 }
467 
468 
469 static const struct glsl_type *
relational_result_type(ir_rvalue * & value_a,ir_rvalue * & value_b,struct _mesa_glsl_parse_state * state,YYLTYPE * loc)470 relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b,
471 		       struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
472 {
473    const glsl_type *type_a = value_a->type;
474    const glsl_type *type_b = value_b->type;
475 
476    /* From GLSL 1.50 spec, page 56:
477     *    "The relational operators greater than (>), less than (<), greater
478     *    than or equal (>=), and less than or equal (<=) operate only on
479     *    scalar integer and scalar floating-point expressions."
480     */
481    if (!type_a->is_numeric()
482        || !type_b->is_numeric()
483        || !type_a->is_scalar()
484        || !type_b->is_scalar()) {
485       _mesa_glsl_error(loc, state,
486 		       "Operands to relational operators must be scalar and "
487 		       "numeric");
488       return glsl_type::error_type;
489    }
490 
491    /*    "Either the operands' types must match, or the conversions from
492     *    Section 4.1.10 "Implicit Conversions" will be applied to the integer
493     *    operand, after which the types must match."
494     */
495    if (!apply_implicit_conversion(type_a, value_b, state)
496        && !apply_implicit_conversion(type_b, value_a, state)) {
497       _mesa_glsl_error(loc, state,
498 		       "Could not implicitly convert operands to "
499 		       "relational operator");
500       return glsl_type::error_type;
501    }
502    type_a = value_a->type;
503    type_b = value_b->type;
504 
505    if (type_a->base_type != type_b->base_type) {
506       _mesa_glsl_error(loc, state, "base type mismatch");
507       return glsl_type::error_type;
508    }
509 
510    /*    "The result is scalar Boolean."
511     */
512    return glsl_type::bool_type;
513 }
514 
515 /**
516  * \brief Return the result type of a bit-shift operation.
517  *
518  * If the given types to the bit-shift operator are invalid, return
519  * glsl_type::error_type.
520  *
521  * \param type_a Type of LHS of bit-shift op
522  * \param type_b Type of RHS of bit-shift op
523  */
524 static const struct glsl_type *
shift_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)525 shift_result_type(const struct glsl_type *type_a,
526                   const struct glsl_type *type_b,
527                   ast_operators op,
528                   struct _mesa_glsl_parse_state *state, YYLTYPE *loc)
529 {
530    if (state->language_version < 130) {
531       _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30");
532       return glsl_type::error_type;
533    }
534 
535    /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec:
536     *
537     *     "The shift operators (<<) and (>>). For both operators, the operands
538     *     must be signed or unsigned integers or integer vectors. One operand
539     *     can be signed while the other is unsigned."
540     */
541    if (!type_a->is_integer()) {
542       _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or "
543               "integer vector", ast_expression::operator_string(op));
544      return glsl_type::error_type;
545 
546    }
547    if (!type_b->is_integer()) {
548       _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or "
549               "integer vector", ast_expression::operator_string(op));
550      return glsl_type::error_type;
551    }
552 
553    /*     "If the first operand is a scalar, the second operand has to be
554     *     a scalar as well."
555     */
556    if (type_a->is_scalar() && !type_b->is_scalar()) {
557       _mesa_glsl_error(loc, state, "If the first operand of %s is scalar, the "
558               "second must be scalar as well",
559               ast_expression::operator_string(op));
560      return glsl_type::error_type;
561    }
562 
563    /* If both operands are vectors, check that they have same number of
564     * elements.
565     */
566    if (type_a->is_vector() &&
567       type_b->is_vector() &&
568       type_a->vector_elements != type_b->vector_elements) {
569       _mesa_glsl_error(loc, state, "Vector operands to operator %s must "
570               "have same number of elements",
571               ast_expression::operator_string(op));
572      return glsl_type::error_type;
573    }
574 
575    /*     "In all cases, the resulting type will be the same type as the left
576     *     operand."
577     */
578    return type_a;
579 }
580 
581 /**
582  * Validates that a value can be assigned to a location with a specified type
583  *
584  * Validates that \c rhs can be assigned to some location.  If the types are
585  * not an exact match but an automatic conversion is possible, \c rhs will be
586  * converted.
587  *
588  * \return
589  * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
590  * Otherwise the actual RHS to be assigned will be returned.  This may be
591  * \c rhs, or it may be \c rhs after some type conversion.
592  *
593  * \note
594  * In addition to being used for assignments, this function is used to
595  * type-check return values.
596  */
597 ir_rvalue *
validate_assignment(struct _mesa_glsl_parse_state * state,const glsl_type * lhs_type,ir_rvalue * rhs)598 validate_assignment(struct _mesa_glsl_parse_state *state,
599 		    const glsl_type *lhs_type, ir_rvalue *rhs)
600 {
601    const glsl_type *rhs_type = rhs->type;
602 
603    /* If there is already some error in the RHS, just return it.  Anything
604     * else will lead to an avalanche of error message back to the user.
605     */
606    if (rhs_type->is_error())
607       return rhs;
608 
609    /* If the types are identical, the assignment can trivially proceed.
610     */
611    if (rhs_type == lhs_type)
612       return rhs;
613 
614    /* If the array element types are the same and the size of the LHS is zero,
615     * the assignment is okay.
616     *
617     * Note: Whole-array assignments are not permitted in GLSL 1.10, but this
618     * is handled by ir_dereference::is_lvalue.
619     */
620    if (lhs_type->is_array() && rhs->type->is_array()
621        && (lhs_type->element_type() == rhs->type->element_type())
622        && (lhs_type->array_size() == 0)) {
623       return rhs;
624    }
625 
626    /* Check for implicit conversion in GLSL 1.20 */
627    if (apply_implicit_conversion(lhs_type, rhs, state)) {
628       rhs_type = rhs->type;
629       if (rhs_type == lhs_type)
630 	 return rhs;
631    }
632 
633    return NULL;
634 }
635 
636 ir_rvalue *
do_assignment(exec_list * instructions,struct _mesa_glsl_parse_state * state,ir_rvalue * lhs,ir_rvalue * rhs,YYLTYPE lhs_loc)637 do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
638 	      ir_rvalue *lhs, ir_rvalue *rhs,
639 	      YYLTYPE lhs_loc)
640 {
641    void *ctx = state;
642    bool error_emitted = (lhs->type->is_error() || rhs->type->is_error());
643 
644    if (!error_emitted) {
645       if (!lhs->is_lvalue()) {
646 	 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment");
647 	 error_emitted = true;
648       }
649 
650       if (state->es_shader && lhs->type->is_array()) {
651 	 _mesa_glsl_error(&lhs_loc, state, "whole array assignment is not "
652 			  "allowed in GLSL ES 1.00.");
653 	 error_emitted = true;
654       }
655    }
656 
657    ir_rvalue *new_rhs = validate_assignment(state, lhs->type, rhs);
658    if (new_rhs == NULL) {
659       _mesa_glsl_error(& lhs_loc, state, "type mismatch");
660    } else {
661       rhs = new_rhs;
662 
663       /* If the LHS array was not declared with a size, it takes it size from
664        * the RHS.  If the LHS is an l-value and a whole array, it must be a
665        * dereference of a variable.  Any other case would require that the LHS
666        * is either not an l-value or not a whole array.
667        */
668       if (lhs->type->array_size() == 0) {
669 	 ir_dereference *const d = lhs->as_dereference();
670 
671 	 assert(d != NULL);
672 
673 	 ir_variable *const var = d->variable_referenced();
674 
675 	 assert(var != NULL);
676 
677 	 if (var->max_array_access >= unsigned(rhs->type->array_size())) {
678 	    /* FINISHME: This should actually log the location of the RHS. */
679 	    _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to "
680 			     "previous access",
681 			     var->max_array_access);
682 	 }
683 
684 	 var->type = glsl_type::get_array_instance(lhs->type->element_type(),
685 						   rhs->type->array_size());
686 	 d->type = var->type;
687       }
688    }
689 
690    /* Most callers of do_assignment (assign, add_assign, pre_inc/dec,
691     * but not post_inc) need the converted assigned value as an rvalue
692     * to handle things like:
693     *
694     * i = j += 1;
695     *
696     * So we always just store the computed value being assigned to a
697     * temporary and return a deref of that temporary.  If the rvalue
698     * ends up not being used, the temp will get copy-propagated out.
699     */
700    ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp",
701 					   ir_var_temporary);
702    ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var);
703    instructions->push_tail(var);
704    instructions->push_tail(new(ctx) ir_assignment(deref_var,
705 						  rhs,
706 						  NULL));
707    deref_var = new(ctx) ir_dereference_variable(var);
708 
709    if (!error_emitted)
710       instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var, NULL));
711 
712    return new(ctx) ir_dereference_variable(var);
713 }
714 
715 static ir_rvalue *
get_lvalue_copy(exec_list * instructions,ir_rvalue * lvalue)716 get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
717 {
718    void *ctx = hieralloc_parent(lvalue);
719    ir_variable *var;
720 
721    var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp",
722 			      ir_var_temporary);
723    instructions->push_tail(var);
724    var->mode = ir_var_auto;
725 
726    instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
727 						  lvalue, NULL));
728 
729    /* Once we've created this temporary, mark it read only so it's no
730     * longer considered an lvalue.
731     */
732    var->read_only = true;
733 
734    return new(ctx) ir_dereference_variable(var);
735 }
736 
737 
738 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)739 ast_node::hir(exec_list *instructions,
740 	      struct _mesa_glsl_parse_state *state)
741 {
742    (void) instructions;
743    (void) state;
744 
745    return NULL;
746 }
747 
748 static void
mark_whole_array_access(ir_rvalue * access)749 mark_whole_array_access(ir_rvalue *access)
750 {
751    ir_dereference_variable *deref = access->as_dereference_variable();
752 
753    if (deref) {
754       deref->var->max_array_access = deref->type->length - 1;
755    }
756 }
757 
758 static ir_rvalue *
do_comparison(void * mem_ctx,int operation,ir_rvalue * op0,ir_rvalue * op1)759 do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1)
760 {
761    int join_op;
762    ir_rvalue *cmp = NULL;
763 
764    if (operation == ir_binop_all_equal)
765       join_op = ir_binop_logic_and;
766    else
767       join_op = ir_binop_logic_or;
768 
769    switch (op0->type->base_type) {
770    case GLSL_TYPE_FLOAT:
771    case GLSL_TYPE_UINT:
772    case GLSL_TYPE_INT:
773    case GLSL_TYPE_BOOL:
774       return new(mem_ctx) ir_expression(operation, op0, op1);
775 
776    case GLSL_TYPE_ARRAY: {
777       for (unsigned int i = 0; i < op0->type->length; i++) {
778 	 ir_rvalue *e0, *e1, *result;
779 
780 	 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL),
781 						new(mem_ctx) ir_constant(i));
782 	 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL),
783 						new(mem_ctx) ir_constant(i));
784 	 result = do_comparison(mem_ctx, operation, e0, e1);
785 
786 	 if (cmp) {
787 	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
788 	 } else {
789 	    cmp = result;
790 	 }
791       }
792 
793       mark_whole_array_access(op0);
794       mark_whole_array_access(op1);
795       break;
796    }
797 
798    case GLSL_TYPE_STRUCT: {
799       for (unsigned int i = 0; i < op0->type->length; i++) {
800 	 ir_rvalue *e0, *e1, *result;
801 	 const char *field_name = op0->type->fields.structure[i].name;
802 
803 	 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL),
804 						 field_name);
805 	 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL),
806 						 field_name);
807 	 result = do_comparison(mem_ctx, operation, e0, e1);
808 
809 	 if (cmp) {
810 	    cmp = new(mem_ctx) ir_expression(join_op, cmp, result);
811 	 } else {
812 	    cmp = result;
813 	 }
814       }
815       break;
816    }
817 
818    case GLSL_TYPE_ERROR:
819    case GLSL_TYPE_VOID:
820    case GLSL_TYPE_SAMPLER:
821       /* I assume a comparison of a struct containing a sampler just
822        * ignores the sampler present in the type.
823        */
824       break;
825 
826    default:
827       assert(!"Should not get here.");
828       break;
829    }
830 
831    if (cmp == NULL)
832       cmp = new(mem_ctx) ir_constant(true);
833 
834    return cmp;
835 }
836 
837 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)838 ast_expression::hir(exec_list *instructions,
839 		    struct _mesa_glsl_parse_state *state)
840 {
841    void *ctx = state;
842    static const int operations[AST_NUM_OPERATORS] = {
843       -1,               /* ast_assign doesn't convert to ir_expression. */
844       -1,               /* ast_plus doesn't convert to ir_expression. */
845       ir_unop_neg,
846       ir_binop_add,
847       ir_binop_sub,
848       ir_binop_mul,
849       ir_binop_div,
850       ir_binop_mod,
851       ir_binop_lshift,
852       ir_binop_rshift,
853       ir_binop_less,
854       ir_binop_greater,
855       ir_binop_lequal,
856       ir_binop_gequal,
857       ir_binop_all_equal,
858       ir_binop_any_nequal,
859       ir_binop_bit_and,
860       ir_binop_bit_xor,
861       ir_binop_bit_or,
862       ir_unop_bit_not,
863       ir_binop_logic_and,
864       ir_binop_logic_xor,
865       ir_binop_logic_or,
866       ir_unop_logic_not,
867 
868       /* Note: The following block of expression types actually convert
869        * to multiple IR instructions.
870        */
871       ir_binop_mul,     /* ast_mul_assign */
872       ir_binop_div,     /* ast_div_assign */
873       ir_binop_mod,     /* ast_mod_assign */
874       ir_binop_add,     /* ast_add_assign */
875       ir_binop_sub,     /* ast_sub_assign */
876       ir_binop_lshift,  /* ast_ls_assign */
877       ir_binop_rshift,  /* ast_rs_assign */
878       ir_binop_bit_and, /* ast_and_assign */
879       ir_binop_bit_xor, /* ast_xor_assign */
880       ir_binop_bit_or,  /* ast_or_assign */
881 
882       -1,               /* ast_conditional doesn't convert to ir_expression. */
883       ir_binop_add,     /* ast_pre_inc. */
884       ir_binop_sub,     /* ast_pre_dec. */
885       ir_binop_add,     /* ast_post_inc. */
886       ir_binop_sub,     /* ast_post_dec. */
887       -1,               /* ast_field_selection doesn't conv to ir_expression. */
888       -1,               /* ast_array_index doesn't convert to ir_expression. */
889       -1,               /* ast_function_call doesn't conv to ir_expression. */
890       -1,               /* ast_identifier doesn't convert to ir_expression. */
891       -1,               /* ast_int_constant doesn't convert to ir_expression. */
892       -1,               /* ast_uint_constant doesn't conv to ir_expression. */
893       -1,               /* ast_float_constant doesn't conv to ir_expression. */
894       -1,               /* ast_bool_constant doesn't conv to ir_expression. */
895       -1,               /* ast_sequence doesn't convert to ir_expression. */
896    };
897    ir_rvalue *result = NULL;
898    ir_rvalue *op[3];
899    const struct glsl_type *type = glsl_type::error_type;
900    bool error_emitted = false;
901    YYLTYPE loc;
902 
903    loc = this->get_location();
904 
905    switch (this->oper) {
906    case ast_assign: {
907       op[0] = this->subexpressions[0]->hir(instructions, state);
908       op[1] = this->subexpressions[1]->hir(instructions, state);
909 
910       result = do_assignment(instructions, state, op[0], op[1],
911 			     this->subexpressions[0]->get_location());
912       error_emitted = result->type->is_error();
913       type = result->type;
914       break;
915    }
916 
917    case ast_plus:
918       op[0] = this->subexpressions[0]->hir(instructions, state);
919 
920       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
921 
922       error_emitted = type->is_error();
923 
924       result = op[0];
925       break;
926 
927    case ast_neg:
928       op[0] = this->subexpressions[0]->hir(instructions, state);
929 
930       type = unary_arithmetic_result_type(op[0]->type, state, & loc);
931 
932       error_emitted = type->is_error();
933 
934       result = new(ctx) ir_expression(operations[this->oper], type,
935 				      op[0], NULL);
936       break;
937 
938    case ast_add:
939    case ast_sub:
940    case ast_mul:
941    case ast_div:
942       op[0] = this->subexpressions[0]->hir(instructions, state);
943       op[1] = this->subexpressions[1]->hir(instructions, state);
944 
945       type = arithmetic_result_type(op[0], op[1],
946 				    (this->oper == ast_mul),
947 				    state, & loc);
948       error_emitted = type->is_error();
949 
950       result = new(ctx) ir_expression(operations[this->oper], type,
951 				      op[0], op[1]);
952       break;
953 
954    case ast_mod:
955       op[0] = this->subexpressions[0]->hir(instructions, state);
956       op[1] = this->subexpressions[1]->hir(instructions, state);
957 
958       type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
959 
960       assert(operations[this->oper] == ir_binop_mod);
961 
962       result = new(ctx) ir_expression(operations[this->oper], type,
963 				      op[0], op[1]);
964       error_emitted = type->is_error();
965       break;
966 
967    case ast_lshift:
968    case ast_rshift:
969        if (state->language_version < 130) {
970           _mesa_glsl_error(&loc, state, "operator %s requires GLSL 1.30",
971               operator_string(this->oper));
972           error_emitted = true;
973        }
974 
975        op[0] = this->subexpressions[0]->hir(instructions, state);
976        op[1] = this->subexpressions[1]->hir(instructions, state);
977        type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
978                                 &loc);
979        result = new(ctx) ir_expression(operations[this->oper], type,
980                                        op[0], op[1]);
981        error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
982        break;
983 
984    case ast_less:
985    case ast_greater:
986    case ast_lequal:
987    case ast_gequal:
988       op[0] = this->subexpressions[0]->hir(instructions, state);
989       op[1] = this->subexpressions[1]->hir(instructions, state);
990 
991       type = relational_result_type(op[0], op[1], state, & loc);
992 
993       /* The relational operators must either generate an error or result
994        * in a scalar boolean.  See page 57 of the GLSL 1.50 spec.
995        */
996       assert(type->is_error()
997 	     || ((type->base_type == GLSL_TYPE_BOOL)
998 		 && type->is_scalar()));
999 
1000       result = new(ctx) ir_expression(operations[this->oper], type,
1001 				      op[0], op[1]);
1002       error_emitted = type->is_error();
1003       break;
1004 
1005    case ast_nequal:
1006    case ast_equal:
1007       op[0] = this->subexpressions[0]->hir(instructions, state);
1008       op[1] = this->subexpressions[1]->hir(instructions, state);
1009 
1010       /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
1011        *
1012        *    "The equality operators equal (==), and not equal (!=)
1013        *    operate on all types. They result in a scalar Boolean. If
1014        *    the operand types do not match, then there must be a
1015        *    conversion from Section 4.1.10 "Implicit Conversions"
1016        *    applied to one operand that can make them match, in which
1017        *    case this conversion is done."
1018        */
1019       if ((!apply_implicit_conversion(op[0]->type, op[1], state)
1020 	   && !apply_implicit_conversion(op[1]->type, op[0], state))
1021 	  || (op[0]->type != op[1]->type)) {
1022 	 _mesa_glsl_error(& loc, state, "operands of `%s' must have the same "
1023 			  "type", (this->oper == ast_equal) ? "==" : "!=");
1024 	 error_emitted = true;
1025       } else if ((state->language_version <= 110)
1026 		 && (op[0]->type->is_array() || op[1]->type->is_array())) {
1027 	 _mesa_glsl_error(& loc, state, "array comparisons forbidden in "
1028 			  "GLSL 1.10");
1029 	 error_emitted = true;
1030       }
1031 
1032       result = do_comparison(ctx, operations[this->oper], op[0], op[1]);
1033       type = glsl_type::bool_type;
1034 
1035       assert(error_emitted || (result->type == glsl_type::bool_type));
1036       break;
1037 
1038    case ast_bit_and:
1039    case ast_bit_xor:
1040    case ast_bit_or:
1041       op[0] = this->subexpressions[0]->hir(instructions, state);
1042       op[1] = this->subexpressions[1]->hir(instructions, state);
1043       type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
1044                                    state, &loc);
1045       result = new(ctx) ir_expression(operations[this->oper], type,
1046 				      op[0], op[1]);
1047       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
1048       break;
1049 
1050    case ast_bit_not:
1051       op[0] = this->subexpressions[0]->hir(instructions, state);
1052 
1053       if (state->language_version < 130) {
1054 	 _mesa_glsl_error(&loc, state, "bit-wise operations require GLSL 1.30");
1055 	 error_emitted = true;
1056       }
1057 
1058       if (!op[0]->type->is_integer()) {
1059 	 _mesa_glsl_error(&loc, state, "operand of `~' must be an integer");
1060 	 error_emitted = true;
1061       }
1062 
1063       type = op[0]->type;
1064       result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL);
1065       break;
1066 
1067    case ast_logic_and: {
1068       op[0] = this->subexpressions[0]->hir(instructions, state);
1069 
1070       if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
1071 	 YYLTYPE loc = this->subexpressions[0]->get_location();
1072 
1073 	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
1074 			  operator_string(this->oper));
1075 	 error_emitted = true;
1076       }
1077 
1078       ir_constant *op0_const = op[0]->constant_expression_value();
1079       if (op0_const) {
1080 	 if (op0_const->value.b[0]) {
1081 	    op[1] = this->subexpressions[1]->hir(instructions, state);
1082 
1083 	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
1084 	       YYLTYPE loc = this->subexpressions[1]->get_location();
1085 
1086 	       _mesa_glsl_error(& loc, state,
1087 				"RHS of `%s' must be scalar boolean",
1088 				operator_string(this->oper));
1089 	       error_emitted = true;
1090 	    }
1091 	    result = op[1];
1092 	 } else {
1093 	    result = op0_const;
1094 	 }
1095 	 type = glsl_type::bool_type;
1096       } else {
1097 	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
1098 						       "and_tmp",
1099 						       ir_var_temporary);
1100 	 instructions->push_tail(tmp);
1101 
1102 	 ir_if *const stmt = new(ctx) ir_if(op[0]);
1103 	 instructions->push_tail(stmt);
1104 
1105 	 op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state);
1106 
1107 	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
1108 	    YYLTYPE loc = this->subexpressions[1]->get_location();
1109 
1110 	    _mesa_glsl_error(& loc, state,
1111 			     "RHS of `%s' must be scalar boolean",
1112 			     operator_string(this->oper));
1113 	    error_emitted = true;
1114 	 }
1115 
1116 	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
1117 	 ir_assignment *const then_assign =
1118 	    new(ctx) ir_assignment(then_deref, op[1], NULL);
1119 	 stmt->then_instructions.push_tail(then_assign);
1120 
1121 	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
1122 	 ir_assignment *const else_assign =
1123 	    new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false), NULL);
1124 	 stmt->else_instructions.push_tail(else_assign);
1125 
1126 	 result = new(ctx) ir_dereference_variable(tmp);
1127 	 type = tmp->type;
1128       }
1129       break;
1130    }
1131 
1132    case ast_logic_or: {
1133       op[0] = this->subexpressions[0]->hir(instructions, state);
1134 
1135       if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
1136 	 YYLTYPE loc = this->subexpressions[0]->get_location();
1137 
1138 	 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean",
1139 			  operator_string(this->oper));
1140 	 error_emitted = true;
1141       }
1142 
1143       ir_constant *op0_const = op[0]->constant_expression_value();
1144       if (op0_const) {
1145 	 if (op0_const->value.b[0]) {
1146 	    result = op0_const;
1147 	 } else {
1148 	    op[1] = this->subexpressions[1]->hir(instructions, state);
1149 
1150 	    if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
1151 	       YYLTYPE loc = this->subexpressions[1]->get_location();
1152 
1153 	       _mesa_glsl_error(& loc, state,
1154 				"RHS of `%s' must be scalar boolean",
1155 				operator_string(this->oper));
1156 	       error_emitted = true;
1157 	    }
1158 	    result = op[1];
1159 	 }
1160 	 type = glsl_type::bool_type;
1161       } else {
1162 	 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type,
1163 						       "or_tmp",
1164 						       ir_var_temporary);
1165 	 instructions->push_tail(tmp);
1166 
1167 	 ir_if *const stmt = new(ctx) ir_if(op[0]);
1168 	 instructions->push_tail(stmt);
1169 
1170 	 op[1] = this->subexpressions[1]->hir(&stmt->else_instructions, state);
1171 
1172 	 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) {
1173 	    YYLTYPE loc = this->subexpressions[1]->get_location();
1174 
1175 	    _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean",
1176 			     operator_string(this->oper));
1177 	    error_emitted = true;
1178 	 }
1179 
1180 	 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp);
1181 	 ir_assignment *const then_assign =
1182 	    new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true), NULL);
1183 	 stmt->then_instructions.push_tail(then_assign);
1184 
1185 	 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp);
1186 	 ir_assignment *const else_assign =
1187 	    new(ctx) ir_assignment(else_deref, op[1], NULL);
1188 	 stmt->else_instructions.push_tail(else_assign);
1189 
1190 	 result = new(ctx) ir_dereference_variable(tmp);
1191 	 type = tmp->type;
1192       }
1193       break;
1194    }
1195 
1196    case ast_logic_xor:
1197       op[0] = this->subexpressions[0]->hir(instructions, state);
1198       op[1] = this->subexpressions[1]->hir(instructions, state);
1199 
1200 
1201       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
1202 				      op[0], op[1]);
1203       type = glsl_type::bool_type;
1204       break;
1205 
1206    case ast_logic_not:
1207       op[0] = this->subexpressions[0]->hir(instructions, state);
1208 
1209       if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
1210 	 YYLTYPE loc = this->subexpressions[0]->get_location();
1211 
1212 	 _mesa_glsl_error(& loc, state,
1213 			  "operand of `!' must be scalar boolean");
1214 	 error_emitted = true;
1215       }
1216 
1217       result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type,
1218 				      op[0], NULL);
1219       type = glsl_type::bool_type;
1220       break;
1221 
1222    case ast_mul_assign:
1223    case ast_div_assign:
1224    case ast_add_assign:
1225    case ast_sub_assign: {
1226       op[0] = this->subexpressions[0]->hir(instructions, state);
1227       op[1] = this->subexpressions[1]->hir(instructions, state);
1228 
1229       type = arithmetic_result_type(op[0], op[1],
1230 				    (this->oper == ast_mul_assign),
1231 				    state, & loc);
1232 
1233       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
1234 						   op[0], op[1]);
1235 
1236       result = do_assignment(instructions, state,
1237 			     op[0]->clone(ctx, NULL), temp_rhs,
1238 			     this->subexpressions[0]->get_location());
1239       type = result->type;
1240       error_emitted = (op[0]->type->is_error());
1241 
1242       /* GLSL 1.10 does not allow array assignment.  However, we don't have to
1243        * explicitly test for this because none of the binary expression
1244        * operators allow array operands either.
1245        */
1246 
1247       break;
1248    }
1249 
1250    case ast_mod_assign: {
1251       op[0] = this->subexpressions[0]->hir(instructions, state);
1252       op[1] = this->subexpressions[1]->hir(instructions, state);
1253 
1254       type = modulus_result_type(op[0]->type, op[1]->type, state, & loc);
1255 
1256       assert(operations[this->oper] == ir_binop_mod);
1257 
1258       ir_rvalue *temp_rhs;
1259       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
1260 					op[0], op[1]);
1261 
1262       result = do_assignment(instructions, state,
1263 			     op[0]->clone(ctx, NULL), temp_rhs,
1264 			     this->subexpressions[0]->get_location());
1265       type = result->type;
1266       error_emitted = type->is_error();
1267       break;
1268    }
1269 
1270    case ast_ls_assign:
1271    case ast_rs_assign: {
1272       op[0] = this->subexpressions[0]->hir(instructions, state);
1273       op[1] = this->subexpressions[1]->hir(instructions, state);
1274       type = shift_result_type(op[0]->type, op[1]->type, this->oper, state,
1275                                &loc);
1276       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
1277                                                    type, op[0], op[1]);
1278       result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),
1279                              temp_rhs,
1280                              this->subexpressions[0]->get_location());
1281       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
1282       break;
1283    }
1284 
1285    case ast_and_assign:
1286    case ast_xor_assign:
1287    case ast_or_assign: {
1288       op[0] = this->subexpressions[0]->hir(instructions, state);
1289       op[1] = this->subexpressions[1]->hir(instructions, state);
1290       type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper,
1291                                    state, &loc);
1292       ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper],
1293                                                    type, op[0], op[1]);
1294       result = do_assignment(instructions, state, op[0]->clone(ctx, NULL),
1295                              temp_rhs,
1296                              this->subexpressions[0]->get_location());
1297       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
1298       break;
1299    }
1300 
1301    case ast_conditional: {
1302       op[0] = this->subexpressions[0]->hir(instructions, state);
1303 
1304       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
1305        *
1306        *    "The ternary selection operator (?:). It operates on three
1307        *    expressions (exp1 ? exp2 : exp3). This operator evaluates the
1308        *    first expression, which must result in a scalar Boolean."
1309        */
1310       if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) {
1311 	 YYLTYPE loc = this->subexpressions[0]->get_location();
1312 
1313 	 _mesa_glsl_error(& loc, state, "?: condition must be scalar boolean");
1314 	 error_emitted = true;
1315       }
1316 
1317       /* The :? operator is implemented by generating an anonymous temporary
1318        * followed by an if-statement.  The last instruction in each branch of
1319        * the if-statement assigns a value to the anonymous temporary.  This
1320        * temporary is the r-value of the expression.
1321        */
1322       exec_list then_instructions;
1323       exec_list else_instructions;
1324 
1325       op[1] = this->subexpressions[1]->hir(&then_instructions, state);
1326       op[2] = this->subexpressions[2]->hir(&else_instructions, state);
1327 
1328       /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
1329        *
1330        *     "The second and third expressions can be any type, as
1331        *     long their types match, or there is a conversion in
1332        *     Section 4.1.10 "Implicit Conversions" that can be applied
1333        *     to one of the expressions to make their types match. This
1334        *     resulting matching type is the type of the entire
1335        *     expression."
1336        */
1337       if ((!apply_implicit_conversion(op[1]->type, op[2], state)
1338 	   && !apply_implicit_conversion(op[2]->type, op[1], state))
1339 	  || (op[1]->type != op[2]->type)) {
1340 	 YYLTYPE loc = this->subexpressions[1]->get_location();
1341 
1342 	 _mesa_glsl_error(& loc, state, "Second and third operands of ?: "
1343 			  "operator must have matching types.");
1344 	 error_emitted = true;
1345 	 type = glsl_type::error_type;
1346       } else {
1347 	 type = op[1]->type;
1348       }
1349 
1350       /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec:
1351        *
1352        *    "The second and third expressions must be the same type, but can
1353        *    be of any type other than an array."
1354        */
1355       if ((state->language_version <= 110) && type->is_array()) {
1356 	 _mesa_glsl_error(& loc, state, "Second and third operands of ?: "
1357 			  "operator must not be arrays.");
1358 	 error_emitted = true;
1359       }
1360 
1361       ir_constant *cond_val = op[0]->constant_expression_value();
1362       ir_constant *then_val = op[1]->constant_expression_value();
1363       ir_constant *else_val = op[2]->constant_expression_value();
1364 
1365       if (then_instructions.is_empty()
1366 	  && else_instructions.is_empty()
1367 	  && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) {
1368 	 result = (cond_val->value.b[0]) ? then_val : else_val;
1369       } else {
1370 	 ir_variable *const tmp =
1371 	    new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary);
1372 	 instructions->push_tail(tmp);
1373 
1374 	 ir_if *const stmt = new(ctx) ir_if(op[0]);
1375 	 instructions->push_tail(stmt);
1376 
1377 	 then_instructions.move_nodes_to(& stmt->then_instructions);
1378 	 ir_dereference *const then_deref =
1379 	    new(ctx) ir_dereference_variable(tmp);
1380 	 ir_assignment *const then_assign =
1381 	    new(ctx) ir_assignment(then_deref, op[1], NULL);
1382 	 stmt->then_instructions.push_tail(then_assign);
1383 
1384 	 else_instructions.move_nodes_to(& stmt->else_instructions);
1385 	 ir_dereference *const else_deref =
1386 	    new(ctx) ir_dereference_variable(tmp);
1387 	 ir_assignment *const else_assign =
1388 	    new(ctx) ir_assignment(else_deref, op[2], NULL);
1389 	 stmt->else_instructions.push_tail(else_assign);
1390 
1391 	 result = new(ctx) ir_dereference_variable(tmp);
1392       }
1393       break;
1394    }
1395 
1396    case ast_pre_inc:
1397    case ast_pre_dec: {
1398       op[0] = this->subexpressions[0]->hir(instructions, state);
1399       if (op[0]->type->base_type == GLSL_TYPE_FLOAT)
1400 	 op[1] = new(ctx) ir_constant(1.0f);
1401       else
1402 	 op[1] = new(ctx) ir_constant(1);
1403 
1404       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
1405 
1406       ir_rvalue *temp_rhs;
1407       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
1408 					op[0], op[1]);
1409 
1410       result = do_assignment(instructions, state,
1411 			     op[0]->clone(ctx, NULL), temp_rhs,
1412 			     this->subexpressions[0]->get_location());
1413       type = result->type;
1414       error_emitted = op[0]->type->is_error();
1415       break;
1416    }
1417 
1418    case ast_post_inc:
1419    case ast_post_dec: {
1420       op[0] = this->subexpressions[0]->hir(instructions, state);
1421       if (op[0]->type->base_type == GLSL_TYPE_FLOAT)
1422 	 op[1] = new(ctx) ir_constant(1.0f);
1423       else
1424 	 op[1] = new(ctx) ir_constant(1);
1425 
1426       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
1427 
1428       type = arithmetic_result_type(op[0], op[1], false, state, & loc);
1429 
1430       ir_rvalue *temp_rhs;
1431       temp_rhs = new(ctx) ir_expression(operations[this->oper], type,
1432 					op[0], op[1]);
1433 
1434       /* Get a temporary of a copy of the lvalue before it's modified.
1435        * This may get thrown away later.
1436        */
1437       result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
1438 
1439       (void)do_assignment(instructions, state,
1440 			  op[0]->clone(ctx, NULL), temp_rhs,
1441 			  this->subexpressions[0]->get_location());
1442 
1443       type = result->type;
1444       error_emitted = op[0]->type->is_error();
1445       break;
1446    }
1447 
1448    case ast_field_selection:
1449       result = _mesa_ast_field_selection_to_hir(this, instructions, state);
1450       type = result->type;
1451       break;
1452 
1453    case ast_array_index: {
1454       YYLTYPE index_loc = subexpressions[1]->get_location();
1455 
1456       op[0] = subexpressions[0]->hir(instructions, state);
1457       op[1] = subexpressions[1]->hir(instructions, state);
1458 
1459       error_emitted = op[0]->type->is_error() || op[1]->type->is_error();
1460 
1461       ir_rvalue *const array = op[0];
1462 
1463       result = new(ctx) ir_dereference_array(op[0], op[1]);
1464 
1465       /* Do not use op[0] after this point.  Use array.
1466        */
1467       op[0] = NULL;
1468 
1469 
1470       if (error_emitted)
1471 	 break;
1472 
1473       if (!array->type->is_array()
1474 	  && !array->type->is_matrix()
1475 	  && !array->type->is_vector()) {
1476 	 _mesa_glsl_error(& index_loc, state,
1477 			  "cannot dereference non-array / non-matrix / "
1478 			  "non-vector");
1479 	 error_emitted = true;
1480       }
1481 
1482       if (!op[1]->type->is_integer()) {
1483 	 _mesa_glsl_error(& index_loc, state,
1484 			  "array index must be integer type");
1485 	 error_emitted = true;
1486       } else if (!op[1]->type->is_scalar()) {
1487 	 _mesa_glsl_error(& index_loc, state,
1488 			  "array index must be scalar");
1489 	 error_emitted = true;
1490       }
1491 
1492       /* If the array index is a constant expression and the array has a
1493        * declared size, ensure that the access is in-bounds.  If the array
1494        * index is not a constant expression, ensure that the array has a
1495        * declared size.
1496        */
1497       ir_constant *const const_index = op[1]->constant_expression_value();
1498       if (const_index != NULL) {
1499 	 const int idx = const_index->value.i[0];
1500 	 const char *type_name;
1501 	 unsigned bound = 0;
1502 
1503 	 if (array->type->is_matrix()) {
1504 	    type_name = "matrix";
1505 	 } else if (array->type->is_vector()) {
1506 	    type_name = "vector";
1507 	 } else {
1508 	    type_name = "array";
1509 	 }
1510 
1511 	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec:
1512 	  *
1513 	  *    "It is illegal to declare an array with a size, and then
1514 	  *    later (in the same shader) index the same array with an
1515 	  *    integral constant expression greater than or equal to the
1516 	  *    declared size. It is also illegal to index an array with a
1517 	  *    negative constant expression."
1518 	  */
1519 	 if (array->type->is_matrix()) {
1520 	    if (array->type->row_type()->vector_elements <= idx) {
1521 	       bound = array->type->row_type()->vector_elements;
1522 	    }
1523 	 } else if (array->type->is_vector()) {
1524 	    if (array->type->vector_elements <= idx) {
1525 	       bound = array->type->vector_elements;
1526 	    }
1527 	 } else {
1528 	    if ((array->type->array_size() > 0)
1529 		&& (array->type->array_size() <= idx)) {
1530 	       bound = array->type->array_size();
1531 	    }
1532 	 }
1533 
1534 	 if (bound > 0) {
1535 	    _mesa_glsl_error(& loc, state, "%s index must be < %u",
1536 			     type_name, bound);
1537 	    error_emitted = true;
1538 	 } else if (idx < 0) {
1539 	    _mesa_glsl_error(& loc, state, "%s index must be >= 0",
1540 			     type_name);
1541 	    error_emitted = true;
1542 	 }
1543 
1544 	 if (array->type->is_array()) {
1545 	    /* If the array is a variable dereference, it dereferences the
1546 	     * whole array, by definition.  Use this to get the variable.
1547 	     *
1548 	     * FINISHME: Should some methods for getting / setting / testing
1549 	     * FINISHME: array access limits be added to ir_dereference?
1550 	     */
1551 	    ir_variable *const v = array->whole_variable_referenced();
1552 	    if ((v != NULL) && (unsigned(idx) > v->max_array_access))
1553 	       v->max_array_access = idx;
1554 	 }
1555       } else if (array->type->array_size() == 0) {
1556 	 _mesa_glsl_error(&loc, state, "unsized array index must be constant");
1557       } else {
1558 	 if (array->type->is_array()) {
1559 	    /* whole_variable_referenced can return NULL if the array is a
1560 	     * member of a structure.  In this case it is safe to not update
1561 	     * the max_array_access field because it is never used for fields
1562 	     * of structures.
1563 	     */
1564 	    ir_variable *v = array->whole_variable_referenced();
1565 	    if (v != NULL)
1566 	       v->max_array_access = array->type->array_size();
1567           // TODO: should this be array->type->array_size() - 1
1568 	 }
1569       }
1570 
1571       /* From page 23 (29 of the PDF) of the GLSL 1.30 spec:
1572        *
1573        *    "Samplers aggregated into arrays within a shader (using square
1574        *    brackets [ ]) can only be indexed with integral constant
1575        *    expressions [...]."
1576        *
1577        * This restriction was added in GLSL 1.30.  Shaders using earlier version
1578        * of the language should not be rejected by the compiler front-end for
1579        * using this construct.  This allows useful things such as using a loop
1580        * counter as the index to an array of samplers.  If the loop in unrolled,
1581        * the code should compile correctly.  Instead, emit a warning.
1582        */
1583       if (array->type->is_array() &&
1584           array->type->element_type()->is_sampler() &&
1585           const_index == NULL) {
1586 
1587 	 if (state->language_version == 100) {
1588 	    _mesa_glsl_warning(&loc, state,
1589 			       "sampler arrays indexed with non-constant "
1590 			       "expressions is optional in GLSL ES 1.00");
1591 	 } else if (state->language_version < 130) {
1592 	    _mesa_glsl_warning(&loc, state,
1593 			       "sampler arrays indexed with non-constant "
1594 			       "expressions is forbidden in GLSL 1.30 and "
1595 			       "later");
1596 	 } else {
1597 	    _mesa_glsl_error(&loc, state,
1598 			     "sampler arrays indexed with non-constant "
1599 			     "expressions is forbidden in GLSL 1.30 and "
1600 			     "later");
1601 	    error_emitted = true;
1602 	 }
1603       }
1604 
1605       if (error_emitted)
1606 	 result->type = glsl_type::error_type;
1607 
1608       type = result->type;
1609       break;
1610    }
1611 
1612    case ast_function_call:
1613       /* Should *NEVER* get here.  ast_function_call should always be handled
1614        * by ast_function_expression::hir.
1615        */
1616       assert(0);
1617       break;
1618 
1619    case ast_identifier: {
1620       /* ast_identifier can appear several places in a full abstract syntax
1621        * tree.  This particular use must be at location specified in the grammar
1622        * as 'variable_identifier'.
1623        */
1624       ir_variable *var =
1625 	 state->symbols->get_variable(this->primary_expression.identifier);
1626 
1627       result = new(ctx) ir_dereference_variable(var);
1628 
1629       if (var != NULL) {
1630 	 type = result->type;
1631       } else {
1632 	 _mesa_glsl_error(& loc, state, "`%s' undeclared",
1633 			  this->primary_expression.identifier);
1634 
1635 	 error_emitted = true;
1636       }
1637       break;
1638    }
1639 
1640    case ast_int_constant:
1641       type = glsl_type::int_type;
1642       result = new(ctx) ir_constant(this->primary_expression.int_constant);
1643       break;
1644 
1645    case ast_uint_constant:
1646       type = glsl_type::uint_type;
1647       result = new(ctx) ir_constant(this->primary_expression.uint_constant);
1648       break;
1649 
1650    case ast_float_constant:
1651       type = glsl_type::float_type;
1652       result = new(ctx) ir_constant(this->primary_expression.float_constant);
1653       break;
1654 
1655    case ast_bool_constant:
1656       type = glsl_type::bool_type;
1657       result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant));
1658       break;
1659 
1660    case ast_sequence: {
1661       /* It should not be possible to generate a sequence in the AST without
1662        * any expressions in it.
1663        */
1664       assert(!this->expressions.is_empty());
1665 
1666       /* The r-value of a sequence is the last expression in the sequence.  If
1667        * the other expressions in the sequence do not have side-effects (and
1668        * therefore add instructions to the instruction list), they get dropped
1669        * on the floor.
1670        */
1671       foreach_list_typed (ast_node, ast, link, &this->expressions)
1672 	 result = ast->hir(instructions, state);
1673 
1674       type = result->type;
1675 
1676       /* Any errors should have already been emitted in the loop above.
1677        */
1678       error_emitted = true;
1679       break;
1680    }
1681    }
1682 
1683    if (type->is_error() && !error_emitted)
1684       _mesa_glsl_error(& loc, state, "type mismatch");
1685 
1686    return result;
1687 }
1688 
1689 
1690 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)1691 ast_expression_statement::hir(exec_list *instructions,
1692 			      struct _mesa_glsl_parse_state *state)
1693 {
1694    /* It is possible to have expression statements that don't have an
1695     * expression.  This is the solitary semicolon:
1696     *
1697     * for (i = 0; i < 5; i++)
1698     *     ;
1699     *
1700     * In this case the expression will be NULL.  Test for NULL and don't do
1701     * anything in that case.
1702     */
1703    if (expression != NULL)
1704       expression->hir(instructions, state);
1705 
1706    /* Statements do not have r-values.
1707     */
1708    return NULL;
1709 }
1710 
1711 
1712 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)1713 ast_compound_statement::hir(exec_list *instructions,
1714 			    struct _mesa_glsl_parse_state *state)
1715 {
1716    if (new_scope)
1717       state->symbols->push_scope();
1718 
1719    foreach_list_typed (ast_node, ast, link, &this->statements)
1720       ast->hir(instructions, state);
1721 
1722    if (new_scope)
1723       state->symbols->pop_scope();
1724 
1725    /* Compound statements do not have r-values.
1726     */
1727    return NULL;
1728 }
1729 
1730 
1731 static const glsl_type *
process_array_type(YYLTYPE * loc,const glsl_type * base,ast_node * array_size,struct _mesa_glsl_parse_state * state)1732 process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size,
1733 		   struct _mesa_glsl_parse_state *state)
1734 {
1735    unsigned length = 0;
1736 
1737    /* FINISHME: Reject delcarations of multidimensional arrays. */
1738 
1739    if (array_size != NULL) {
1740       exec_list dummy_instructions;
1741       ir_rvalue *const ir = array_size->hir(& dummy_instructions, state);
1742       YYLTYPE loc = array_size->get_location();
1743 
1744       /* FINISHME: Verify that the grammar forbids side-effects in array
1745        * FINISHME: sizes.   i.e., 'vec4 [x = 12] data'
1746        */
1747       assert(dummy_instructions.is_empty());
1748 
1749       if (ir != NULL) {
1750 	 if (!ir->type->is_integer()) {
1751 	    _mesa_glsl_error(& loc, state, "array size must be integer type");
1752 	 } else if (!ir->type->is_scalar()) {
1753 	    _mesa_glsl_error(& loc, state, "array size must be scalar type");
1754 	 } else {
1755 	    ir_constant *const size = ir->constant_expression_value();
1756 
1757 	    if (size == NULL) {
1758 	       _mesa_glsl_error(& loc, state, "array size must be a "
1759 				"constant valued expression");
1760 	    } else if (size->value.i[0] <= 0) {
1761 	       _mesa_glsl_error(& loc, state, "array size must be > 0");
1762 	    } else {
1763 	       assert(size->type == ir->type);
1764 	       length = size->value.u[0];
1765 	    }
1766 	 }
1767       }
1768    } else if (state->es_shader) {
1769       /* Section 10.17 of the GLSL ES 1.00 specification states that unsized
1770        * array declarations have been removed from the language.
1771        */
1772       _mesa_glsl_error(loc, state, "unsized array declarations are not "
1773 		       "allowed in GLSL ES 1.00.");
1774    }
1775 
1776    return glsl_type::get_array_instance(base, length);
1777 }
1778 
1779 
1780 const glsl_type *
glsl_type(const char ** name,struct _mesa_glsl_parse_state * state) const1781 ast_type_specifier::glsl_type(const char **name,
1782 			      struct _mesa_glsl_parse_state *state) const
1783 {
1784    const struct glsl_type *type;
1785 
1786    type = state->symbols->get_type(this->type_name);
1787    *name = this->type_name;
1788 
1789    if (this->is_array) {
1790       YYLTYPE loc = this->get_location();
1791       type = process_array_type(&loc, type, this->array_size, state);
1792    }
1793 
1794    return type;
1795 }
1796 
1797 
1798 static void
apply_type_qualifier_to_variable(const struct ast_type_qualifier * qual,ir_variable * var,struct _mesa_glsl_parse_state * state,YYLTYPE * loc)1799 apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
1800 				 ir_variable *var,
1801 				 struct _mesa_glsl_parse_state *state,
1802 				 YYLTYPE *loc)
1803 {
1804    if (qual->flags.q.invariant)
1805       var->invariant = 1;
1806 
1807    /* FINISHME: Mark 'in' variables at global scope as read-only. */
1808    if (qual->flags.q.constant || qual->flags.q.attribute
1809        || qual->flags.q.uniform
1810        || (qual->flags.q.varying && (state->target == fragment_shader)))
1811       var->read_only = 1;
1812 
1813    if (qual->flags.q.centroid)
1814       var->centroid = 1;
1815 
1816    if (qual->flags.q.attribute && state->target != vertex_shader) {
1817       var->type = glsl_type::error_type;
1818       _mesa_glsl_error(loc, state,
1819 		       "`attribute' variables may not be declared in the "
1820 		       "%s shader",
1821 		       _mesa_glsl_shader_target_name(state->target));
1822    }
1823 
1824    /* From page 25 (page 31 of the PDF) of the GLSL 1.10 spec:
1825     *
1826     *     "The varying qualifier can be used only with the data types
1827     *     float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of
1828     *     these."
1829     */
1830    if (qual->flags.q.varying) {
1831       const glsl_type *non_array_type;
1832 
1833       if (var->type && var->type->is_array())
1834 	 non_array_type = var->type->fields.array;
1835       else
1836 	 non_array_type = var->type;
1837 
1838       if (non_array_type && non_array_type->base_type != GLSL_TYPE_FLOAT) {
1839 	 var->type = glsl_type::error_type;
1840 	 _mesa_glsl_error(loc, state,
1841 			  "varying variables must be of base type float");
1842       }
1843    }
1844 
1845    /* If there is no qualifier that changes the mode of the variable, leave
1846     * the setting alone.
1847     */
1848    if (qual->flags.q.in && qual->flags.q.out)
1849       var->mode = ir_var_inout;
1850    else if (qual->flags.q.attribute || qual->flags.q.in
1851 	    || (qual->flags.q.varying && (state->target == fragment_shader)))
1852       var->mode = ir_var_in;
1853    else if (qual->flags.q.out
1854 	    || (qual->flags.q.varying && (state->target == vertex_shader)))
1855       var->mode = ir_var_out;
1856    else if (qual->flags.q.uniform)
1857       var->mode = ir_var_uniform;
1858 
1859    if (qual->flags.q.flat)
1860       var->interpolation = ir_var_flat;
1861    else if (qual->flags.q.noperspective)
1862       var->interpolation = ir_var_noperspective;
1863    else
1864       var->interpolation = ir_var_smooth;
1865 
1866    var->pixel_center_integer = qual->flags.q.pixel_center_integer;
1867    var->origin_upper_left = qual->flags.q.origin_upper_left;
1868    if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer)
1869        && (strcmp(var->name, "gl_FragCoord") != 0)) {
1870       const char *const qual_string = (qual->flags.q.origin_upper_left)
1871 	 ? "origin_upper_left" : "pixel_center_integer";
1872 
1873       _mesa_glsl_error(loc, state,
1874 		       "layout qualifier `%s' can only be applied to "
1875 		       "fragment shader input `gl_FragCoord'",
1876 		       qual_string);
1877    }
1878 
1879    if (qual->flags.q.explicit_location) {
1880       const bool global_scope = (state->current_function == NULL);
1881       bool fail = false;
1882       const char *string = "";
1883 
1884       /* In the vertex shader only shader inputs can be given explicit
1885        * locations.
1886        *
1887        * In the fragment shader only shader outputs can be given explicit
1888        * locations.
1889        */
1890       switch (state->target) {
1891       case vertex_shader:
1892 	 if (!global_scope || (var->mode != ir_var_in)) {
1893 	    fail = true;
1894 	    string = "input";
1895 	 }
1896 	 break;
1897 
1898       case geometry_shader:
1899 	 _mesa_glsl_error(loc, state,
1900 			  "geometry shader variables cannot be given "
1901 			  "explicit locations\n");
1902 	 break;
1903 
1904       case fragment_shader:
1905 	 if (!global_scope || (var->mode != ir_var_in)) {
1906 	    fail = true;
1907 	    string = "output";
1908 	 }
1909 	 break;
1910       };
1911 
1912       if (fail) {
1913 	 _mesa_glsl_error(loc, state,
1914 			  "only %s shader %s variables can be given an "
1915 			  "explicit location\n",
1916 			  _mesa_glsl_shader_target_name(state->target),
1917 			  string);
1918       } else {
1919 	 var->explicit_location = true;
1920 
1921 	 /* This bit of silliness is needed because invalid explicit locations
1922 	  * are supposed to be flagged during linking.  Small negative values
1923 	  * biased by VERT_ATTRIB_GENERIC0 or FRAG_RESULT_DATA0 could alias
1924 	  * built-in values (e.g., -16+VERT_ATTRIB_GENERIC0 = VERT_ATTRIB_POS).
1925 	  * The linker needs to be able to differentiate these cases.  This
1926 	  * ensures that negative values stay negative.
1927 	  */
1928 	 if (qual->location >= 0) {
1929 	    var->location = (state->target == vertex_shader)
1930 	       ? (qual->location + VERT_ATTRIB_GENERIC0)
1931 	       : (qual->location + FRAG_RESULT_DATA0);
1932 	 } else {
1933 	    var->location = qual->location;
1934 	 }
1935       }
1936    }
1937 
1938    if (var->type->is_array() && state->language_version != 110) {
1939       var->array_lvalue = true;
1940    }
1941 }
1942 
1943 
1944 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)1945 ast_declarator_list::hir(exec_list *instructions,
1946 			 struct _mesa_glsl_parse_state *state)
1947 {
1948    void *ctx = state;
1949    const struct glsl_type *decl_type;
1950    const char *type_name = NULL;
1951    ir_rvalue *result = NULL;
1952    YYLTYPE loc = this->get_location();
1953 
1954    /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec:
1955     *
1956     *     "To ensure that a particular output variable is invariant, it is
1957     *     necessary to use the invariant qualifier. It can either be used to
1958     *     qualify a previously declared variable as being invariant
1959     *
1960     *         invariant gl_Position; // make existing gl_Position be invariant"
1961     *
1962     * In these cases the parser will set the 'invariant' flag in the declarator
1963     * list, and the type will be NULL.
1964     */
1965    if (this->invariant) {
1966       assert(this->type == NULL);
1967 
1968       if (state->current_function != NULL) {
1969 	 _mesa_glsl_error(& loc, state,
1970 			  "All uses of `invariant' keyword must be at global "
1971 			  "scope\n");
1972       }
1973 
1974       foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
1975 	 assert(!decl->is_array);
1976 	 assert(decl->array_size == NULL);
1977 	 assert(decl->initializer == NULL);
1978 
1979 	 ir_variable *const earlier =
1980 	    state->symbols->get_variable(decl->identifier);
1981 	 if (earlier == NULL) {
1982 	    _mesa_glsl_error(& loc, state,
1983 			     "Undeclared variable `%s' cannot be marked "
1984 			     "invariant\n", decl->identifier);
1985 	 } else if ((state->target == vertex_shader)
1986 	       && (earlier->mode != ir_var_out)) {
1987 	    _mesa_glsl_error(& loc, state,
1988 			     "`%s' cannot be marked invariant, vertex shader "
1989 			     "outputs only\n", decl->identifier);
1990 	 } else if ((state->target == fragment_shader)
1991 	       && (earlier->mode != ir_var_in)) {
1992 	    _mesa_glsl_error(& loc, state,
1993 			     "`%s' cannot be marked invariant, fragment shader "
1994 			     "inputs only\n", decl->identifier);
1995 	 } else {
1996 	    earlier->invariant = true;
1997 	 }
1998       }
1999 
2000       /* Invariant redeclarations do not have r-values.
2001        */
2002       return NULL;
2003    }
2004 
2005    assert(this->type != NULL);
2006    assert(!this->invariant);
2007 
2008    /* The type specifier may contain a structure definition.  Process that
2009     * before any of the variable declarations.
2010     */
2011    (void) this->type->specifier->hir(instructions, state);
2012 
2013    decl_type = this->type->specifier->glsl_type(& type_name, state);
2014    if (this->declarations.is_empty()) {
2015       /* The only valid case where the declaration list can be empty is when
2016        * the declaration is setting the default precision of a built-in type
2017        * (e.g., 'precision highp vec4;').
2018        */
2019 
2020       if (decl_type != NULL) {
2021       } else {
2022 	    _mesa_glsl_error(& loc, state, "incomplete declaration");
2023       }
2024    }
2025 
2026    foreach_list_typed (ast_declaration, decl, link, &this->declarations) {
2027       const struct glsl_type *var_type;
2028       ir_variable *var;
2029 
2030       /* FINISHME: Emit a warning if a variable declaration shadows a
2031        * FINISHME: declaration at a higher scope.
2032        */
2033 
2034       if ((decl_type == NULL) || decl_type->is_void()) {
2035 	 if (type_name != NULL) {
2036 	    _mesa_glsl_error(& loc, state,
2037 			     "invalid type `%s' in declaration of `%s'",
2038 			     type_name, decl->identifier);
2039 	 } else {
2040 	    _mesa_glsl_error(& loc, state,
2041 			     "invalid type in declaration of `%s'",
2042 			     decl->identifier);
2043 	 }
2044 	 continue;
2045       }
2046 
2047       if (decl->is_array) {
2048 	 var_type = process_array_type(&loc, decl_type, decl->array_size,
2049 				       state);
2050       } else {
2051 	 var_type = decl_type;
2052       }
2053 
2054       var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto);
2055 
2056       /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification;
2057        *
2058        *     "Global variables can only use the qualifiers const,
2059        *     attribute, uni form, or varying. Only one may be
2060        *     specified.
2061        *
2062        *     Local variables can only use the qualifier const."
2063        *
2064        * This is relaxed in GLSL 1.30.
2065        */
2066       if (state->language_version < 120) {
2067 	 if (this->type->qualifier.flags.q.out) {
2068 	    _mesa_glsl_error(& loc, state,
2069 			     "`out' qualifier in declaration of `%s' "
2070 			     "only valid for function parameters in GLSL 1.10.",
2071 			     decl->identifier);
2072 	 }
2073 	 if (this->type->qualifier.flags.q.in) {
2074 	    _mesa_glsl_error(& loc, state,
2075 			     "`in' qualifier in declaration of `%s' "
2076 			     "only valid for function parameters in GLSL 1.10.",
2077 			     decl->identifier);
2078 	 }
2079 	 /* FINISHME: Test for other invalid qualifiers. */
2080       }
2081 
2082       apply_type_qualifier_to_variable(& this->type->qualifier, var, state,
2083 				       & loc);
2084 
2085       if (this->type->qualifier.flags.q.invariant) {
2086 	 if ((state->target == vertex_shader) && !(var->mode == ir_var_out ||
2087 						   var->mode == ir_var_inout)) {
2088 	    /* FINISHME: Note that this doesn't work for invariant on
2089 	     * a function signature outval
2090 	     */
2091 	    _mesa_glsl_error(& loc, state,
2092 			     "`%s' cannot be marked invariant, vertex shader "
2093 			     "outputs only\n", var->name);
2094 	 } else if ((state->target == fragment_shader) &&
2095 		    !(var->mode == ir_var_in || var->mode == ir_var_inout)) {
2096 	    /* FINISHME: Note that this doesn't work for invariant on
2097 	     * a function signature inval
2098 	     */
2099 	    _mesa_glsl_error(& loc, state,
2100 			     "`%s' cannot be marked invariant, fragment shader "
2101 			     "inputs only\n", var->name);
2102 	 }
2103       }
2104 
2105       if (state->current_function != NULL) {
2106 	 const char *mode = NULL;
2107 	 const char *extra = "";
2108 
2109 	 /* There is no need to check for 'inout' here because the parser will
2110 	  * only allow that in function parameter lists.
2111 	  */
2112 	 if (this->type->qualifier.flags.q.attribute) {
2113 	    mode = "attribute";
2114 	 } else if (this->type->qualifier.flags.q.uniform) {
2115 	    mode = "uniform";
2116 	 } else if (this->type->qualifier.flags.q.varying) {
2117 	    mode = "varying";
2118 	 } else if (this->type->qualifier.flags.q.in) {
2119 	    mode = "in";
2120 	    extra = " or in function parameter list";
2121 	 } else if (this->type->qualifier.flags.q.out) {
2122 	    mode = "out";
2123 	    extra = " or in function parameter list";
2124 	 }
2125 
2126 	 if (mode) {
2127 	    _mesa_glsl_error(& loc, state,
2128 			     "%s variable `%s' must be declared at "
2129 			     "global scope%s",
2130 			     mode, var->name, extra);
2131 	 }
2132       } else if (var->mode == ir_var_in) {
2133 	 if (state->target == vertex_shader) {
2134 	    bool error_emitted = false;
2135 
2136 	    /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
2137 	     *
2138 	     *    "Vertex shader inputs can only be float, floating-point
2139 	     *    vectors, matrices, signed and unsigned integers and integer
2140 	     *    vectors. Vertex shader inputs can also form arrays of these
2141 	     *    types, but not structures."
2142 	     *
2143 	     * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
2144 	     *
2145 	     *    "Vertex shader inputs can only be float, floating-point
2146 	     *    vectors, matrices, signed and unsigned integers and integer
2147 	     *    vectors. They cannot be arrays or structures."
2148 	     *
2149 	     * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
2150 	     *
2151 	     *    "The attribute qualifier can be used only with float,
2152 	     *    floating-point vectors, and matrices. Attribute variables
2153 	     *    cannot be declared as arrays or structures."
2154 	     */
2155 	    const glsl_type *check_type = var->type->is_array()
2156 	       ? var->type->fields.array : var->type;
2157 
2158 	    switch (check_type->base_type) {
2159 	    case GLSL_TYPE_FLOAT:
2160 	       break;
2161 	    case GLSL_TYPE_UINT:
2162 	    case GLSL_TYPE_INT:
2163 	       if (state->language_version > 120)
2164 		  break;
2165 	       /* FALLTHROUGH */
2166 	    default:
2167 	       _mesa_glsl_error(& loc, state,
2168 				"vertex shader input / attribute cannot have "
2169 				"type %s`%s'",
2170 				var->type->is_array() ? "array of " : "",
2171 				check_type->name);
2172 	       error_emitted = true;
2173 	    }
2174 
2175 	    if (!error_emitted && (state->language_version <= 130)
2176 		&& var->type->is_array()) {
2177 	       _mesa_glsl_error(& loc, state,
2178 				"vertex shader input / attribute cannot have "
2179 				"array type");
2180 	       error_emitted = true;
2181 	    }
2182 	 }
2183       }
2184 
2185       /* Process the initializer and add its instructions to a temporary
2186        * list.  This list will be added to the instruction stream (below) after
2187        * the declaration is added.  This is done because in some cases (such as
2188        * redeclarations) the declaration may not actually be added to the
2189        * instruction stream.
2190        */
2191       exec_list initializer_instructions;
2192       if (decl->initializer != NULL) {
2193 	 YYLTYPE initializer_loc = decl->initializer->get_location();
2194 
2195 	 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:
2196 	  *
2197 	  *    "All uniform variables are read-only and are initialized either
2198 	  *    directly by an application via API commands, or indirectly by
2199 	  *    OpenGL."
2200 	  */
2201 	 if ((state->language_version <= 110)
2202 	     && (var->mode == ir_var_uniform)) {
2203 	    _mesa_glsl_error(& initializer_loc, state,
2204 			     "cannot initialize uniforms in GLSL 1.10");
2205 	 }
2206 
2207 	 if (var->type->is_sampler()) {
2208 	    _mesa_glsl_error(& initializer_loc, state,
2209 			     "cannot initialize samplers");
2210 	 }
2211 
2212 	 if ((var->mode == ir_var_in) && (state->current_function == NULL)) {
2213 	    _mesa_glsl_error(& initializer_loc, state,
2214 			     "cannot initialize %s shader input / %s",
2215 			     _mesa_glsl_shader_target_name(state->target),
2216 			     (state->target == vertex_shader)
2217 			     ? "attribute" : "varying");
2218 	 }
2219 
2220 	 ir_dereference *const lhs = new(ctx) ir_dereference_variable(var);
2221 	 ir_rvalue *rhs = decl->initializer->hir(&initializer_instructions,
2222 						 state);
2223 
2224 	 /* Calculate the constant value if this is a const or uniform
2225 	  * declaration.
2226 	  */
2227 	 if (this->type->qualifier.flags.q.constant
2228 	     || this->type->qualifier.flags.q.uniform) {
2229 	    ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs);
2230 	    if (new_rhs != NULL) {
2231 	       rhs = new_rhs;
2232 
2233 	       ir_constant *constant_value = rhs->constant_expression_value();
2234 	       if (!constant_value) {
2235 		  _mesa_glsl_error(& initializer_loc, state,
2236 				   "initializer of %s variable `%s' must be a "
2237 				   "constant expression",
2238 				   (this->type->qualifier.flags.q.constant)
2239 				   ? "const" : "uniform",
2240 				   decl->identifier);
2241 		  if (var->type->is_numeric()) {
2242 		     /* Reduce cascading errors. */
2243 		     var->constant_value = ir_constant::zero(ctx, var->type);
2244 		  }
2245 	       } else {
2246 		  rhs = constant_value;
2247 		  var->constant_value = constant_value;
2248 	       }
2249 	    } else {
2250 	       _mesa_glsl_error(&initializer_loc, state,
2251 			        "initializer of type %s cannot be assigned to "
2252 				"variable of type %s",
2253 				rhs->type->name, var->type->name);
2254 	       if (var->type->is_numeric()) {
2255 		  /* Reduce cascading errors. */
2256 		  var->constant_value = ir_constant::zero(ctx, var->type);
2257 	       }
2258 	    }
2259 	 }
2260 
2261 	 if (rhs && !rhs->type->is_error()) {
2262 	    bool temp = var->read_only;
2263 	    if (this->type->qualifier.flags.q.constant)
2264 	       var->read_only = false;
2265 
2266 	    /* Never emit code to initialize a uniform.
2267 	     */
2268 	    const glsl_type *initializer_type;
2269 	    if (!this->type->qualifier.flags.q.uniform) {
2270 	       result = do_assignment(&initializer_instructions, state,
2271 				      lhs, rhs,
2272 				      this->get_location());
2273 	       initializer_type = result->type;
2274 	    } else
2275 	       initializer_type = rhs->type;
2276 
2277 	    /* If the declared variable is an unsized array, it must inherrit
2278 	     * its full type from the initializer.  A declaration such as
2279 	     *
2280 	     *     uniform float a[] = float[](1.0, 2.0, 3.0, 3.0);
2281 	     *
2282 	     * becomes
2283 	     *
2284 	     *     uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0);
2285 	     *
2286 	     * The assignment generated in the if-statement (below) will also
2287 	     * automatically handle this case for non-uniforms.
2288 	     *
2289 	     * If the declared variable is not an array, the types must
2290 	     * already match exactly.  As a result, the type assignment
2291 	     * here can be done unconditionally.  For non-uniforms the call
2292 	     * to do_assignment can change the type of the initializer (via
2293 	     * the implicit conversion rules).  For uniforms the initializer
2294 	     * must be a constant expression, and the type of that expression
2295 	     * was validated above.
2296 	     */
2297 	    var->type = initializer_type;
2298 
2299 	    var->read_only = temp;
2300 	 }
2301       }
2302 
2303       /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec:
2304        *
2305        *     "It is an error to write to a const variable outside of
2306        *      its declaration, so they must be initialized when
2307        *      declared."
2308        */
2309       if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) {
2310 	 _mesa_glsl_error(& loc, state,
2311 			  "const declaration of `%s' must be initialized");
2312       }
2313 
2314       /* Check if this declaration is actually a re-declaration, either to
2315        * resize an array or add qualifiers to an existing variable.
2316        *
2317        * This is allowed for variables in the current scope, or when at
2318        * global scope (for built-ins in the implicit outer scope).
2319        */
2320       ir_variable *earlier = state->symbols->get_variable(decl->identifier);
2321       if (earlier != NULL && (state->current_function == NULL ||
2322 	  state->symbols->name_declared_this_scope(decl->identifier))) {
2323 
2324 	 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec,
2325 	  *
2326 	  * "It is legal to declare an array without a size and then
2327 	  *  later re-declare the same name as an array of the same
2328 	  *  type and specify a size."
2329 	  */
2330 	 if ((earlier->type->array_size() == 0)
2331 	     && var->type->is_array()
2332 	     && (var->type->element_type() == earlier->type->element_type())) {
2333 	    /* FINISHME: This doesn't match the qualifiers on the two
2334 	     * FINISHME: declarations.  It's not 100% clear whether this is
2335 	     * FINISHME: required or not.
2336 	     */
2337 
2338 	    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
2339 	     *
2340 	     *     "The size [of gl_TexCoord] can be at most
2341 	     *     gl_MaxTextureCoords."
2342 	     */
2343 	    const unsigned size = unsigned(var->type->array_size());
2344 	    if ((strcmp("gl_TexCoord", var->name) == 0)
2345 		&& (size > state->Const.MaxTextureCoords)) {
2346 	       YYLTYPE loc = this->get_location();
2347 
2348 	       _mesa_glsl_error(& loc, state, "`gl_TexCoord' array size cannot "
2349 				"be larger than gl_MaxTextureCoords (%u)\n",
2350 				state->Const.MaxTextureCoords);
2351 	    } else if ((size > 0) && (size <= earlier->max_array_access)) {
2352 	       YYLTYPE loc = this->get_location();
2353 
2354 	       _mesa_glsl_error(& loc, state, "array size must be > %u due to "
2355 				"previous access",
2356 				earlier->max_array_access);
2357 	    }
2358 
2359 	    earlier->type = var->type;
2360 	    delete var;
2361 	    var = NULL;
2362 	 } else if (state->ARB_fragment_coord_conventions_enable
2363 		    && strcmp(var->name, "gl_FragCoord") == 0
2364 		    && earlier->type == var->type
2365 		    && earlier->mode == var->mode) {
2366 	    /* Allow redeclaration of gl_FragCoord for ARB_fcc layout
2367 	     * qualifiers.
2368 	     */
2369 	    earlier->origin_upper_left = var->origin_upper_left;
2370 	    earlier->pixel_center_integer = var->pixel_center_integer;
2371 	 } else {
2372 	    YYLTYPE loc = this->get_location();
2373 	    _mesa_glsl_error(&loc, state, "`%s' redeclared", decl->identifier);
2374 	 }
2375 
2376 	 continue;
2377       }
2378 
2379       /* By now, we know it's a new variable declaration (we didn't hit the
2380        * above "continue").
2381        *
2382        * From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
2383        *
2384        *   "Identifiers starting with "gl_" are reserved for use by
2385        *   OpenGL, and may not be declared in a shader as either a
2386        *   variable or a function."
2387        */
2388       if (strncmp(decl->identifier, "gl_", 3) == 0)
2389 	 _mesa_glsl_error(& loc, state,
2390 			  "identifier `%s' uses reserved `gl_' prefix",
2391 			  decl->identifier);
2392 
2393       /* Add the variable to the symbol table.  Note that the initializer's
2394        * IR was already processed earlier (though it hasn't been emitted yet),
2395        * without the variable in scope.
2396        *
2397        * This differs from most C-like languages, but it follows the GLSL
2398        * specification.  From page 28 (page 34 of the PDF) of the GLSL 1.50
2399        * spec:
2400        *
2401        *     "Within a declaration, the scope of a name starts immediately
2402        *     after the initializer if present or immediately after the name
2403        *     being declared if not."
2404        */
2405       if (!state->symbols->add_variable(var)) {
2406 	 YYLTYPE loc = this->get_location();
2407 	 _mesa_glsl_error(&loc, state, "name `%s' already taken in the "
2408 			  "current scope", decl->identifier);
2409 	 continue;
2410       }
2411 
2412       /* Push the variable declaration to the top.  It means that all
2413        * the variable declarations will appear in a funny
2414        * last-to-first order, but otherwise we run into trouble if a
2415        * function is prototyped, a global var is decled, then the
2416        * function is defined with usage of the global var.  See
2417        * glslparsertest's CorrectModule.frag.
2418        */
2419       instructions->push_head(var);
2420       instructions->append_list(&initializer_instructions);
2421    }
2422 
2423 
2424    /* Generally, variable declarations do not have r-values.  However,
2425     * one is used for the declaration in
2426     *
2427     * while (bool b = some_condition()) {
2428     *   ...
2429     * }
2430     *
2431     * so we return the rvalue from the last seen declaration here.
2432     */
2433    return result;
2434 }
2435 
2436 
2437 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2438 ast_parameter_declarator::hir(exec_list *instructions,
2439 			      struct _mesa_glsl_parse_state *state)
2440 {
2441    void *ctx = state;
2442    const struct glsl_type *type;
2443    const char *name = NULL;
2444    YYLTYPE loc = this->get_location();
2445 
2446    type = this->type->specifier->glsl_type(& name, state);
2447 
2448    if (type == NULL) {
2449       if (name != NULL) {
2450 	 _mesa_glsl_error(& loc, state,
2451 			  "invalid type `%s' in declaration of `%s'",
2452 			  name, this->identifier);
2453       } else {
2454 	 _mesa_glsl_error(& loc, state,
2455 			  "invalid type in declaration of `%s'",
2456 			  this->identifier);
2457       }
2458 
2459       type = glsl_type::error_type;
2460    }
2461 
2462    /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec:
2463     *
2464     *    "Functions that accept no input arguments need not use void in the
2465     *    argument list because prototypes (or definitions) are required and
2466     *    therefore there is no ambiguity when an empty argument list "( )" is
2467     *    declared. The idiom "(void)" as a parameter list is provided for
2468     *    convenience."
2469     *
2470     * Placing this check here prevents a void parameter being set up
2471     * for a function, which avoids tripping up checks for main taking
2472     * parameters and lookups of an unnamed symbol.
2473     */
2474    if (type->is_void()) {
2475       if (this->identifier != NULL)
2476 	 _mesa_glsl_error(& loc, state,
2477 			  "named parameter cannot have type `void'");
2478 
2479       is_void = true;
2480       return NULL;
2481    }
2482 
2483    if (formal_parameter && (this->identifier == NULL)) {
2484       _mesa_glsl_error(& loc, state, "formal parameter lacks a name");
2485       return NULL;
2486    }
2487 
2488    /* This only handles "vec4 foo[..]".  The earlier specifier->glsl_type(...)
2489     * call already handled the "vec4[..] foo" case.
2490     */
2491    if (this->is_array) {
2492       type = process_array_type(&loc, type, this->array_size, state);
2493    }
2494 
2495    if (type->array_size() == 0) {
2496       _mesa_glsl_error(&loc, state, "arrays passed as parameters must have "
2497 		       "a declared size.");
2498       type = glsl_type::error_type;
2499    }
2500 
2501    is_void = false;
2502    ir_variable *var = new(ctx) ir_variable(type, this->identifier, ir_var_in);
2503 
2504    /* Apply any specified qualifiers to the parameter declaration.  Note that
2505     * for function parameters the default mode is 'in'.
2506     */
2507    apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc);
2508 
2509    instructions->push_tail(var);
2510 
2511    /* Parameter declarations do not have r-values.
2512     */
2513    return NULL;
2514 }
2515 
2516 
2517 void
parameters_to_hir(exec_list * ast_parameters,bool formal,exec_list * ir_parameters,_mesa_glsl_parse_state * state)2518 ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters,
2519 					    bool formal,
2520 					    exec_list *ir_parameters,
2521 					    _mesa_glsl_parse_state *state)
2522 {
2523    ast_parameter_declarator *void_param = NULL;
2524    unsigned count = 0;
2525 
2526    foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters) {
2527       param->formal_parameter = formal;
2528       param->hir(ir_parameters, state);
2529 
2530       if (param->is_void)
2531 	 void_param = param;
2532 
2533       count++;
2534    }
2535 
2536    if ((void_param != NULL) && (count > 1)) {
2537       YYLTYPE loc = void_param->get_location();
2538 
2539       _mesa_glsl_error(& loc, state,
2540 		       "`void' parameter must be only parameter");
2541    }
2542 }
2543 
2544 
2545 void
emit_function(_mesa_glsl_parse_state * state,exec_list * instructions,ir_function * f)2546 emit_function(_mesa_glsl_parse_state *state, exec_list *instructions,
2547 	      ir_function *f)
2548 {
2549    /* Emit the new function header */
2550    if (state->current_function == NULL) {
2551       instructions->push_tail(f);
2552    } else {
2553       /* IR invariants disallow function declarations or definitions nested
2554        * within other function definitions.  Insert the new ir_function
2555        * block in the instruction sequence before the ir_function block
2556        * containing the current ir_function_signature.
2557        */
2558       ir_function *const curr =
2559 	 const_cast<ir_function *>(state->current_function->function());
2560 
2561       curr->insert_before(f);
2562    }
2563 }
2564 
2565 
2566 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2567 ast_function::hir(exec_list *instructions,
2568 		  struct _mesa_glsl_parse_state *state)
2569 {
2570    void *ctx = state;
2571    ir_function *f = NULL;
2572    ir_function_signature *sig = NULL;
2573    exec_list hir_parameters;
2574 
2575    const char *const name = identifier;
2576 
2577    /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec,
2578     *
2579     *   "Function declarations (prototypes) cannot occur inside of functions;
2580     *   they must be at global scope, or for the built-in functions, outside
2581     *   the global scope."
2582     *
2583     * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec,
2584     *
2585     *   "User defined functions may only be defined within the global scope."
2586     *
2587     * Note that this language does not appear in GLSL 1.10.
2588     */
2589    if ((state->current_function != NULL) && (state->language_version != 110)) {
2590       YYLTYPE loc = this->get_location();
2591       _mesa_glsl_error(&loc, state,
2592 		       "declaration of function `%s' not allowed within "
2593 		       "function body", name);
2594    }
2595 
2596    /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec,
2597     *
2598     *   "Identifiers starting with "gl_" are reserved for use by
2599     *   OpenGL, and may not be declared in a shader as either a
2600     *   variable or a function."
2601     */
2602    if (strncmp(name, "gl_", 3) == 0) {
2603       YYLTYPE loc = this->get_location();
2604       _mesa_glsl_error(&loc, state,
2605 		       "identifier `%s' uses reserved `gl_' prefix", name);
2606    }
2607 
2608    /* Convert the list of function parameters to HIR now so that they can be
2609     * used below to compare this function's signature with previously seen
2610     * signatures for functions with the same name.
2611     */
2612    ast_parameter_declarator::parameters_to_hir(& this->parameters,
2613 					       is_definition,
2614 					       & hir_parameters, state);
2615 
2616    const char *return_type_name;
2617    const glsl_type *return_type =
2618       this->return_type->specifier->glsl_type(& return_type_name, state);
2619 
2620    if (!return_type) {
2621       YYLTYPE loc = this->get_location();
2622       _mesa_glsl_error(&loc, state,
2623 		       "function `%s' has undeclared return type `%s'",
2624 		       name, return_type_name);
2625       return_type = glsl_type::error_type;
2626    }
2627 
2628    /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec:
2629     * "No qualifier is allowed on the return type of a function."
2630     */
2631    if (this->return_type->has_qualifiers()) {
2632       YYLTYPE loc = this->get_location();
2633       _mesa_glsl_error(& loc, state,
2634 		       "function `%s' return type has qualifiers", name);
2635    }
2636 
2637    /* Verify that this function's signature either doesn't match a previously
2638     * seen signature for a function with the same name, or, if a match is found,
2639     * that the previously seen signature does not have an associated definition.
2640     */
2641    f = state->symbols->get_function(name);
2642    if (f != NULL && (state->es_shader || f->has_user_signature())) {
2643       sig = f->exact_matching_signature(&hir_parameters);
2644       if (sig != NULL) {
2645 	 const char *badvar = sig->qualifiers_match(&hir_parameters);
2646 	 if (badvar != NULL) {
2647 	    YYLTYPE loc = this->get_location();
2648 
2649 	    _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' "
2650 			     "qualifiers don't match prototype", name, badvar);
2651 	 }
2652 
2653 	 if (sig->return_type != return_type) {
2654 	    YYLTYPE loc = this->get_location();
2655 
2656 	    _mesa_glsl_error(&loc, state, "function `%s' return type doesn't "
2657 			     "match prototype", name);
2658 	 }
2659 
2660 	 if (is_definition && sig->is_defined) {
2661 	    YYLTYPE loc = this->get_location();
2662 
2663 	    _mesa_glsl_error(& loc, state, "function `%s' redefined", name);
2664 	 }
2665       }
2666    } else {
2667       f = new(ctx) ir_function(name);
2668       if (!state->symbols->add_function(f)) {
2669 	 /* This function name shadows a non-function use of the same name. */
2670 	 YYLTYPE loc = this->get_location();
2671 
2672 	 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with "
2673 			  "non-function", name);
2674 	 return NULL;
2675       }
2676 
2677       emit_function(state, instructions, f);
2678    }
2679 
2680    /* Verify the return type of main() */
2681    if (strcmp(name, "main") == 0) {
2682       if (! return_type->is_void()) {
2683 	 YYLTYPE loc = this->get_location();
2684 
2685 	 _mesa_glsl_error(& loc, state, "main() must return void");
2686       }
2687 
2688       if (!hir_parameters.is_empty()) {
2689 	 YYLTYPE loc = this->get_location();
2690 
2691 	 _mesa_glsl_error(& loc, state, "main() must not take any parameters");
2692       }
2693    }
2694 
2695    /* Finish storing the information about this new function in its signature.
2696     */
2697    if (sig == NULL) {
2698       sig = new(ctx) ir_function_signature(return_type);
2699       f->add_signature(sig);
2700    }
2701 
2702    sig->replace_parameters(&hir_parameters);
2703    signature = sig;
2704 
2705    /* Function declarations (prototypes) do not have r-values.
2706     */
2707    return NULL;
2708 }
2709 
2710 
2711 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2712 ast_function_definition::hir(exec_list *instructions,
2713 			     struct _mesa_glsl_parse_state *state)
2714 {
2715    prototype->is_definition = true;
2716    prototype->hir(instructions, state);
2717 
2718    ir_function_signature *signature = prototype->signature;
2719    if (signature == NULL)
2720       return NULL;
2721 
2722    assert(state->current_function == NULL);
2723    state->current_function = signature;
2724    state->found_return = false;
2725 
2726    /* Duplicate parameters declared in the prototype as concrete variables.
2727     * Add these to the symbol table.
2728     */
2729    state->symbols->push_scope();
2730    foreach_iter(exec_list_iterator, iter, signature->parameters) {
2731       ir_variable *const var = ((ir_instruction *) iter.get())->as_variable();
2732 
2733       assert(var != NULL);
2734 
2735       /* The only way a parameter would "exist" is if two parameters have
2736        * the same name.
2737        */
2738       if (state->symbols->name_declared_this_scope(var->name)) {
2739 	 YYLTYPE loc = this->get_location();
2740 
2741 	 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name);
2742       } else {
2743 	 state->symbols->add_variable(var);
2744       }
2745    }
2746 
2747    /* Convert the body of the function to HIR. */
2748    this->body->hir(&signature->body, state);
2749    signature->is_defined = true;
2750 
2751    state->symbols->pop_scope();
2752 
2753    assert(state->current_function == signature);
2754    state->current_function = NULL;
2755 
2756    if (!signature->return_type->is_void() && !state->found_return) {
2757       YYLTYPE loc = this->get_location();
2758       _mesa_glsl_error(& loc, state, "function `%s' has non-void return type "
2759 		       "%s, but no return statement",
2760 		       signature->function_name(),
2761 		       signature->return_type->name);
2762    }
2763 
2764    /* Function definitions do not have r-values.
2765     */
2766    return NULL;
2767 }
2768 
2769 
2770 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2771 ast_jump_statement::hir(exec_list *instructions,
2772 			struct _mesa_glsl_parse_state *state)
2773 {
2774    void *ctx = state;
2775 
2776    switch (mode) {
2777    case ast_return: {
2778       ir_return *inst;
2779       assert(state->current_function);
2780 
2781       if (opt_return_value) {
2782 	 if (state->current_function->return_type->base_type ==
2783 	     GLSL_TYPE_VOID) {
2784 	    YYLTYPE loc = this->get_location();
2785 
2786 	    _mesa_glsl_error(& loc, state,
2787 			     "`return` with a value, in function `%s' "
2788 			     "returning void",
2789 			     state->current_function->function_name());
2790 	 }
2791 
2792 	 ir_rvalue *const ret = opt_return_value->hir(instructions, state);
2793 	 assert(ret != NULL);
2794 
2795 	 /* Implicit conversions are not allowed for return values. */
2796 	 if (state->current_function->return_type != ret->type) {
2797 	    YYLTYPE loc = this->get_location();
2798 
2799 	    _mesa_glsl_error(& loc, state,
2800 			     "`return' with wrong type %s, in function `%s' "
2801 			     "returning %s",
2802 			     ret->type->name,
2803 			     state->current_function->function_name(),
2804 			     state->current_function->return_type->name);
2805 	 }
2806 
2807 	 inst = new(ctx) ir_return(ret);
2808       } else {
2809 	 if (state->current_function->return_type->base_type !=
2810 	     GLSL_TYPE_VOID) {
2811 	    YYLTYPE loc = this->get_location();
2812 
2813 	    _mesa_glsl_error(& loc, state,
2814 			     "`return' with no value, in function %s returning "
2815 			     "non-void",
2816 			     state->current_function->function_name());
2817 	 }
2818 	 inst = new(ctx) ir_return;
2819       }
2820 
2821       state->found_return = true;
2822       instructions->push_tail(inst);
2823       break;
2824    }
2825 
2826    case ast_discard:
2827       if (state->target != fragment_shader) {
2828 	 YYLTYPE loc = this->get_location();
2829 
2830 	 _mesa_glsl_error(& loc, state,
2831 			  "`discard' may only appear in a fragment shader");
2832       }
2833       instructions->push_tail(new(ctx) ir_discard);
2834       break;
2835 
2836    case ast_break:
2837    case ast_continue:
2838       /* FINISHME: Handle switch-statements.  They cannot contain 'continue',
2839        * FINISHME: and they use a different IR instruction for 'break'.
2840        */
2841       /* FINISHME: Correctly handle the nesting.  If a switch-statement is
2842        * FINISHME: inside a loop, a 'continue' is valid and will bind to the
2843        * FINISHME: loop.
2844        */
2845       if (state->loop_or_switch_nesting == NULL) {
2846 	 YYLTYPE loc = this->get_location();
2847 
2848 	 _mesa_glsl_error(& loc, state,
2849 			  "`%s' may only appear in a loop",
2850 			  (mode == ast_break) ? "break" : "continue");
2851       } else {
2852 	 ir_loop *const loop = state->loop_or_switch_nesting->as_loop();
2853 
2854 	 /* Inline the for loop expression again, since we don't know
2855 	  * where near the end of the loop body the normal copy of it
2856 	  * is going to be placed.
2857 	  */
2858 	 if (mode == ast_continue &&
2859 	     state->loop_or_switch_nesting_ast->rest_expression) {
2860 	    state->loop_or_switch_nesting_ast->rest_expression->hir(instructions,
2861 								    state);
2862 	 }
2863 
2864 	 if (loop != NULL) {
2865 	    ir_loop_jump *const jump =
2866 	       new(ctx) ir_loop_jump((mode == ast_break)
2867 				     ? ir_loop_jump::jump_break
2868 				     : ir_loop_jump::jump_continue);
2869 	    instructions->push_tail(jump);
2870 	 }
2871       }
2872 
2873       break;
2874    }
2875 
2876    /* Jump instructions do not have r-values.
2877     */
2878    return NULL;
2879 }
2880 
2881 
2882 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2883 ast_selection_statement::hir(exec_list *instructions,
2884 			     struct _mesa_glsl_parse_state *state)
2885 {
2886    void *ctx = state;
2887 
2888    ir_rvalue *const condition = this->condition->hir(instructions, state);
2889 
2890    /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec:
2891     *
2892     *    "Any expression whose type evaluates to a Boolean can be used as the
2893     *    conditional expression bool-expression. Vector types are not accepted
2894     *    as the expression to if."
2895     *
2896     * The checks are separated so that higher quality diagnostics can be
2897     * generated for cases where both rules are violated.
2898     */
2899    if (!condition->type->is_boolean() || !condition->type->is_scalar()) {
2900       YYLTYPE loc = this->condition->get_location();
2901 
2902       _mesa_glsl_error(& loc, state, "if-statement condition must be scalar "
2903 		       "boolean");
2904    }
2905 
2906    ir_if *const stmt = new(ctx) ir_if(condition);
2907 
2908    if (then_statement != NULL) {
2909       state->symbols->push_scope();
2910       then_statement->hir(& stmt->then_instructions, state);
2911       state->symbols->pop_scope();
2912    }
2913 
2914    if (else_statement != NULL) {
2915       state->symbols->push_scope();
2916       else_statement->hir(& stmt->else_instructions, state);
2917       state->symbols->pop_scope();
2918    }
2919 
2920    instructions->push_tail(stmt);
2921 
2922    /* if-statements do not have r-values.
2923     */
2924    return NULL;
2925 }
2926 
2927 
2928 void
condition_to_hir(ir_loop * stmt,struct _mesa_glsl_parse_state * state)2929 ast_iteration_statement::condition_to_hir(ir_loop *stmt,
2930 					  struct _mesa_glsl_parse_state *state)
2931 {
2932    void *ctx = state;
2933 
2934    if (condition != NULL) {
2935       ir_rvalue *const cond =
2936 	 condition->hir(& stmt->body_instructions, state);
2937 
2938       if ((cond == NULL)
2939 	  || !cond->type->is_boolean() || !cond->type->is_scalar()) {
2940 	 YYLTYPE loc = condition->get_location();
2941 
2942 	 _mesa_glsl_error(& loc, state,
2943 			  "loop condition must be scalar boolean");
2944       } else {
2945 	 /* As the first code in the loop body, generate a block that looks
2946 	  * like 'if (!condition) break;' as the loop termination condition.
2947 	  */
2948 	 ir_rvalue *const not_cond =
2949 	    new(ctx) ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond,
2950 				   NULL);
2951 
2952 	 ir_if *const if_stmt = new(ctx) ir_if(not_cond);
2953 
2954 	 ir_jump *const break_stmt =
2955 	    new(ctx) ir_loop_jump(ir_loop_jump::jump_break);
2956 
2957 	 if_stmt->then_instructions.push_tail(break_stmt);
2958 	 stmt->body_instructions.push_tail(if_stmt);
2959       }
2960    }
2961 }
2962 
2963 
2964 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)2965 ast_iteration_statement::hir(exec_list *instructions,
2966 			     struct _mesa_glsl_parse_state *state)
2967 {
2968    void *ctx = state;
2969 
2970    /* For-loops and while-loops start a new scope, but do-while loops do not.
2971     */
2972    if (mode != ast_do_while)
2973       state->symbols->push_scope();
2974 
2975    if (init_statement != NULL)
2976       init_statement->hir(instructions, state);
2977 
2978    ir_loop *const stmt = new(ctx) ir_loop();
2979    instructions->push_tail(stmt);
2980 
2981    /* Track the current loop and / or switch-statement nesting.
2982     */
2983    ir_instruction *const nesting = state->loop_or_switch_nesting;
2984    ast_iteration_statement *nesting_ast = state->loop_or_switch_nesting_ast;
2985 
2986    state->loop_or_switch_nesting = stmt;
2987    state->loop_or_switch_nesting_ast = this;
2988 
2989    if (mode != ast_do_while)
2990       condition_to_hir(stmt, state);
2991 
2992    if (body != NULL)
2993       body->hir(& stmt->body_instructions, state);
2994 
2995    if (rest_expression != NULL)
2996       rest_expression->hir(& stmt->body_instructions, state);
2997 
2998    if (mode == ast_do_while)
2999       condition_to_hir(stmt, state);
3000 
3001    if (mode != ast_do_while)
3002       state->symbols->pop_scope();
3003 
3004    /* Restore previous nesting before returning.
3005     */
3006    state->loop_or_switch_nesting = nesting;
3007    state->loop_or_switch_nesting_ast = nesting_ast;
3008 
3009    /* Loops do not have r-values.
3010     */
3011    return NULL;
3012 }
3013 
3014 
3015 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)3016 ast_type_specifier::hir(exec_list *instructions,
3017 			  struct _mesa_glsl_parse_state *state)
3018 {
3019    if (this->structure != NULL)
3020       return this->structure->hir(instructions, state);
3021 
3022    return NULL;
3023 }
3024 
3025 
3026 ir_rvalue *
hir(exec_list * instructions,struct _mesa_glsl_parse_state * state)3027 ast_struct_specifier::hir(exec_list *instructions,
3028 			  struct _mesa_glsl_parse_state *state)
3029 {
3030    unsigned decl_count = 0;
3031 
3032    /* Make an initial pass over the list of structure fields to determine how
3033     * many there are.  Each element in this list is an ast_declarator_list.
3034     * This means that we actually need to count the number of elements in the
3035     * 'declarations' list in each of the elements.
3036     */
3037    foreach_list_typed (ast_declarator_list, decl_list, link,
3038 		       &this->declarations) {
3039       foreach_list_const (decl_ptr, & decl_list->declarations) {
3040 	 decl_count++;
3041       }
3042    }
3043 
3044    /* Allocate storage for the structure fields and process the field
3045     * declarations.  As the declarations are processed, try to also convert
3046     * the types to HIR.  This ensures that structure definitions embedded in
3047     * other structure definitions are processed.
3048     */
3049    glsl_struct_field *const fields = hieralloc_array(state, glsl_struct_field,
3050 						  decl_count);
3051 
3052    unsigned i = 0;
3053    foreach_list_typed (ast_declarator_list, decl_list, link,
3054 		       &this->declarations) {
3055       const char *type_name;
3056 
3057       decl_list->type->specifier->hir(instructions, state);
3058 
3059       /* Section 10.9 of the GLSL ES 1.00 specification states that
3060        * embedded structure definitions have been removed from the language.
3061        */
3062       if (state->es_shader && decl_list->type->specifier->structure != NULL) {
3063 	 YYLTYPE loc = this->get_location();
3064 	 _mesa_glsl_error(&loc, state, "Embedded structure definitions are "
3065 			  "not allowed in GLSL ES 1.00.");
3066       }
3067 
3068       const glsl_type *decl_type =
3069 	 decl_list->type->specifier->glsl_type(& type_name, state);
3070 
3071       foreach_list_typed (ast_declaration, decl, link,
3072 			  &decl_list->declarations) {
3073 	 const struct glsl_type *field_type = decl_type;
3074 	 if (decl->is_array) {
3075 	    YYLTYPE loc = decl->get_location();
3076 	    field_type = process_array_type(&loc, decl_type, decl->array_size,
3077 					    state);
3078 	 }
3079 	 fields[i].type = (field_type != NULL)
3080 	    ? field_type : glsl_type::error_type;
3081 	 fields[i].name = decl->identifier;
3082 	 i++;
3083       }
3084    }
3085 
3086    assert(i == decl_count);
3087 
3088    const glsl_type *t =
3089       glsl_type::get_record_instance(fields, decl_count, this->name);
3090 
3091    YYLTYPE loc = this->get_location();
3092    if (!state->symbols->add_type(name, t)) {
3093       _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name);
3094    } else {
3095 
3096       const glsl_type **s = (const glsl_type **)
3097 	 realloc(state->user_structures,
3098 		 sizeof(state->user_structures[0]) *
3099 		 (state->num_user_structures + 1));
3100       if (s != NULL) {
3101 	 s[state->num_user_structures] = t;
3102 	 state->user_structures = s;
3103 	 state->num_user_structures++;
3104       }
3105    }
3106 
3107    /* Structure type definitions do not have r-values.
3108     */
3109    return NULL;
3110 }
3111