2 * Copyright © 2010 Intel Corporation
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:
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
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.
26 * Convert abstract syntax to to high-level intermediate reprensentation (HIR).
28 * During the conversion to HIR, the majority of the symantic checking is
29 * preformed on the program. This includes:
31 * * Symbol table management
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.
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.
48 * As a result, my preference is to put as little C code as possible in the
49 * parser (and lexer) sources.
52 #include "main/imports.h"
53 #include "glsl_symbol_table.h"
54 #include "glsl_parser_extras.h"
56 #include "glsl_types.h"
60 _mesa_ast_to_hir(exec_list
*instructions
, struct _mesa_glsl_parse_state
*state
)
62 struct simple_node
*ptr
;
64 _mesa_glsl_initialize_variables(instructions
, state
);
65 _mesa_glsl_initialize_constructors(instructions
, state
);
66 _mesa_glsl_initialize_functions(instructions
, state
);
68 state
->current_function
= NULL
;
70 foreach (ptr
, & state
->translation_unit
) {
71 ((ast_node
*)ptr
)->hir(instructions
, state
);
77 * If a conversion is available, convert one operand to a different type
79 * The \c from \c ir_rvalue is converted "in place".
81 * \param to Type that the operand it to be converted to
82 * \param from Operand that is being converted
83 * \param state GLSL compiler state
86 * If a conversion is possible (or unnecessary), \c true is returned.
87 * Otherwise \c false is returned.
90 apply_implicit_conversion(const glsl_type
*to
, ir_rvalue
* &from
,
91 struct _mesa_glsl_parse_state
*state
)
93 if (to
->base_type
== from
->type
->base_type
)
96 /* This conversion was added in GLSL 1.20. If the compilation mode is
97 * GLSL 1.10, the conversion is skipped.
99 if (state
->language_version
< 120)
102 /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec:
104 * "There are no implicit array or structure conversions. For
105 * example, an array of int cannot be implicitly converted to an
106 * array of float. There are no implicit conversions between
107 * signed and unsigned integers."
109 /* FINISHME: The above comment is partially a lie. There is int/uint
110 * FINISHME: conversion for immediate constants.
112 if (!to
->is_float() || !from
->type
->is_numeric())
115 switch (from
->type
->base_type
) {
117 from
= new ir_expression(ir_unop_i2f
, to
, from
, NULL
);
120 from
= new ir_expression(ir_unop_u2f
, to
, from
, NULL
);
123 assert(!"FINISHME: Convert bool to float.");
132 static const struct glsl_type
*
133 arithmetic_result_type(ir_rvalue
* &value_a
, ir_rvalue
* &value_b
,
135 struct _mesa_glsl_parse_state
*state
)
137 const glsl_type
*const type_a
= value_a
->type
;
138 const glsl_type
*const type_b
= value_b
->type
;
140 /* From GLSL 1.50 spec, page 56:
142 * "The arithmetic binary operators add (+), subtract (-),
143 * multiply (*), and divide (/) operate on integer and
144 * floating-point scalars, vectors, and matrices."
146 if (!type_a
->is_numeric() || !type_b
->is_numeric()) {
147 return glsl_type::error_type
;
151 /* "If one operand is floating-point based and the other is
152 * not, then the conversions from Section 4.1.10 "Implicit
153 * Conversions" are applied to the non-floating-point-based operand."
155 if (!apply_implicit_conversion(type_a
, value_b
, state
)
156 && !apply_implicit_conversion(type_b
, value_a
, state
)) {
157 return glsl_type::error_type
;
160 /* "If the operands are integer types, they must both be signed or
163 * From this rule and the preceeding conversion it can be inferred that
164 * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT.
165 * The is_numeric check above already filtered out the case where either
166 * type is not one of these, so now the base types need only be tested for
169 if (type_a
->base_type
!= type_b
->base_type
) {
170 return glsl_type::error_type
;
173 /* "All arithmetic binary operators result in the same fundamental type
174 * (signed integer, unsigned integer, or floating-point) as the
175 * operands they operate on, after operand type conversion. After
176 * conversion, the following cases are valid
178 * * The two operands are scalars. In this case the operation is
179 * applied, resulting in a scalar."
181 if (type_a
->is_scalar() && type_b
->is_scalar())
184 /* "* One operand is a scalar, and the other is a vector or matrix.
185 * In this case, the scalar operation is applied independently to each
186 * component of the vector or matrix, resulting in the same size
189 if (type_a
->is_scalar()) {
190 if (!type_b
->is_scalar())
192 } else if (type_b
->is_scalar()) {
196 /* All of the combinations of <scalar, scalar>, <vector, scalar>,
197 * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been
200 assert(!type_a
->is_scalar());
201 assert(!type_b
->is_scalar());
203 /* "* The two operands are vectors of the same size. In this case, the
204 * operation is done component-wise resulting in the same size
207 if (type_a
->is_vector() && type_b
->is_vector()) {
208 return (type_a
== type_b
) ? type_a
: glsl_type::error_type
;
211 /* All of the combinations of <scalar, scalar>, <vector, scalar>,
212 * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and
213 * <vector, vector> have been handled. At least one of the operands must
214 * be matrix. Further, since there are no integer matrix types, the base
215 * type of both operands must be float.
217 assert(type_a
->is_matrix() || type_b
->is_matrix());
218 assert(type_a
->base_type
== GLSL_TYPE_FLOAT
);
219 assert(type_b
->base_type
== GLSL_TYPE_FLOAT
);
221 /* "* The operator is add (+), subtract (-), or divide (/), and the
222 * operands are matrices with the same number of rows and the same
223 * number of columns. In this case, the operation is done component-
224 * wise resulting in the same size matrix."
225 * * The operator is multiply (*), where both operands are matrices or
226 * one operand is a vector and the other a matrix. A right vector
227 * operand is treated as a column vector and a left vector operand as a
228 * row vector. In all these cases, it is required that the number of
229 * columns of the left operand is equal to the number of rows of the
230 * right operand. Then, the multiply (*) operation does a linear
231 * algebraic multiply, yielding an object that has the same number of
232 * rows as the left operand and the same number of columns as the right
233 * operand. Section 5.10 "Vector and Matrix Operations" explains in
234 * more detail how vectors and matrices are operated on."
237 return (type_a
== type_b
) ? type_a
: glsl_type::error_type
;
239 if (type_a
->is_matrix() && type_b
->is_matrix()) {
240 /* Matrix multiply. The columns of A must match the rows of B. Given
241 * the other previously tested constraints, this means the vector type
242 * of a row from A must be the same as the vector type of a column from
245 if (type_a
->row_type() == type_b
->column_type()) {
246 /* The resulting matrix has the number of columns of matrix B and
247 * the number of rows of matrix A. We get the row count of A by
248 * looking at the size of a vector that makes up a column. The
249 * transpose (size of a row) is done for B.
252 glsl_type::get_instance(type_a
->base_type
,
253 type_a
->column_type()->vector_elements
,
254 type_b
->row_type()->vector_elements
);
256 } else if (type_a
->is_matrix()) {
257 /* A is a matrix and B is a column vector. Columns of A must match
258 * rows of B. Given the other previously tested constraints, this
259 * means the vector type of a row from A must be the same as the
260 * vector the type of B.
262 if (type_a
->row_type() == type_b
)
265 assert(type_b
->is_matrix());
267 /* A is a row vector and B is a matrix. Columns of A must match rows
268 * of B. Given the other previously tested constraints, this means
269 * the type of A must be the same as the vector type of a column from
272 if (type_a
== type_b
->column_type())
278 /* "All other cases are illegal."
280 return glsl_type::error_type
;
284 static const struct glsl_type
*
285 unary_arithmetic_result_type(const struct glsl_type
*type
)
287 /* From GLSL 1.50 spec, page 57:
289 * "The arithmetic unary operators negate (-), post- and pre-increment
290 * and decrement (-- and ++) operate on integer or floating-point
291 * values (including vectors and matrices). All unary operators work
292 * component-wise on their operands. These result with the same type
295 if (!type
->is_numeric())
296 return glsl_type::error_type
;
302 static const struct glsl_type
*
303 modulus_result_type(const struct glsl_type
*type_a
,
304 const struct glsl_type
*type_b
)
306 /* From GLSL 1.50 spec, page 56:
307 * "The operator modulus (%) operates on signed or unsigned integers or
308 * integer vectors. The operand types must both be signed or both be
311 if (!type_a
->is_integer() || !type_b
->is_integer()
312 || (type_a
->base_type
!= type_b
->base_type
)) {
313 return glsl_type::error_type
;
316 /* "The operands cannot be vectors of differing size. If one operand is
317 * a scalar and the other vector, then the scalar is applied component-
318 * wise to the vector, resulting in the same type as the vector. If both
319 * are vectors of the same size, the result is computed component-wise."
321 if (type_a
->is_vector()) {
322 if (!type_b
->is_vector()
323 || (type_a
->vector_elements
== type_b
->vector_elements
))
328 /* "The operator modulus (%) is not defined for any other data types
329 * (non-integer types)."
331 return glsl_type::error_type
;
335 static const struct glsl_type
*
336 relational_result_type(ir_rvalue
* &value_a
, ir_rvalue
* &value_b
,
337 struct _mesa_glsl_parse_state
*state
)
339 const glsl_type
*const type_a
= value_a
->type
;
340 const glsl_type
*const type_b
= value_b
->type
;
342 /* From GLSL 1.50 spec, page 56:
343 * "The relational operators greater than (>), less than (<), greater
344 * than or equal (>=), and less than or equal (<=) operate only on
345 * scalar integer and scalar floating-point expressions."
347 if (!type_a
->is_numeric()
348 || !type_b
->is_numeric()
349 || !type_a
->is_scalar()
350 || !type_b
->is_scalar())
351 return glsl_type::error_type
;
353 /* "Either the operands' types must match, or the conversions from
354 * Section 4.1.10 "Implicit Conversions" will be applied to the integer
355 * operand, after which the types must match."
357 if (!apply_implicit_conversion(type_a
, value_b
, state
)
358 && !apply_implicit_conversion(type_b
, value_a
, state
)) {
359 return glsl_type::error_type
;
362 if (type_a
->base_type
!= type_b
->base_type
)
363 return glsl_type::error_type
;
365 /* "The result is scalar Boolean."
367 return glsl_type::bool_type
;
372 * Validates that a value can be assigned to a location with a specified type
374 * Validates that \c rhs can be assigned to some location. If the types are
375 * not an exact match but an automatic conversion is possible, \c rhs will be
379 * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type.
380 * Otherwise the actual RHS to be assigned will be returned. This may be
381 * \c rhs, or it may be \c rhs after some type conversion.
384 * In addition to being used for assignments, this function is used to
385 * type-check return values.
388 validate_assignment(const glsl_type
*lhs_type
, ir_rvalue
*rhs
)
390 const glsl_type
*const rhs_type
= rhs
->type
;
392 /* If there is already some error in the RHS, just return it. Anything
393 * else will lead to an avalanche of error message back to the user.
395 if (rhs_type
->is_error())
398 /* FINISHME: For GLSL 1.10, check that the types are not arrays. */
400 /* If the types are identical, the assignment can trivially proceed.
402 if (rhs_type
== lhs_type
)
405 /* FINISHME: Check for and apply automatic conversions. */
410 do_assignment(exec_list
*instructions
, struct _mesa_glsl_parse_state
*state
,
411 ir_rvalue
*lhs
, ir_rvalue
*rhs
,
414 bool error_emitted
= (lhs
->type
->is_error() || rhs
->type
->is_error());
416 if (!error_emitted
) {
417 /* FINISHME: This does not handle 'foo.bar.a.b.c[5].d = 5' */
418 if (!lhs
->is_lvalue()) {
419 _mesa_glsl_error(& lhs_loc
, state
, "non-lvalue in assignment");
420 error_emitted
= true;
424 ir_rvalue
*new_rhs
= validate_assignment(lhs
->type
, rhs
);
425 if (new_rhs
== NULL
) {
426 _mesa_glsl_error(& lhs_loc
, state
, "type mismatch");
431 ir_instruction
*tmp
= new ir_assignment(lhs
, rhs
, NULL
);
432 instructions
->push_tail(tmp
);
439 * Generate a new temporary and add its declaration to the instruction stream
442 generate_temporary(const glsl_type
*type
, exec_list
*instructions
,
443 struct _mesa_glsl_parse_state
*state
)
445 char *name
= (char *) malloc(sizeof(char) * 13);
447 snprintf(name
, 13, "tmp_%08X", state
->temp_index
);
450 ir_variable
*const var
= new ir_variable(type
, name
);
451 instructions
->push_tail(var
);
458 get_lvalue_copy(exec_list
*instructions
, struct _mesa_glsl_parse_state
*state
,
459 ir_rvalue
*lvalue
, YYLTYPE loc
)
462 ir_rvalue
*var_deref
;
464 /* FINISHME: Give unique names to the temporaries. */
465 var
= new ir_variable(lvalue
->type
, "_internal_tmp");
466 var
->mode
= ir_var_auto
;
468 var_deref
= new ir_dereference(var
);
469 do_assignment(instructions
, state
, var_deref
, lvalue
, loc
);
471 /* Once we've created this temporary, mark it read only so it's no
472 * longer considered an lvalue.
474 var
->read_only
= true;
481 ast_node::hir(exec_list
*instructions
,
482 struct _mesa_glsl_parse_state
*state
)
492 ast_expression::hir(exec_list
*instructions
,
493 struct _mesa_glsl_parse_state
*state
)
495 static const int operations
[AST_NUM_OPERATORS
] = {
496 -1, /* ast_assign doesn't convert to ir_expression. */
497 -1, /* ast_plus doesn't convert to ir_expression. */
521 /* Note: The following block of expression types actually convert
522 * to multiple IR instructions.
524 ir_binop_mul
, /* ast_mul_assign */
525 ir_binop_div
, /* ast_div_assign */
526 ir_binop_mod
, /* ast_mod_assign */
527 ir_binop_add
, /* ast_add_assign */
528 ir_binop_sub
, /* ast_sub_assign */
529 ir_binop_lshift
, /* ast_ls_assign */
530 ir_binop_rshift
, /* ast_rs_assign */
531 ir_binop_bit_and
, /* ast_and_assign */
532 ir_binop_bit_xor
, /* ast_xor_assign */
533 ir_binop_bit_or
, /* ast_or_assign */
535 -1, /* ast_conditional doesn't convert to ir_expression. */
536 ir_binop_add
, /* ast_pre_inc. */
537 ir_binop_sub
, /* ast_pre_dec. */
538 ir_binop_add
, /* ast_post_inc. */
539 ir_binop_sub
, /* ast_post_dec. */
540 -1, /* ast_field_selection doesn't conv to ir_expression. */
541 -1, /* ast_array_index doesn't convert to ir_expression. */
542 -1, /* ast_function_call doesn't conv to ir_expression. */
543 -1, /* ast_identifier doesn't convert to ir_expression. */
544 -1, /* ast_int_constant doesn't convert to ir_expression. */
545 -1, /* ast_uint_constant doesn't conv to ir_expression. */
546 -1, /* ast_float_constant doesn't conv to ir_expression. */
547 -1, /* ast_bool_constant doesn't conv to ir_expression. */
548 -1, /* ast_sequence doesn't convert to ir_expression. */
550 ir_rvalue
*result
= NULL
;
552 struct simple_node op_list
;
553 const struct glsl_type
*type
= glsl_type::error_type
;
554 bool error_emitted
= false;
557 loc
= this->get_location();
558 make_empty_list(& op_list
);
560 switch (this->oper
) {
562 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
563 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
565 result
= do_assignment(instructions
, state
, op
[0], op
[1],
566 this->subexpressions
[0]->get_location());
567 error_emitted
= result
->type
->is_error();
573 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
575 error_emitted
= op
[0]->type
->is_error();
576 if (type
->is_error())
583 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
585 type
= unary_arithmetic_result_type(op
[0]->type
);
587 error_emitted
= op
[0]->type
->is_error();
589 result
= new ir_expression(operations
[this->oper
], type
,
597 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
598 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
600 type
= arithmetic_result_type(op
[0], op
[1],
601 (this->oper
== ast_mul
),
604 result
= new ir_expression(operations
[this->oper
], type
,
609 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
610 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
612 error_emitted
= op
[0]->type
->is_error() || op
[1]->type
->is_error();
614 type
= modulus_result_type(op
[0]->type
, op
[1]->type
);
616 assert(operations
[this->oper
] == ir_binop_mod
);
618 result
= new ir_expression(operations
[this->oper
], type
,
624 /* FINISHME: Implement bit-shift operators. */
631 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
632 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
634 error_emitted
= op
[0]->type
->is_error() || op
[1]->type
->is_error();
636 type
= relational_result_type(op
[0], op
[1], state
);
638 /* The relational operators must either generate an error or result
639 * in a scalar boolean. See page 57 of the GLSL 1.50 spec.
641 assert(type
->is_error()
642 || ((type
->base_type
== GLSL_TYPE_BOOL
)
643 && type
->is_scalar()));
645 result
= new ir_expression(operations
[this->oper
], type
,
651 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
652 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
654 /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec:
656 * "The equality operators equal (==), and not equal (!=)
657 * operate on all types. They result in a scalar Boolean. If
658 * the operand types do not match, then there must be a
659 * conversion from Section 4.1.10 "Implicit Conversions"
660 * applied to one operand that can make them match, in which
661 * case this conversion is done."
663 if ((!apply_implicit_conversion(op
[0]->type
, op
[1], state
)
664 && !apply_implicit_conversion(op
[1]->type
, op
[0], state
))
665 || (op
[0]->type
!= op
[1]->type
)) {
666 _mesa_glsl_error(& loc
, state
, "operands of `%s' must have the same "
667 "type", (this->oper
== ast_equal
) ? "==" : "!=");
668 error_emitted
= true;
669 } else if ((state
->language_version
<= 110)
670 && (op
[0]->type
->is_array() || op
[1]->type
->is_array())) {
671 _mesa_glsl_error(& loc
, state
, "array comparisons forbidden in "
673 error_emitted
= true;
676 result
= new ir_expression(operations
[this->oper
], glsl_type::bool_type
,
678 type
= glsl_type::bool_type
;
680 assert(result
->type
== glsl_type::bool_type
);
687 /* FINISHME: Implement bit-wise operators. */
694 /* FINISHME: Implement logical operators. */
700 case ast_sub_assign
: {
701 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
702 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
704 type
= arithmetic_result_type(op
[0], op
[1],
705 (this->oper
== ast_mul_assign
),
708 ir_rvalue
*temp_rhs
= new ir_expression(operations
[this->oper
], type
,
711 result
= do_assignment(instructions
, state
, op
[0], temp_rhs
,
712 this->subexpressions
[0]->get_location());
714 error_emitted
= (op
[0]->type
->is_error());
716 /* GLSL 1.10 does not allow array assignment. However, we don't have to
717 * explicitly test for this because none of the binary expression
718 * operators allow array operands either.
724 case ast_mod_assign
: {
725 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
726 op
[1] = this->subexpressions
[1]->hir(instructions
, state
);
728 error_emitted
= op
[0]->type
->is_error() || op
[1]->type
->is_error();
730 type
= modulus_result_type(op
[0]->type
, op
[1]->type
);
732 assert(operations
[this->oper
] == ir_binop_mod
);
734 struct ir_rvalue
*temp_rhs
;
735 temp_rhs
= new ir_expression(operations
[this->oper
], type
,
738 result
= do_assignment(instructions
, state
, op
[0], temp_rhs
,
739 this->subexpressions
[0]->get_location());
741 error_emitted
= op
[0]->type
->is_error();
754 case ast_conditional
: {
755 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
757 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
759 * "The ternary selection operator (?:). It operates on three
760 * expressions (exp1 ? exp2 : exp3). This operator evaluates the
761 * first expression, which must result in a scalar Boolean."
763 if (!op
[0]->type
->is_boolean() || !op
[0]->type
->is_scalar()) {
764 YYLTYPE loc
= this->subexpressions
[0]->get_location();
766 _mesa_glsl_error(& loc
, state
, "?: condition must be scalar boolean");
767 error_emitted
= true;
770 /* The :? operator is implemented by generating an anonymous temporary
771 * followed by an if-statement. The last instruction in each branch of
772 * the if-statement assigns a value to the anonymous temporary. This
773 * temporary is the r-value of the expression.
775 ir_variable
*const tmp
= generate_temporary(glsl_type::error_type
,
776 instructions
, state
);
778 ir_if
*const stmt
= new ir_if(op
[0]);
779 instructions
->push_tail(stmt
);
781 op
[1] = this->subexpressions
[1]->hir(& stmt
->then_instructions
, state
);
782 ir_dereference
*const then_deref
= new ir_dereference(tmp
);
783 ir_assignment
*const then_assign
=
784 new ir_assignment(then_deref
, op
[1], NULL
);
785 stmt
->then_instructions
.push_tail(then_assign
);
787 op
[2] = this->subexpressions
[2]->hir(& stmt
->else_instructions
, state
);
788 ir_dereference
*const else_deref
= new ir_dereference(tmp
);
789 ir_assignment
*const else_assign
=
790 new ir_assignment(else_deref
, op
[2], NULL
);
791 stmt
->else_instructions
.push_tail(else_assign
);
793 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec:
795 * "The second and third expressions can be any type, as
796 * long their types match, or there is a conversion in
797 * Section 4.1.10 "Implicit Conversions" that can be applied
798 * to one of the expressions to make their types match. This
799 * resulting matching type is the type of the entire
802 if ((!apply_implicit_conversion(op
[1]->type
, op
[2], state
)
803 && !apply_implicit_conversion(op
[2]->type
, op
[1], state
))
804 || (op
[1]->type
!= op
[2]->type
)) {
805 YYLTYPE loc
= this->subexpressions
[1]->get_location();
807 _mesa_glsl_error(& loc
, state
, "Second and third operands of ?: "
808 "operator must have matching types.");
809 error_emitted
= true;
811 tmp
->type
= op
[1]->type
;
814 result
= new ir_dereference(tmp
);
821 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
822 if (op
[0]->type
->base_type
== GLSL_TYPE_FLOAT
)
823 op
[1] = new ir_constant(1.0f
);
825 op
[1] = new ir_constant(1);
827 type
= arithmetic_result_type(op
[0], op
[1], false, state
);
829 struct ir_rvalue
*temp_rhs
;
830 temp_rhs
= new ir_expression(operations
[this->oper
], type
,
833 result
= do_assignment(instructions
, state
, op
[0], temp_rhs
,
834 this->subexpressions
[0]->get_location());
836 error_emitted
= op
[0]->type
->is_error();
842 op
[0] = this->subexpressions
[0]->hir(instructions
, state
);
843 if (op
[0]->type
->base_type
== GLSL_TYPE_FLOAT
)
844 op
[1] = new ir_constant(1.0f
);
846 op
[1] = new ir_constant(1);
848 error_emitted
= op
[0]->type
->is_error() || op
[1]->type
->is_error();
850 type
= arithmetic_result_type(op
[0], op
[1], false, state
);
852 struct ir_rvalue
*temp_rhs
;
853 temp_rhs
= new ir_expression(operations
[this->oper
], type
,
856 /* Get a temporary of a copy of the lvalue before it's modified.
857 * This may get thrown away later.
859 result
= get_lvalue_copy(instructions
, state
, op
[0],
860 this->subexpressions
[0]->get_location());
862 (void)do_assignment(instructions
, state
, op
[0], temp_rhs
,
863 this->subexpressions
[0]->get_location());
866 error_emitted
= op
[0]->type
->is_error();
870 case ast_field_selection
:
871 result
= _mesa_ast_field_selection_to_hir(this, instructions
, state
);
875 case ast_array_index
:
878 case ast_function_call
:
879 /* Should *NEVER* get here. ast_function_call should always be handled
880 * by ast_function_expression::hir.
885 case ast_identifier
: {
886 /* ast_identifier can appear several places in a full abstract syntax
887 * tree. This particular use must be at location specified in the grammar
888 * as 'variable_identifier'.
891 state
->symbols
->get_variable(this->primary_expression
.identifier
);
893 result
= new ir_dereference(var
);
898 _mesa_glsl_error(& loc
, state
, "`%s' undeclared",
899 this->primary_expression
.identifier
);
901 error_emitted
= true;
906 case ast_int_constant
:
907 type
= glsl_type::int_type
;
908 result
= new ir_constant(type
, & this->primary_expression
);
911 case ast_uint_constant
:
912 type
= glsl_type::uint_type
;
913 result
= new ir_constant(type
, & this->primary_expression
);
916 case ast_float_constant
:
917 type
= glsl_type::float_type
;
918 result
= new ir_constant(type
, & this->primary_expression
);
921 case ast_bool_constant
:
922 type
= glsl_type::bool_type
;
923 result
= new ir_constant(type
, & this->primary_expression
);
927 struct simple_node
*ptr
;
929 /* It should not be possible to generate a sequence in the AST without
930 * any expressions in it.
932 assert(!is_empty_list(&this->expressions
));
934 /* The r-value of a sequence is the last expression in the sequence. If
935 * the other expressions in the sequence do not have side-effects (and
936 * therefore add instructions to the instruction list), they get dropped
939 foreach (ptr
, &this->expressions
)
940 result
= ((ast_node
*)ptr
)->hir(instructions
, state
);
944 /* Any errors should have already been emitted in the loop above.
946 error_emitted
= true;
951 if (type
->is_error() && !error_emitted
)
952 _mesa_glsl_error(& loc
, state
, "type mismatch");
959 ast_expression_statement::hir(exec_list
*instructions
,
960 struct _mesa_glsl_parse_state
*state
)
962 /* It is possible to have expression statements that don't have an
963 * expression. This is the solitary semicolon:
965 * for (i = 0; i < 5; i++)
968 * In this case the expression will be NULL. Test for NULL and don't do
969 * anything in that case.
971 if (expression
!= NULL
)
972 expression
->hir(instructions
, state
);
974 /* Statements do not have r-values.
981 ast_compound_statement::hir(exec_list
*instructions
,
982 struct _mesa_glsl_parse_state
*state
)
984 struct simple_node
*ptr
;
988 state
->symbols
->push_scope();
990 foreach (ptr
, &statements
)
991 ((ast_node
*)ptr
)->hir(instructions
, state
);
994 state
->symbols
->pop_scope();
996 /* Compound statements do not have r-values.
1002 static const glsl_type
*
1003 process_array_type(const glsl_type
*base
, ast_node
*array_size
,
1004 struct _mesa_glsl_parse_state
*state
)
1006 unsigned length
= 0;
1008 /* FINISHME: Reject delcarations of multidimensional arrays. */
1010 if (array_size
!= NULL
) {
1011 exec_list dummy_instructions
;
1012 ir_rvalue
*const ir
= array_size
->hir(& dummy_instructions
, state
);
1013 YYLTYPE loc
= array_size
->get_location();
1015 /* FINISHME: Verify that the grammar forbids side-effects in array
1016 * FINISHME: sizes. i.e., 'vec4 [x = 12] data'
1018 assert(dummy_instructions
.is_empty());
1021 if (!ir
->type
->is_integer()) {
1022 _mesa_glsl_error(& loc
, state
, "array size must be integer type");
1023 } else if (!ir
->type
->is_scalar()) {
1024 _mesa_glsl_error(& loc
, state
, "array size must be scalar type");
1026 ir_constant
*const size
= ir
->constant_expression_value();
1029 _mesa_glsl_error(& loc
, state
, "array size must be a "
1030 "constant valued expression");
1031 } else if (size
->value
.i
[0] <= 0) {
1032 _mesa_glsl_error(& loc
, state
, "array size must be > 0");
1034 assert(size
->type
== ir
->type
);
1035 length
= size
->value
.u
[0];
1041 return glsl_type::get_array_instance(base
, length
);
1045 static const struct glsl_type
*
1046 type_specifier_to_glsl_type(const struct ast_type_specifier
*spec
,
1048 struct _mesa_glsl_parse_state
*state
)
1050 const glsl_type
*type
;
1052 if (spec
->type_specifier
== ast_struct
) {
1053 /* FINISHME: Handle annonymous structures. */
1056 type
= state
->symbols
->get_type(spec
->type_name
);
1057 *name
= spec
->type_name
;
1059 if (spec
->is_array
) {
1060 type
= process_array_type(type
, spec
->array_size
, state
);
1069 apply_type_qualifier_to_variable(const struct ast_type_qualifier
*qual
,
1070 struct ir_variable
*var
,
1071 struct _mesa_glsl_parse_state
*state
,
1074 if (qual
->invariant
)
1077 /* FINISHME: Mark 'in' variables at global scope as read-only. */
1078 if (qual
->constant
|| qual
->attribute
|| qual
->uniform
1079 || (qual
->varying
&& (state
->target
== fragment_shader
)))
1085 if (qual
->attribute
&& state
->target
== fragment_shader
) {
1086 var
->type
= glsl_type::error_type
;
1087 _mesa_glsl_error(loc
, state
,
1088 "`attribute' variables may not be declared in the "
1092 if (qual
->in
&& qual
->out
)
1093 var
->mode
= ir_var_inout
;
1094 else if (qual
->attribute
|| qual
->in
1095 || (qual
->varying
&& (state
->target
== fragment_shader
)))
1096 var
->mode
= ir_var_in
;
1097 else if (qual
->out
|| (qual
->varying
&& (state
->target
== vertex_shader
)))
1098 var
->mode
= ir_var_out
;
1099 else if (qual
->uniform
)
1100 var
->mode
= ir_var_uniform
;
1102 var
->mode
= ir_var_auto
;
1105 var
->interpolation
= ir_var_flat
;
1106 else if (qual
->noperspective
)
1107 var
->interpolation
= ir_var_noperspective
;
1109 var
->interpolation
= ir_var_smooth
;
1114 ast_declarator_list::hir(exec_list
*instructions
,
1115 struct _mesa_glsl_parse_state
*state
)
1117 struct simple_node
*ptr
;
1118 const struct glsl_type
*decl_type
;
1119 const char *type_name
= NULL
;
1122 /* FINISHME: Handle vertex shader "invariant" declarations that do not
1123 * FINISHME: include a type. These re-declare built-in variables to be
1124 * FINISHME: invariant.
1127 decl_type
= type_specifier_to_glsl_type(this->type
->specifier
,
1128 & type_name
, state
);
1130 foreach (ptr
, &this->declarations
) {
1131 struct ast_declaration
*const decl
= (struct ast_declaration
* )ptr
;
1132 const struct glsl_type
*var_type
;
1133 struct ir_variable
*var
;
1134 YYLTYPE loc
= this->get_location();
1136 /* FINISHME: Emit a warning if a variable declaration shadows a
1137 * FINISHME: declaration at a higher scope.
1140 if ((decl_type
== NULL
) || decl_type
->is_void()) {
1141 if (type_name
!= NULL
) {
1142 _mesa_glsl_error(& loc
, state
,
1143 "invalid type `%s' in declaration of `%s'",
1144 type_name
, decl
->identifier
);
1146 _mesa_glsl_error(& loc
, state
,
1147 "invalid type in declaration of `%s'",
1153 if (decl
->is_array
) {
1154 var_type
= process_array_type(decl_type
, decl
->array_size
, state
);
1156 var_type
= decl_type
;
1159 var
= new ir_variable(var_type
, decl
->identifier
);
1161 /* FINISHME: Variables that are attribute, uniform, varying, in, or
1162 * FINISHME: out varibles must be declared either at global scope or
1163 * FINISHME: in a parameter list (in and out only).
1166 apply_type_qualifier_to_variable(& this->type
->qualifier
, var
, state
,
1169 /* Attempt to add the variable to the symbol table. If this fails, it
1170 * means the variable has already been declared at this scope.
1172 if (state
->symbols
->name_declared_this_scope(decl
->identifier
)) {
1173 YYLTYPE loc
= this->get_location();
1175 _mesa_glsl_error(& loc
, state
, "`%s' redeclared",
1180 instructions
->push_tail(var
);
1182 if (this->type
->qualifier
.attribute
1183 && (state
->current_function
!= NULL
)) {
1184 _mesa_glsl_error(& loc
, state
,
1185 "attribute variable `%s' must be declared at global "
1190 if ((var
->mode
== ir_var_in
) && (state
->current_function
== NULL
)) {
1191 if (state
->target
== vertex_shader
) {
1192 bool error_emitted
= false;
1194 /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
1196 * "Vertex shader inputs can only be float, floating-point
1197 * vectors, matrices, signed and unsigned integers and integer
1198 * vectors. Vertex shader inputs can also form arrays of these
1199 * types, but not structures."
1201 * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec:
1203 * "Vertex shader inputs can only be float, floating-point
1204 * vectors, matrices, signed and unsigned integers and integer
1205 * vectors. They cannot be arrays or structures."
1207 * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
1209 * "The attribute qualifier can be used only with float,
1210 * floating-point vectors, and matrices. Attribute variables
1211 * cannot be declared as arrays or structures."
1213 const glsl_type
*check_type
= var
->type
->is_array()
1214 ? var
->type
->fields
.array
: var
->type
;
1216 switch (check_type
->base_type
) {
1217 case GLSL_TYPE_FLOAT
:
1219 case GLSL_TYPE_UINT
:
1221 if (state
->language_version
> 120)
1225 _mesa_glsl_error(& loc
, state
,
1226 "vertex shader input / attribute cannot have "
1228 var
->type
->is_array() ? "array of " : "",
1230 error_emitted
= true;
1233 if (!error_emitted
&& (state
->language_version
<= 130)
1234 && var
->type
->is_array()) {
1235 _mesa_glsl_error(& loc
, state
,
1236 "vertex shader input / attribute cannot have "
1238 error_emitted
= true;
1243 if (decl
->initializer
!= NULL
) {
1244 YYLTYPE initializer_loc
= decl
->initializer
->get_location();
1246 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec:
1248 * "All uniform variables are read-only and are initialized either
1249 * directly by an application via API commands, or indirectly by
1252 if ((state
->language_version
<= 110)
1253 && (var
->mode
== ir_var_uniform
)) {
1254 _mesa_glsl_error(& initializer_loc
, state
,
1255 "cannot initialize uniforms in GLSL 1.10");
1258 if (var
->type
->is_sampler()) {
1259 _mesa_glsl_error(& initializer_loc
, state
,
1260 "cannot initialize samplers");
1263 if ((var
->mode
== ir_var_in
) && (state
->current_function
== NULL
)) {
1264 _mesa_glsl_error(& initializer_loc
, state
,
1265 "cannot initialize %s shader input / %s",
1266 (state
->target
== vertex_shader
)
1267 ? "vertex" : "fragment",
1268 (state
->target
== vertex_shader
)
1269 ? "attribute" : "varying");
1272 ir_dereference
*const lhs
= new ir_dereference(var
);
1273 ir_rvalue
*const rhs
= decl
->initializer
->hir(instructions
, state
);
1275 /* FINISHME: If the declaration is either 'const' or 'uniform', the
1276 * FINISHME: initializer (rhs) must be a constant expression.
1279 if (!rhs
->type
->is_error()) {
1280 (void) do_assignment(instructions
, state
, lhs
, rhs
,
1281 this->get_location());
1285 /* Add the vairable to the symbol table after processing the initializer.
1286 * This differs from most C-like languages, but it follows the GLSL
1287 * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50
1290 * "Within a declaration, the scope of a name starts immediately
1291 * after the initializer if present or immediately after the name
1292 * being declared if not."
1294 const bool added_variable
=
1295 state
->symbols
->add_variable(decl
->identifier
, var
);
1296 assert(added_variable
);
1299 /* Variable declarations do not have r-values.
1306 ast_parameter_declarator::hir(exec_list
*instructions
,
1307 struct _mesa_glsl_parse_state
*state
)
1309 const struct glsl_type
*type
;
1310 const char *name
= NULL
;
1311 YYLTYPE loc
= this->get_location();
1313 type
= type_specifier_to_glsl_type(this->type
->specifier
, & name
, state
);
1317 _mesa_glsl_error(& loc
, state
,
1318 "invalid type `%s' in declaration of `%s'",
1319 name
, this->identifier
);
1321 _mesa_glsl_error(& loc
, state
,
1322 "invalid type in declaration of `%s'",
1326 type
= glsl_type::error_type
;
1329 ir_variable
*var
= new ir_variable(type
, this->identifier
);
1331 /* FINISHME: Handle array declarations. Note that this requires
1332 * FINISHME: complete handling of constant expressions.
1335 /* Apply any specified qualifiers to the parameter declaration. Note that
1336 * for function parameters the default mode is 'in'.
1338 apply_type_qualifier_to_variable(& this->type
->qualifier
, var
, state
, & loc
);
1339 if (var
->mode
== ir_var_auto
)
1340 var
->mode
= ir_var_in
;
1342 instructions
->push_tail(var
);
1344 /* Parameter declarations do not have r-values.
1351 ast_function_parameters_to_hir(struct simple_node
*ast_parameters
,
1352 exec_list
*ir_parameters
,
1353 struct _mesa_glsl_parse_state
*state
)
1355 struct simple_node
*ptr
;
1357 foreach (ptr
, ast_parameters
) {
1358 ((ast_node
*)ptr
)->hir(ir_parameters
, state
);
1364 parameter_lists_match(exec_list
*list_a
, exec_list
*list_b
)
1366 exec_list_iterator iter_a
= list_a
->iterator();
1367 exec_list_iterator iter_b
= list_b
->iterator();
1369 while (iter_a
.has_next()) {
1370 /* If all of the parameters from the other parameter list have been
1371 * exhausted, the lists have different length and, by definition,
1374 if (!iter_b
.has_next())
1377 /* If the types of the parameters do not match, the parameters lists
1392 ast_function_definition::hir(exec_list
*instructions
,
1393 struct _mesa_glsl_parse_state
*state
)
1396 ir_function_signature
*signature
= NULL
;
1397 ir_function
*f
= NULL
;
1398 exec_list parameters
;
1401 /* Convert the list of function parameters to HIR now so that they can be
1402 * used below to compare this function's signature with previously seen
1403 * signatures for functions with the same name.
1405 ast_function_parameters_to_hir(& this->prototype
->parameters
, & parameters
,
1408 const char *return_type_name
;
1409 const glsl_type
*return_type
=
1410 type_specifier_to_glsl_type(this->prototype
->return_type
->specifier
,
1411 & return_type_name
, state
);
1413 assert(return_type
!= NULL
);
1415 /* Verify that this function's signature either doesn't match a previously
1416 * seen signature for a function with the same name, or, if a match is found,
1417 * that the previously seen signature does not have an associated definition.
1419 const char *const name
= this->prototype
->identifier
;
1420 f
= state
->symbols
->get_function(name
);
1422 foreach_iter(exec_list_iterator
, iter
, f
->signatures
) {
1423 signature
= (struct ir_function_signature
*) iter
.get();
1425 /* Compare the parameter list of the function being defined to the
1426 * existing function. If the parameter lists match, then the return
1427 * type must also match and the existing function must not have a
1430 if (parameter_lists_match(& parameters
, & signature
->parameters
)) {
1431 /* FINISHME: Compare return types. */
1433 if (signature
->definition
!= NULL
) {
1434 YYLTYPE loc
= this->get_location();
1436 _mesa_glsl_error(& loc
, state
, "function `%s' redefined", name
);
1445 } else if (state
->symbols
->name_declared_this_scope(name
)) {
1446 /* This function name shadows a non-function use of the same name.
1448 YYLTYPE loc
= this->get_location();
1450 _mesa_glsl_error(& loc
, state
, "function name `%s' conflicts with "
1451 "non-function", name
);
1454 f
= new ir_function(name
);
1455 state
->symbols
->add_function(f
->name
, f
);
1458 /* Verify the return type of main() */
1459 if (strcmp(name
, "main") == 0) {
1460 if (return_type
!= glsl_type::get_instance(GLSL_TYPE_VOID
, 0, 0)) {
1461 YYLTYPE loc
= this->get_location();
1463 _mesa_glsl_error(& loc
, state
, "main() must return void");
1467 /* Finish storing the information about this new function in its signature.
1469 if (signature
== NULL
) {
1470 signature
= new ir_function_signature(return_type
);
1471 f
->signatures
.push_tail(signature
);
1473 /* Destroy all of the previous parameter information. The previous
1474 * parameter information comes from the function prototype, and it can
1475 * either include invalid parameter names or may not have names at all.
1477 foreach_iter(exec_list_iterator
, iter
, signature
->parameters
) {
1478 assert(((ir_instruction
*) iter
.get())->as_variable() != NULL
);
1486 assert(state
->current_function
== NULL
);
1487 state
->current_function
= signature
;
1489 ast_function_parameters_to_hir(& this->prototype
->parameters
,
1490 & signature
->parameters
,
1492 /* FINISHME: Set signature->return_type */
1494 label
= new ir_label(name
);
1495 if (signature
->definition
== NULL
) {
1496 signature
->definition
= label
;
1498 instructions
->push_tail(label
);
1500 /* Add the function parameters to the symbol table. During this step the
1501 * parameter declarations are also moved from the temporary "parameters" list
1502 * to the instruction list. There are other more efficient ways to do this,
1503 * but they involve ugly linked-list gymnastics.
1505 state
->symbols
->push_scope();
1506 foreach_iter(exec_list_iterator
, iter
, parameters
) {
1507 ir_variable
*const var
= (ir_variable
*) iter
.get();
1509 assert(((ir_instruction
*) var
)->as_variable() != NULL
);
1512 instructions
->push_tail(var
);
1514 /* The only way a parameter would "exist" is if two parameters have
1517 if (state
->symbols
->name_declared_this_scope(var
->name
)) {
1518 YYLTYPE loc
= this->get_location();
1520 _mesa_glsl_error(& loc
, state
, "parameter `%s' redeclared", var
->name
);
1522 state
->symbols
->add_variable(var
->name
, var
);
1526 /* Convert the body of the function to HIR, and append the resulting
1527 * instructions to the list that currently consists of the function label
1528 * and the function parameters.
1530 this->body
->hir(instructions
, state
);
1532 state
->symbols
->pop_scope();
1534 assert(state
->current_function
== signature
);
1535 state
->current_function
= NULL
;
1537 /* Function definitions do not have r-values.
1544 ast_jump_statement::hir(exec_list
*instructions
,
1545 struct _mesa_glsl_parse_state
*state
)
1548 if (mode
== ast_return
) {
1550 assert(state
->current_function
);
1552 if (opt_return_value
) {
1553 if (state
->current_function
->return_type
->base_type
==
1555 YYLTYPE loc
= this->get_location();
1557 _mesa_glsl_error(& loc
, state
,
1558 "`return` with a value, in function `%s' "
1560 state
->current_function
->definition
->label
);
1563 ir_expression
*const ret
= (ir_expression
*)
1564 opt_return_value
->hir(instructions
, state
);
1565 assert(ret
!= NULL
);
1567 /* FINISHME: Make sure the type of the return value matches the return
1568 * FINISHME: type of the enclosing function.
1571 inst
= new ir_return(ret
);
1573 if (state
->current_function
->return_type
->base_type
!=
1575 YYLTYPE loc
= this->get_location();
1577 _mesa_glsl_error(& loc
, state
,
1578 "`return' with no value, in function %s returning "
1580 state
->current_function
->definition
->label
);
1582 inst
= new ir_return
;
1585 instructions
->push_tail(inst
);
1588 /* Jump instructions do not have r-values.
1595 ast_selection_statement::hir(exec_list
*instructions
,
1596 struct _mesa_glsl_parse_state
*state
)
1598 ir_rvalue
*const condition
= this->condition
->hir(instructions
, state
);
1600 /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec:
1602 * "Any expression whose type evaluates to a Boolean can be used as the
1603 * conditional expression bool-expression. Vector types are not accepted
1604 * as the expression to if."
1606 * The checks are separated so that higher quality diagnostics can be
1607 * generated for cases where both rules are violated.
1609 if (!condition
->type
->is_boolean() || !condition
->type
->is_scalar()) {
1610 YYLTYPE loc
= this->condition
->get_location();
1612 _mesa_glsl_error(& loc
, state
, "if-statement condition must be scalar "
1616 ir_if
*const stmt
= new ir_if(condition
);
1618 if (then_statement
!= NULL
) {
1619 ast_node
*node
= (ast_node
*) then_statement
;
1621 node
->hir(& stmt
->then_instructions
, state
);
1622 node
= (ast_node
*) node
->next
;
1623 } while (node
!= then_statement
);
1626 if (else_statement
!= NULL
) {
1627 ast_node
*node
= (ast_node
*) else_statement
;
1629 node
->hir(& stmt
->else_instructions
, state
);
1630 node
= (ast_node
*) node
->next
;
1631 } while (node
!= else_statement
);
1634 instructions
->push_tail(stmt
);
1636 /* if-statements do not have r-values.