ast_to_hir.cpp revision aa5ec137757323b424d0f2638c50c93b9b06ffff
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 "program/hash_table.h" 58#include "ir.h" 59 60static void 61detect_conflicting_assignments(struct _mesa_glsl_parse_state *state, 62 exec_list *instructions); 63 64void 65_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) 66{ 67 _mesa_glsl_initialize_variables(instructions, state); 68 69 state->symbols->language_version = state->language_version; 70 71 state->current_function = NULL; 72 73 state->toplevel_ir = instructions; 74 75 /* Section 4.2 of the GLSL 1.20 specification states: 76 * "The built-in functions are scoped in a scope outside the global scope 77 * users declare global variables in. That is, a shader's global scope, 78 * available for user-defined functions and global variables, is nested 79 * inside the scope containing the built-in functions." 80 * 81 * Since built-in functions like ftransform() access built-in variables, 82 * it follows that those must be in the outer scope as well. 83 * 84 * We push scope here to create this nesting effect...but don't pop. 85 * This way, a shader's globals are still in the symbol table for use 86 * by the linker. 87 */ 88 state->symbols->push_scope(); 89 90 foreach_list_typed (ast_node, ast, link, & state->translation_unit) 91 ast->hir(instructions, state); 92 93 detect_recursion_unlinked(state, instructions); 94 detect_conflicting_assignments(state, instructions); 95 96 state->toplevel_ir = NULL; 97} 98 99 100/** 101 * If a conversion is available, convert one operand to a different type 102 * 103 * The \c from \c ir_rvalue is converted "in place". 104 * 105 * \param to Type that the operand it to be converted to 106 * \param from Operand that is being converted 107 * \param state GLSL compiler state 108 * 109 * \return 110 * If a conversion is possible (or unnecessary), \c true is returned. 111 * Otherwise \c false is returned. 112 */ 113bool 114apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, 115 struct _mesa_glsl_parse_state *state) 116{ 117 void *ctx = state; 118 if (to->base_type == from->type->base_type) 119 return true; 120 121 /* This conversion was added in GLSL 1.20. If the compilation mode is 122 * GLSL 1.10, the conversion is skipped. 123 */ 124 if (state->language_version < 120) 125 return false; 126 127 /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec: 128 * 129 * "There are no implicit array or structure conversions. For 130 * example, an array of int cannot be implicitly converted to an 131 * array of float. There are no implicit conversions between 132 * signed and unsigned integers." 133 */ 134 /* FINISHME: The above comment is partially a lie. There is int/uint 135 * FINISHME: conversion for immediate constants. 136 */ 137 if (!to->is_float() || !from->type->is_numeric()) 138 return false; 139 140 /* Convert to a floating point type with the same number of components 141 * as the original type - i.e. int to float, not int to vec4. 142 */ 143 to = glsl_type::get_instance(GLSL_TYPE_FLOAT, from->type->vector_elements, 144 from->type->matrix_columns); 145 146 switch (from->type->base_type) { 147 case GLSL_TYPE_INT: 148 from = new(ctx) ir_expression(ir_unop_i2f, to, from, NULL); 149 break; 150 case GLSL_TYPE_UINT: 151 from = new(ctx) ir_expression(ir_unop_u2f, to, from, NULL); 152 break; 153 case GLSL_TYPE_BOOL: 154 from = new(ctx) ir_expression(ir_unop_b2f, to, from, NULL); 155 break; 156 default: 157 assert(0); 158 } 159 160 return true; 161} 162 163 164static const struct glsl_type * 165arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b, 166 bool multiply, 167 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 168{ 169 const glsl_type *type_a = value_a->type; 170 const glsl_type *type_b = value_b->type; 171 172 /* From GLSL 1.50 spec, page 56: 173 * 174 * "The arithmetic binary operators add (+), subtract (-), 175 * multiply (*), and divide (/) operate on integer and 176 * floating-point scalars, vectors, and matrices." 177 */ 178 if (!type_a->is_numeric() || !type_b->is_numeric()) { 179 _mesa_glsl_error(loc, state, 180 "Operands to arithmetic operators must be numeric"); 181 return glsl_type::error_type; 182 } 183 184 185 /* "If one operand is floating-point based and the other is 186 * not, then the conversions from Section 4.1.10 "Implicit 187 * Conversions" are applied to the non-floating-point-based operand." 188 */ 189 if (!apply_implicit_conversion(type_a, value_b, state) 190 && !apply_implicit_conversion(type_b, value_a, state)) { 191 _mesa_glsl_error(loc, state, 192 "Could not implicitly convert operands to " 193 "arithmetic operator"); 194 return glsl_type::error_type; 195 } 196 type_a = value_a->type; 197 type_b = value_b->type; 198 199 /* "If the operands are integer types, they must both be signed or 200 * both be unsigned." 201 * 202 * From this rule and the preceeding conversion it can be inferred that 203 * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT. 204 * The is_numeric check above already filtered out the case where either 205 * type is not one of these, so now the base types need only be tested for 206 * equality. 207 */ 208 if (type_a->base_type != type_b->base_type) { 209 _mesa_glsl_error(loc, state, 210 "base type mismatch for arithmetic operator"); 211 return glsl_type::error_type; 212 } 213 214 /* "All arithmetic binary operators result in the same fundamental type 215 * (signed integer, unsigned integer, or floating-point) as the 216 * operands they operate on, after operand type conversion. After 217 * conversion, the following cases are valid 218 * 219 * * The two operands are scalars. In this case the operation is 220 * applied, resulting in a scalar." 221 */ 222 if (type_a->is_scalar() && type_b->is_scalar()) 223 return type_a; 224 225 /* "* One operand is a scalar, and the other is a vector or matrix. 226 * In this case, the scalar operation is applied independently to each 227 * component of the vector or matrix, resulting in the same size 228 * vector or matrix." 229 */ 230 if (type_a->is_scalar()) { 231 if (!type_b->is_scalar()) 232 return type_b; 233 } else if (type_b->is_scalar()) { 234 return type_a; 235 } 236 237 /* All of the combinations of <scalar, scalar>, <vector, scalar>, 238 * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been 239 * handled. 240 */ 241 assert(!type_a->is_scalar()); 242 assert(!type_b->is_scalar()); 243 244 /* "* The two operands are vectors of the same size. In this case, the 245 * operation is done component-wise resulting in the same size 246 * vector." 247 */ 248 if (type_a->is_vector() && type_b->is_vector()) { 249 if (type_a == type_b) { 250 return type_a; 251 } else { 252 _mesa_glsl_error(loc, state, 253 "vector size mismatch for arithmetic operator"); 254 return glsl_type::error_type; 255 } 256 } 257 258 /* All of the combinations of <scalar, scalar>, <vector, scalar>, 259 * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and 260 * <vector, vector> have been handled. At least one of the operands must 261 * be matrix. Further, since there are no integer matrix types, the base 262 * type of both operands must be float. 263 */ 264 assert(type_a->is_matrix() || type_b->is_matrix()); 265 assert(type_a->base_type == GLSL_TYPE_FLOAT); 266 assert(type_b->base_type == GLSL_TYPE_FLOAT); 267 268 /* "* The operator is add (+), subtract (-), or divide (/), and the 269 * operands are matrices with the same number of rows and the same 270 * number of columns. In this case, the operation is done component- 271 * wise resulting in the same size matrix." 272 * * The operator is multiply (*), where both operands are matrices or 273 * one operand is a vector and the other a matrix. A right vector 274 * operand is treated as a column vector and a left vector operand as a 275 * row vector. In all these cases, it is required that the number of 276 * columns of the left operand is equal to the number of rows of the 277 * right operand. Then, the multiply (*) operation does a linear 278 * algebraic multiply, yielding an object that has the same number of 279 * rows as the left operand and the same number of columns as the right 280 * operand. Section 5.10 "Vector and Matrix Operations" explains in 281 * more detail how vectors and matrices are operated on." 282 */ 283 if (! multiply) { 284 if (type_a == type_b) 285 return type_a; 286 } else { 287 if (type_a->is_matrix() && type_b->is_matrix()) { 288 /* Matrix multiply. The columns of A must match the rows of B. Given 289 * the other previously tested constraints, this means the vector type 290 * of a row from A must be the same as the vector type of a column from 291 * B. 292 */ 293 if (type_a->row_type() == type_b->column_type()) { 294 /* The resulting matrix has the number of columns of matrix B and 295 * the number of rows of matrix A. We get the row count of A by 296 * looking at the size of a vector that makes up a column. The 297 * transpose (size of a row) is done for B. 298 */ 299 const glsl_type *const type = 300 glsl_type::get_instance(type_a->base_type, 301 type_a->column_type()->vector_elements, 302 type_b->row_type()->vector_elements); 303 assert(type != glsl_type::error_type); 304 305 return type; 306 } 307 } else if (type_a->is_matrix()) { 308 /* A is a matrix and B is a column vector. Columns of A must match 309 * rows of B. Given the other previously tested constraints, this 310 * means the vector type of a row from A must be the same as the 311 * vector the type of B. 312 */ 313 if (type_a->row_type() == type_b) { 314 /* The resulting vector has a number of elements equal to 315 * the number of rows of matrix A. */ 316 const glsl_type *const type = 317 glsl_type::get_instance(type_a->base_type, 318 type_a->column_type()->vector_elements, 319 1); 320 assert(type != glsl_type::error_type); 321 322 return type; 323 } 324 } else { 325 assert(type_b->is_matrix()); 326 327 /* A is a row vector and B is a matrix. Columns of A must match rows 328 * of B. Given the other previously tested constraints, this means 329 * the type of A must be the same as the vector type of a column from 330 * B. 331 */ 332 if (type_a == type_b->column_type()) { 333 /* The resulting vector has a number of elements equal to 334 * the number of columns of matrix B. */ 335 const glsl_type *const type = 336 glsl_type::get_instance(type_a->base_type, 337 type_b->row_type()->vector_elements, 338 1); 339 assert(type != glsl_type::error_type); 340 341 return type; 342 } 343 } 344 345 _mesa_glsl_error(loc, state, "size mismatch for matrix multiplication"); 346 return glsl_type::error_type; 347 } 348 349 350 /* "All other cases are illegal." 351 */ 352 _mesa_glsl_error(loc, state, "type mismatch"); 353 return glsl_type::error_type; 354} 355 356 357static const struct glsl_type * 358unary_arithmetic_result_type(const struct glsl_type *type, 359 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 360{ 361 /* From GLSL 1.50 spec, page 57: 362 * 363 * "The arithmetic unary operators negate (-), post- and pre-increment 364 * and decrement (-- and ++) operate on integer or floating-point 365 * values (including vectors and matrices). All unary operators work 366 * component-wise on their operands. These result with the same type 367 * they operated on." 368 */ 369 if (!type->is_numeric()) { 370 _mesa_glsl_error(loc, state, 371 "Operands to arithmetic operators must be numeric"); 372 return glsl_type::error_type; 373 } 374 375 return type; 376} 377 378/** 379 * \brief Return the result type of a bit-logic operation. 380 * 381 * If the given types to the bit-logic operator are invalid, return 382 * glsl_type::error_type. 383 * 384 * \param type_a Type of LHS of bit-logic op 385 * \param type_b Type of RHS of bit-logic op 386 */ 387static const struct glsl_type * 388bit_logic_result_type(const struct glsl_type *type_a, 389 const struct glsl_type *type_b, 390 ast_operators op, 391 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 392{ 393 if (state->language_version < 130) { 394 _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30"); 395 return glsl_type::error_type; 396 } 397 398 /* From page 50 (page 56 of PDF) of GLSL 1.30 spec: 399 * 400 * "The bitwise operators and (&), exclusive-or (^), and inclusive-or 401 * (|). The operands must be of type signed or unsigned integers or 402 * integer vectors." 403 */ 404 if (!type_a->is_integer()) { 405 _mesa_glsl_error(loc, state, "LHS of `%s' must be an integer", 406 ast_expression::operator_string(op)); 407 return glsl_type::error_type; 408 } 409 if (!type_b->is_integer()) { 410 _mesa_glsl_error(loc, state, "RHS of `%s' must be an integer", 411 ast_expression::operator_string(op)); 412 return glsl_type::error_type; 413 } 414 415 /* "The fundamental types of the operands (signed or unsigned) must 416 * match," 417 */ 418 if (type_a->base_type != type_b->base_type) { 419 _mesa_glsl_error(loc, state, "operands of `%s' must have the same " 420 "base type", ast_expression::operator_string(op)); 421 return glsl_type::error_type; 422 } 423 424 /* "The operands cannot be vectors of differing size." */ 425 if (type_a->is_vector() && 426 type_b->is_vector() && 427 type_a->vector_elements != type_b->vector_elements) { 428 _mesa_glsl_error(loc, state, "operands of `%s' cannot be vectors of " 429 "different sizes", ast_expression::operator_string(op)); 430 return glsl_type::error_type; 431 } 432 433 /* "If one operand is a scalar and the other a vector, the scalar is 434 * applied component-wise to the vector, resulting in the same type as 435 * the vector. The fundamental types of the operands [...] will be the 436 * resulting fundamental type." 437 */ 438 if (type_a->is_scalar()) 439 return type_b; 440 else 441 return type_a; 442} 443 444static const struct glsl_type * 445modulus_result_type(const struct glsl_type *type_a, 446 const struct glsl_type *type_b, 447 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 448{ 449 if (state->language_version < 130) { 450 _mesa_glsl_error(loc, state, 451 "operator '%%' is reserved in %s", 452 state->version_string); 453 return glsl_type::error_type; 454 } 455 456 /* From GLSL 1.50 spec, page 56: 457 * "The operator modulus (%) operates on signed or unsigned integers or 458 * integer vectors. The operand types must both be signed or both be 459 * unsigned." 460 */ 461 if (!type_a->is_integer()) { 462 _mesa_glsl_error(loc, state, "LHS of operator %% must be an integer."); 463 return glsl_type::error_type; 464 } 465 if (!type_b->is_integer()) { 466 _mesa_glsl_error(loc, state, "RHS of operator %% must be an integer."); 467 return glsl_type::error_type; 468 } 469 if (type_a->base_type != type_b->base_type) { 470 _mesa_glsl_error(loc, state, 471 "operands of %% must have the same base type"); 472 return glsl_type::error_type; 473 } 474 475 /* "The operands cannot be vectors of differing size. If one operand is 476 * a scalar and the other vector, then the scalar is applied component- 477 * wise to the vector, resulting in the same type as the vector. If both 478 * are vectors of the same size, the result is computed component-wise." 479 */ 480 if (type_a->is_vector()) { 481 if (!type_b->is_vector() 482 || (type_a->vector_elements == type_b->vector_elements)) 483 return type_a; 484 } else 485 return type_b; 486 487 /* "The operator modulus (%) is not defined for any other data types 488 * (non-integer types)." 489 */ 490 _mesa_glsl_error(loc, state, "type mismatch"); 491 return glsl_type::error_type; 492} 493 494 495static const struct glsl_type * 496relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b, 497 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 498{ 499 const glsl_type *type_a = value_a->type; 500 const glsl_type *type_b = value_b->type; 501 502 /* From GLSL 1.50 spec, page 56: 503 * "The relational operators greater than (>), less than (<), greater 504 * than or equal (>=), and less than or equal (<=) operate only on 505 * scalar integer and scalar floating-point expressions." 506 */ 507 if (!type_a->is_numeric() 508 || !type_b->is_numeric() 509 || !type_a->is_scalar() 510 || !type_b->is_scalar()) { 511 _mesa_glsl_error(loc, state, 512 "Operands to relational operators must be scalar and " 513 "numeric"); 514 return glsl_type::error_type; 515 } 516 517 /* "Either the operands' types must match, or the conversions from 518 * Section 4.1.10 "Implicit Conversions" will be applied to the integer 519 * operand, after which the types must match." 520 */ 521 if (!apply_implicit_conversion(type_a, value_b, state) 522 && !apply_implicit_conversion(type_b, value_a, state)) { 523 _mesa_glsl_error(loc, state, 524 "Could not implicitly convert operands to " 525 "relational operator"); 526 return glsl_type::error_type; 527 } 528 type_a = value_a->type; 529 type_b = value_b->type; 530 531 if (type_a->base_type != type_b->base_type) { 532 _mesa_glsl_error(loc, state, "base type mismatch"); 533 return glsl_type::error_type; 534 } 535 536 /* "The result is scalar Boolean." 537 */ 538 return glsl_type::bool_type; 539} 540 541/** 542 * \brief Return the result type of a bit-shift operation. 543 * 544 * If the given types to the bit-shift operator are invalid, return 545 * glsl_type::error_type. 546 * 547 * \param type_a Type of LHS of bit-shift op 548 * \param type_b Type of RHS of bit-shift op 549 */ 550static const struct glsl_type * 551shift_result_type(const struct glsl_type *type_a, 552 const struct glsl_type *type_b, 553 ast_operators op, 554 struct _mesa_glsl_parse_state *state, YYLTYPE *loc) 555{ 556 if (state->language_version < 130) { 557 _mesa_glsl_error(loc, state, "bit operations require GLSL 1.30"); 558 return glsl_type::error_type; 559 } 560 561 /* From page 50 (page 56 of the PDF) of the GLSL 1.30 spec: 562 * 563 * "The shift operators (<<) and (>>). For both operators, the operands 564 * must be signed or unsigned integers or integer vectors. One operand 565 * can be signed while the other is unsigned." 566 */ 567 if (!type_a->is_integer()) { 568 _mesa_glsl_error(loc, state, "LHS of operator %s must be an integer or " 569 "integer vector", ast_expression::operator_string(op)); 570 return glsl_type::error_type; 571 572 } 573 if (!type_b->is_integer()) { 574 _mesa_glsl_error(loc, state, "RHS of operator %s must be an integer or " 575 "integer vector", ast_expression::operator_string(op)); 576 return glsl_type::error_type; 577 } 578 579 /* "If the first operand is a scalar, the second operand has to be 580 * a scalar as well." 581 */ 582 if (type_a->is_scalar() && !type_b->is_scalar()) { 583 _mesa_glsl_error(loc, state, "If the first operand of %s is scalar, the " 584 "second must be scalar as well", 585 ast_expression::operator_string(op)); 586 return glsl_type::error_type; 587 } 588 589 /* If both operands are vectors, check that they have same number of 590 * elements. 591 */ 592 if (type_a->is_vector() && 593 type_b->is_vector() && 594 type_a->vector_elements != type_b->vector_elements) { 595 _mesa_glsl_error(loc, state, "Vector operands to operator %s must " 596 "have same number of elements", 597 ast_expression::operator_string(op)); 598 return glsl_type::error_type; 599 } 600 601 /* "In all cases, the resulting type will be the same type as the left 602 * operand." 603 */ 604 return type_a; 605} 606 607/** 608 * Validates that a value can be assigned to a location with a specified type 609 * 610 * Validates that \c rhs can be assigned to some location. If the types are 611 * not an exact match but an automatic conversion is possible, \c rhs will be 612 * converted. 613 * 614 * \return 615 * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type. 616 * Otherwise the actual RHS to be assigned will be returned. This may be 617 * \c rhs, or it may be \c rhs after some type conversion. 618 * 619 * \note 620 * In addition to being used for assignments, this function is used to 621 * type-check return values. 622 */ 623ir_rvalue * 624validate_assignment(struct _mesa_glsl_parse_state *state, 625 const glsl_type *lhs_type, ir_rvalue *rhs, 626 bool is_initializer) 627{ 628 /* If there is already some error in the RHS, just return it. Anything 629 * else will lead to an avalanche of error message back to the user. 630 */ 631 if (rhs->type->is_error()) 632 return rhs; 633 634 /* If the types are identical, the assignment can trivially proceed. 635 */ 636 if (rhs->type == lhs_type) 637 return rhs; 638 639 /* If the array element types are the same and the size of the LHS is zero, 640 * the assignment is okay for initializers embedded in variable 641 * declarations. 642 * 643 * Note: Whole-array assignments are not permitted in GLSL 1.10, but this 644 * is handled by ir_dereference::is_lvalue. 645 */ 646 if (is_initializer && lhs_type->is_array() && rhs->type->is_array() 647 && (lhs_type->element_type() == rhs->type->element_type()) 648 && (lhs_type->array_size() == 0)) { 649 return rhs; 650 } 651 652 /* Check for implicit conversion in GLSL 1.20 */ 653 if (apply_implicit_conversion(lhs_type, rhs, state)) { 654 if (rhs->type == lhs_type) 655 return rhs; 656 } 657 658 return NULL; 659} 660 661static void 662mark_whole_array_access(ir_rvalue *access) 663{ 664 ir_dereference_variable *deref = access->as_dereference_variable(); 665 666 if (deref && deref->var) { 667 deref->var->max_array_access = deref->type->length - 1; 668 } 669} 670 671ir_rvalue * 672do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state, 673 const char *non_lvalue_description, 674 ir_rvalue *lhs, ir_rvalue *rhs, bool is_initializer, 675 YYLTYPE lhs_loc) 676{ 677 void *ctx = state; 678 bool error_emitted = (lhs->type->is_error() || rhs->type->is_error()); 679 680 ir_variable *lhs_var = lhs->variable_referenced(); 681 if (lhs_var) 682 lhs_var->assigned = true; 683 684 if (!error_emitted) { 685 if (non_lvalue_description != NULL) { 686 _mesa_glsl_error(&lhs_loc, state, 687 "assignment to %s", 688 non_lvalue_description); 689 error_emitted = true; 690 } else if (lhs->variable_referenced() != NULL 691 && lhs->variable_referenced()->read_only) { 692 _mesa_glsl_error(&lhs_loc, state, 693 "assignment to read-only variable '%s'", 694 lhs->variable_referenced()->name); 695 error_emitted = true; 696 697 } else if (state->language_version <= 110 && lhs->type->is_array()) { 698 /* From page 32 (page 38 of the PDF) of the GLSL 1.10 spec: 699 * 700 * "Other binary or unary expressions, non-dereferenced 701 * arrays, function names, swizzles with repeated fields, 702 * and constants cannot be l-values." 703 */ 704 _mesa_glsl_error(&lhs_loc, state, "whole array assignment is not " 705 "allowed in GLSL 1.10 or GLSL ES 1.00."); 706 error_emitted = true; 707 } else if (!lhs->is_lvalue()) { 708 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment"); 709 error_emitted = true; 710 } 711 } 712 713 ir_rvalue *new_rhs = 714 validate_assignment(state, lhs->type, rhs, is_initializer); 715 if (new_rhs == NULL) { 716 _mesa_glsl_error(& lhs_loc, state, "type mismatch"); 717 } else { 718 rhs = new_rhs; 719 720 /* If the LHS array was not declared with a size, it takes it size from 721 * the RHS. If the LHS is an l-value and a whole array, it must be a 722 * dereference of a variable. Any other case would require that the LHS 723 * is either not an l-value or not a whole array. 724 */ 725 if (lhs->type->array_size() == 0) { 726 ir_dereference *const d = lhs->as_dereference(); 727 728 assert(d != NULL); 729 730 ir_variable *const var = d->variable_referenced(); 731 732 assert(var != NULL); 733 734 if (var->max_array_access >= unsigned(rhs->type->array_size())) { 735 /* FINISHME: This should actually log the location of the RHS. */ 736 _mesa_glsl_error(& lhs_loc, state, "array size must be > %u due to " 737 "previous access", 738 var->max_array_access); 739 } 740 741 var->type = glsl_type::get_array_instance(lhs->type->element_type(), 742 rhs->type->array_size()); 743 d->type = var->type; 744 } 745 mark_whole_array_access(rhs); 746 mark_whole_array_access(lhs); 747 } 748 749 /* Most callers of do_assignment (assign, add_assign, pre_inc/dec, 750 * but not post_inc) need the converted assigned value as an rvalue 751 * to handle things like: 752 * 753 * i = j += 1; 754 * 755 * So we always just store the computed value being assigned to a 756 * temporary and return a deref of that temporary. If the rvalue 757 * ends up not being used, the temp will get copy-propagated out. 758 */ 759 ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp", 760 ir_var_temporary); 761 ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var); 762 instructions->push_tail(var); 763 instructions->push_tail(new(ctx) ir_assignment(deref_var, rhs)); 764 deref_var = new(ctx) ir_dereference_variable(var); 765 766 if (!error_emitted) 767 instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var)); 768 769 return new(ctx) ir_dereference_variable(var); 770} 771 772static ir_rvalue * 773get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue) 774{ 775 void *ctx = ralloc_parent(lvalue); 776 ir_variable *var; 777 778 var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp", 779 ir_var_temporary); 780 instructions->push_tail(var); 781 var->mode = ir_var_auto; 782 783 instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var), 784 lvalue)); 785 786 return new(ctx) ir_dereference_variable(var); 787} 788 789 790ir_rvalue * 791ast_node::hir(exec_list *instructions, 792 struct _mesa_glsl_parse_state *state) 793{ 794 (void) instructions; 795 (void) state; 796 797 return NULL; 798} 799 800static ir_rvalue * 801do_comparison(void *mem_ctx, int operation, ir_rvalue *op0, ir_rvalue *op1) 802{ 803 int join_op; 804 ir_rvalue *cmp = NULL; 805 806 if (operation == ir_binop_all_equal) 807 join_op = ir_binop_logic_and; 808 else 809 join_op = ir_binop_logic_or; 810 811 switch (op0->type->base_type) { 812 case GLSL_TYPE_FLOAT: 813 case GLSL_TYPE_UINT: 814 case GLSL_TYPE_INT: 815 case GLSL_TYPE_BOOL: 816 return new(mem_ctx) ir_expression(operation, op0, op1); 817 818 case GLSL_TYPE_ARRAY: { 819 for (unsigned int i = 0; i < op0->type->length; i++) { 820 ir_rvalue *e0, *e1, *result; 821 822 e0 = new(mem_ctx) ir_dereference_array(op0->clone(mem_ctx, NULL), 823 new(mem_ctx) ir_constant(i)); 824 e1 = new(mem_ctx) ir_dereference_array(op1->clone(mem_ctx, NULL), 825 new(mem_ctx) ir_constant(i)); 826 result = do_comparison(mem_ctx, operation, e0, e1); 827 828 if (cmp) { 829 cmp = new(mem_ctx) ir_expression(join_op, cmp, result); 830 } else { 831 cmp = result; 832 } 833 } 834 835 mark_whole_array_access(op0); 836 mark_whole_array_access(op1); 837 break; 838 } 839 840 case GLSL_TYPE_STRUCT: { 841 for (unsigned int i = 0; i < op0->type->length; i++) { 842 ir_rvalue *e0, *e1, *result; 843 const char *field_name = op0->type->fields.structure[i].name; 844 845 e0 = new(mem_ctx) ir_dereference_record(op0->clone(mem_ctx, NULL), 846 field_name); 847 e1 = new(mem_ctx) ir_dereference_record(op1->clone(mem_ctx, NULL), 848 field_name); 849 result = do_comparison(mem_ctx, operation, e0, e1); 850 851 if (cmp) { 852 cmp = new(mem_ctx) ir_expression(join_op, cmp, result); 853 } else { 854 cmp = result; 855 } 856 } 857 break; 858 } 859 860 case GLSL_TYPE_ERROR: 861 case GLSL_TYPE_VOID: 862 case GLSL_TYPE_SAMPLER: 863 /* I assume a comparison of a struct containing a sampler just 864 * ignores the sampler present in the type. 865 */ 866 break; 867 868 default: 869 assert(!"Should not get here."); 870 break; 871 } 872 873 if (cmp == NULL) 874 cmp = new(mem_ctx) ir_constant(true); 875 876 return cmp; 877} 878 879/* For logical operations, we want to ensure that the operands are 880 * scalar booleans. If it isn't, emit an error and return a constant 881 * boolean to avoid triggering cascading error messages. 882 */ 883ir_rvalue * 884get_scalar_boolean_operand(exec_list *instructions, 885 struct _mesa_glsl_parse_state *state, 886 ast_expression *parent_expr, 887 int operand, 888 const char *operand_name, 889 bool *error_emitted) 890{ 891 ast_expression *expr = parent_expr->subexpressions[operand]; 892 void *ctx = state; 893 ir_rvalue *val = expr->hir(instructions, state); 894 895 if (val->type->is_boolean() && val->type->is_scalar()) 896 return val; 897 898 if (!*error_emitted) { 899 YYLTYPE loc = expr->get_location(); 900 _mesa_glsl_error(&loc, state, "%s of `%s' must be scalar boolean", 901 operand_name, 902 parent_expr->operator_string(parent_expr->oper)); 903 *error_emitted = true; 904 } 905 906 return new(ctx) ir_constant(true); 907} 908 909/** 910 * If name refers to a builtin array whose maximum allowed size is less than 911 * size, report an error and return true. Otherwise return false. 912 */ 913static bool 914check_builtin_array_max_size(const char *name, unsigned size, 915 YYLTYPE loc, struct _mesa_glsl_parse_state *state) 916{ 917 if ((strcmp("gl_TexCoord", name) == 0) 918 && (size > state->Const.MaxTextureCoords)) { 919 /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec: 920 * 921 * "The size [of gl_TexCoord] can be at most 922 * gl_MaxTextureCoords." 923 */ 924 _mesa_glsl_error(&loc, state, "`gl_TexCoord' array size cannot " 925 "be larger than gl_MaxTextureCoords (%u)\n", 926 state->Const.MaxTextureCoords); 927 return true; 928 } else if (strcmp("gl_ClipDistance", name) == 0 929 && size > state->Const.MaxClipPlanes) { 930 /* From section 7.1 (Vertex Shader Special Variables) of the 931 * GLSL 1.30 spec: 932 * 933 * "The gl_ClipDistance array is predeclared as unsized and 934 * must be sized by the shader either redeclaring it with a 935 * size or indexing it only with integral constant 936 * expressions. ... The size can be at most 937 * gl_MaxClipDistances." 938 */ 939 _mesa_glsl_error(&loc, state, "`gl_ClipDistance' array size cannot " 940 "be larger than gl_MaxClipDistances (%u)\n", 941 state->Const.MaxClipPlanes); 942 return true; 943 } 944 return false; 945} 946 947/** 948 * Create the constant 1, of a which is appropriate for incrementing and 949 * decrementing values of the given GLSL type. For example, if type is vec4, 950 * this creates a constant value of 1.0 having type float. 951 * 952 * If the given type is invalid for increment and decrement operators, return 953 * a floating point 1--the error will be detected later. 954 */ 955static ir_rvalue * 956constant_one_for_inc_dec(void *ctx, const glsl_type *type) 957{ 958 switch (type->base_type) { 959 case GLSL_TYPE_UINT: 960 return new(ctx) ir_constant((unsigned) 1); 961 case GLSL_TYPE_INT: 962 return new(ctx) ir_constant(1); 963 default: 964 case GLSL_TYPE_FLOAT: 965 return new(ctx) ir_constant(1.0f); 966 } 967} 968 969ir_rvalue * 970ast_expression::hir(exec_list *instructions, 971 struct _mesa_glsl_parse_state *state) 972{ 973 void *ctx = state; 974 static const int operations[AST_NUM_OPERATORS] = { 975 -1, /* ast_assign doesn't convert to ir_expression. */ 976 -1, /* ast_plus doesn't convert to ir_expression. */ 977 ir_unop_neg, 978 ir_binop_add, 979 ir_binop_sub, 980 ir_binop_mul, 981 ir_binop_div, 982 ir_binop_mod, 983 ir_binop_lshift, 984 ir_binop_rshift, 985 ir_binop_less, 986 ir_binop_greater, 987 ir_binop_lequal, 988 ir_binop_gequal, 989 ir_binop_all_equal, 990 ir_binop_any_nequal, 991 ir_binop_bit_and, 992 ir_binop_bit_xor, 993 ir_binop_bit_or, 994 ir_unop_bit_not, 995 ir_binop_logic_and, 996 ir_binop_logic_xor, 997 ir_binop_logic_or, 998 ir_unop_logic_not, 999 1000 /* Note: The following block of expression types actually convert 1001 * to multiple IR instructions. 1002 */ 1003 ir_binop_mul, /* ast_mul_assign */ 1004 ir_binop_div, /* ast_div_assign */ 1005 ir_binop_mod, /* ast_mod_assign */ 1006 ir_binop_add, /* ast_add_assign */ 1007 ir_binop_sub, /* ast_sub_assign */ 1008 ir_binop_lshift, /* ast_ls_assign */ 1009 ir_binop_rshift, /* ast_rs_assign */ 1010 ir_binop_bit_and, /* ast_and_assign */ 1011 ir_binop_bit_xor, /* ast_xor_assign */ 1012 ir_binop_bit_or, /* ast_or_assign */ 1013 1014 -1, /* ast_conditional doesn't convert to ir_expression. */ 1015 ir_binop_add, /* ast_pre_inc. */ 1016 ir_binop_sub, /* ast_pre_dec. */ 1017 ir_binop_add, /* ast_post_inc. */ 1018 ir_binop_sub, /* ast_post_dec. */ 1019 -1, /* ast_field_selection doesn't conv to ir_expression. */ 1020 -1, /* ast_array_index doesn't convert to ir_expression. */ 1021 -1, /* ast_function_call doesn't conv to ir_expression. */ 1022 -1, /* ast_identifier doesn't convert to ir_expression. */ 1023 -1, /* ast_int_constant doesn't convert to ir_expression. */ 1024 -1, /* ast_uint_constant doesn't conv to ir_expression. */ 1025 -1, /* ast_float_constant doesn't conv to ir_expression. */ 1026 -1, /* ast_bool_constant doesn't conv to ir_expression. */ 1027 -1, /* ast_sequence doesn't convert to ir_expression. */ 1028 }; 1029 ir_rvalue *result = NULL; 1030 ir_rvalue *op[3]; 1031 const struct glsl_type *type; /* a temporary variable for switch cases */ 1032 bool error_emitted = false; 1033 YYLTYPE loc; 1034 1035 loc = this->get_location(); 1036 1037 switch (this->oper) { 1038 case ast_assign: { 1039 op[0] = this->subexpressions[0]->hir(instructions, state); 1040 op[1] = this->subexpressions[1]->hir(instructions, state); 1041 1042 result = do_assignment(instructions, state, 1043 this->subexpressions[0]->non_lvalue_description, 1044 op[0], op[1], false, 1045 this->subexpressions[0]->get_location()); 1046 error_emitted = result->type->is_error(); 1047 break; 1048 } 1049 1050 case ast_plus: 1051 op[0] = this->subexpressions[0]->hir(instructions, state); 1052 1053 type = unary_arithmetic_result_type(op[0]->type, state, & loc); 1054 1055 error_emitted = type->is_error(); 1056 1057 result = op[0]; 1058 break; 1059 1060 case ast_neg: 1061 op[0] = this->subexpressions[0]->hir(instructions, state); 1062 1063 type = unary_arithmetic_result_type(op[0]->type, state, & loc); 1064 1065 error_emitted = type->is_error(); 1066 1067 result = new(ctx) ir_expression(operations[this->oper], type, 1068 op[0], NULL); 1069 break; 1070 1071 case ast_add: 1072 case ast_sub: 1073 case ast_mul: 1074 case ast_div: 1075 op[0] = this->subexpressions[0]->hir(instructions, state); 1076 op[1] = this->subexpressions[1]->hir(instructions, state); 1077 1078 type = arithmetic_result_type(op[0], op[1], 1079 (this->oper == ast_mul), 1080 state, & loc); 1081 error_emitted = type->is_error(); 1082 1083 result = new(ctx) ir_expression(operations[this->oper], type, 1084 op[0], op[1]); 1085 break; 1086 1087 case ast_mod: 1088 op[0] = this->subexpressions[0]->hir(instructions, state); 1089 op[1] = this->subexpressions[1]->hir(instructions, state); 1090 1091 type = modulus_result_type(op[0]->type, op[1]->type, state, & loc); 1092 1093 assert(operations[this->oper] == ir_binop_mod); 1094 1095 result = new(ctx) ir_expression(operations[this->oper], type, 1096 op[0], op[1]); 1097 error_emitted = type->is_error(); 1098 break; 1099 1100 case ast_lshift: 1101 case ast_rshift: 1102 if (state->language_version < 130) { 1103 _mesa_glsl_error(&loc, state, "operator %s requires GLSL 1.30", 1104 operator_string(this->oper)); 1105 error_emitted = true; 1106 } 1107 1108 op[0] = this->subexpressions[0]->hir(instructions, state); 1109 op[1] = this->subexpressions[1]->hir(instructions, state); 1110 type = shift_result_type(op[0]->type, op[1]->type, this->oper, state, 1111 &loc); 1112 result = new(ctx) ir_expression(operations[this->oper], type, 1113 op[0], op[1]); 1114 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1115 break; 1116 1117 case ast_less: 1118 case ast_greater: 1119 case ast_lequal: 1120 case ast_gequal: 1121 op[0] = this->subexpressions[0]->hir(instructions, state); 1122 op[1] = this->subexpressions[1]->hir(instructions, state); 1123 1124 type = relational_result_type(op[0], op[1], state, & loc); 1125 1126 /* The relational operators must either generate an error or result 1127 * in a scalar boolean. See page 57 of the GLSL 1.50 spec. 1128 */ 1129 assert(type->is_error() 1130 || ((type->base_type == GLSL_TYPE_BOOL) 1131 && type->is_scalar())); 1132 1133 result = new(ctx) ir_expression(operations[this->oper], type, 1134 op[0], op[1]); 1135 error_emitted = type->is_error(); 1136 break; 1137 1138 case ast_nequal: 1139 case ast_equal: 1140 op[0] = this->subexpressions[0]->hir(instructions, state); 1141 op[1] = this->subexpressions[1]->hir(instructions, state); 1142 1143 /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec: 1144 * 1145 * "The equality operators equal (==), and not equal (!=) 1146 * operate on all types. They result in a scalar Boolean. If 1147 * the operand types do not match, then there must be a 1148 * conversion from Section 4.1.10 "Implicit Conversions" 1149 * applied to one operand that can make them match, in which 1150 * case this conversion is done." 1151 */ 1152 if ((!apply_implicit_conversion(op[0]->type, op[1], state) 1153 && !apply_implicit_conversion(op[1]->type, op[0], state)) 1154 || (op[0]->type != op[1]->type)) { 1155 _mesa_glsl_error(& loc, state, "operands of `%s' must have the same " 1156 "type", (this->oper == ast_equal) ? "==" : "!="); 1157 error_emitted = true; 1158 } else if ((state->language_version <= 110) 1159 && (op[0]->type->is_array() || op[1]->type->is_array())) { 1160 _mesa_glsl_error(& loc, state, "array comparisons forbidden in " 1161 "GLSL 1.10"); 1162 error_emitted = true; 1163 } 1164 1165 if (error_emitted) { 1166 result = new(ctx) ir_constant(false); 1167 } else { 1168 result = do_comparison(ctx, operations[this->oper], op[0], op[1]); 1169 assert(result->type == glsl_type::bool_type); 1170 } 1171 break; 1172 1173 case ast_bit_and: 1174 case ast_bit_xor: 1175 case ast_bit_or: 1176 op[0] = this->subexpressions[0]->hir(instructions, state); 1177 op[1] = this->subexpressions[1]->hir(instructions, state); 1178 type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper, 1179 state, &loc); 1180 result = new(ctx) ir_expression(operations[this->oper], type, 1181 op[0], op[1]); 1182 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1183 break; 1184 1185 case ast_bit_not: 1186 op[0] = this->subexpressions[0]->hir(instructions, state); 1187 1188 if (state->language_version < 130) { 1189 _mesa_glsl_error(&loc, state, "bit-wise operations require GLSL 1.30"); 1190 error_emitted = true; 1191 } 1192 1193 if (!op[0]->type->is_integer()) { 1194 _mesa_glsl_error(&loc, state, "operand of `~' must be an integer"); 1195 error_emitted = true; 1196 } 1197 1198 type = error_emitted ? glsl_type::error_type : op[0]->type; 1199 result = new(ctx) ir_expression(ir_unop_bit_not, type, op[0], NULL); 1200 break; 1201 1202 case ast_logic_and: { 1203 exec_list rhs_instructions; 1204 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, 1205 "LHS", &error_emitted); 1206 op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1, 1207 "RHS", &error_emitted); 1208 1209 if (rhs_instructions.is_empty()) { 1210 result = new(ctx) ir_expression(ir_binop_logic_and, op[0], op[1]); 1211 type = result->type; 1212 } else { 1213 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type, 1214 "and_tmp", 1215 ir_var_temporary); 1216 instructions->push_tail(tmp); 1217 1218 ir_if *const stmt = new(ctx) ir_if(op[0]); 1219 instructions->push_tail(stmt); 1220 1221 stmt->then_instructions.append_list(&rhs_instructions); 1222 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp); 1223 ir_assignment *const then_assign = 1224 new(ctx) ir_assignment(then_deref, op[1]); 1225 stmt->then_instructions.push_tail(then_assign); 1226 1227 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp); 1228 ir_assignment *const else_assign = 1229 new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false)); 1230 stmt->else_instructions.push_tail(else_assign); 1231 1232 result = new(ctx) ir_dereference_variable(tmp); 1233 type = tmp->type; 1234 } 1235 break; 1236 } 1237 1238 case ast_logic_or: { 1239 exec_list rhs_instructions; 1240 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, 1241 "LHS", &error_emitted); 1242 op[1] = get_scalar_boolean_operand(&rhs_instructions, state, this, 1, 1243 "RHS", &error_emitted); 1244 1245 if (rhs_instructions.is_empty()) { 1246 result = new(ctx) ir_expression(ir_binop_logic_or, op[0], op[1]); 1247 type = result->type; 1248 } else { 1249 ir_variable *const tmp = new(ctx) ir_variable(glsl_type::bool_type, 1250 "or_tmp", 1251 ir_var_temporary); 1252 instructions->push_tail(tmp); 1253 1254 ir_if *const stmt = new(ctx) ir_if(op[0]); 1255 instructions->push_tail(stmt); 1256 1257 ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp); 1258 ir_assignment *const then_assign = 1259 new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true)); 1260 stmt->then_instructions.push_tail(then_assign); 1261 1262 stmt->else_instructions.append_list(&rhs_instructions); 1263 ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp); 1264 ir_assignment *const else_assign = 1265 new(ctx) ir_assignment(else_deref, op[1]); 1266 stmt->else_instructions.push_tail(else_assign); 1267 1268 result = new(ctx) ir_dereference_variable(tmp); 1269 type = tmp->type; 1270 } 1271 break; 1272 } 1273 1274 case ast_logic_xor: 1275 /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec: 1276 * 1277 * "The logical binary operators and (&&), or ( | | ), and 1278 * exclusive or (^^). They operate only on two Boolean 1279 * expressions and result in a Boolean expression." 1280 */ 1281 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS", 1282 &error_emitted); 1283 op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS", 1284 &error_emitted); 1285 1286 result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type, 1287 op[0], op[1]); 1288 break; 1289 1290 case ast_logic_not: 1291 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, 1292 "operand", &error_emitted); 1293 1294 result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type, 1295 op[0], NULL); 1296 break; 1297 1298 case ast_mul_assign: 1299 case ast_div_assign: 1300 case ast_add_assign: 1301 case ast_sub_assign: { 1302 op[0] = this->subexpressions[0]->hir(instructions, state); 1303 op[1] = this->subexpressions[1]->hir(instructions, state); 1304 1305 type = arithmetic_result_type(op[0], op[1], 1306 (this->oper == ast_mul_assign), 1307 state, & loc); 1308 1309 ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type, 1310 op[0], op[1]); 1311 1312 result = do_assignment(instructions, state, 1313 this->subexpressions[0]->non_lvalue_description, 1314 op[0]->clone(ctx, NULL), temp_rhs, false, 1315 this->subexpressions[0]->get_location()); 1316 error_emitted = (op[0]->type->is_error()); 1317 1318 /* GLSL 1.10 does not allow array assignment. However, we don't have to 1319 * explicitly test for this because none of the binary expression 1320 * operators allow array operands either. 1321 */ 1322 1323 break; 1324 } 1325 1326 case ast_mod_assign: { 1327 op[0] = this->subexpressions[0]->hir(instructions, state); 1328 op[1] = this->subexpressions[1]->hir(instructions, state); 1329 1330 type = modulus_result_type(op[0]->type, op[1]->type, state, & loc); 1331 1332 assert(operations[this->oper] == ir_binop_mod); 1333 1334 ir_rvalue *temp_rhs; 1335 temp_rhs = new(ctx) ir_expression(operations[this->oper], type, 1336 op[0], op[1]); 1337 1338 result = do_assignment(instructions, state, 1339 this->subexpressions[0]->non_lvalue_description, 1340 op[0]->clone(ctx, NULL), temp_rhs, false, 1341 this->subexpressions[0]->get_location()); 1342 error_emitted = type->is_error(); 1343 break; 1344 } 1345 1346 case ast_ls_assign: 1347 case ast_rs_assign: { 1348 op[0] = this->subexpressions[0]->hir(instructions, state); 1349 op[1] = this->subexpressions[1]->hir(instructions, state); 1350 type = shift_result_type(op[0]->type, op[1]->type, this->oper, state, 1351 &loc); 1352 ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], 1353 type, op[0], op[1]); 1354 result = do_assignment(instructions, state, 1355 this->subexpressions[0]->non_lvalue_description, 1356 op[0]->clone(ctx, NULL), temp_rhs, false, 1357 this->subexpressions[0]->get_location()); 1358 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1359 break; 1360 } 1361 1362 case ast_and_assign: 1363 case ast_xor_assign: 1364 case ast_or_assign: { 1365 op[0] = this->subexpressions[0]->hir(instructions, state); 1366 op[1] = this->subexpressions[1]->hir(instructions, state); 1367 type = bit_logic_result_type(op[0]->type, op[1]->type, this->oper, 1368 state, &loc); 1369 ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], 1370 type, op[0], op[1]); 1371 result = do_assignment(instructions, state, 1372 this->subexpressions[0]->non_lvalue_description, 1373 op[0]->clone(ctx, NULL), temp_rhs, false, 1374 this->subexpressions[0]->get_location()); 1375 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1376 break; 1377 } 1378 1379 case ast_conditional: { 1380 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec: 1381 * 1382 * "The ternary selection operator (?:). It operates on three 1383 * expressions (exp1 ? exp2 : exp3). This operator evaluates the 1384 * first expression, which must result in a scalar Boolean." 1385 */ 1386 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, 1387 "condition", &error_emitted); 1388 1389 /* The :? operator is implemented by generating an anonymous temporary 1390 * followed by an if-statement. The last instruction in each branch of 1391 * the if-statement assigns a value to the anonymous temporary. This 1392 * temporary is the r-value of the expression. 1393 */ 1394 exec_list then_instructions; 1395 exec_list else_instructions; 1396 1397 op[1] = this->subexpressions[1]->hir(&then_instructions, state); 1398 op[2] = this->subexpressions[2]->hir(&else_instructions, state); 1399 1400 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec: 1401 * 1402 * "The second and third expressions can be any type, as 1403 * long their types match, or there is a conversion in 1404 * Section 4.1.10 "Implicit Conversions" that can be applied 1405 * to one of the expressions to make their types match. This 1406 * resulting matching type is the type of the entire 1407 * expression." 1408 */ 1409 if ((!apply_implicit_conversion(op[1]->type, op[2], state) 1410 && !apply_implicit_conversion(op[2]->type, op[1], state)) 1411 || (op[1]->type != op[2]->type)) { 1412 YYLTYPE loc = this->subexpressions[1]->get_location(); 1413 1414 _mesa_glsl_error(& loc, state, "Second and third operands of ?: " 1415 "operator must have matching types."); 1416 error_emitted = true; 1417 type = glsl_type::error_type; 1418 } else { 1419 type = op[1]->type; 1420 } 1421 1422 /* From page 33 (page 39 of the PDF) of the GLSL 1.10 spec: 1423 * 1424 * "The second and third expressions must be the same type, but can 1425 * be of any type other than an array." 1426 */ 1427 if ((state->language_version <= 110) && type->is_array()) { 1428 _mesa_glsl_error(& loc, state, "Second and third operands of ?: " 1429 "operator must not be arrays."); 1430 error_emitted = true; 1431 } 1432 1433 ir_constant *cond_val = op[0]->constant_expression_value(); 1434 ir_constant *then_val = op[1]->constant_expression_value(); 1435 ir_constant *else_val = op[2]->constant_expression_value(); 1436 1437 if (then_instructions.is_empty() 1438 && else_instructions.is_empty() 1439 && (cond_val != NULL) && (then_val != NULL) && (else_val != NULL)) { 1440 result = (cond_val->value.b[0]) ? then_val : else_val; 1441 } else { 1442 ir_variable *const tmp = 1443 new(ctx) ir_variable(type, "conditional_tmp", ir_var_temporary); 1444 instructions->push_tail(tmp); 1445 1446 ir_if *const stmt = new(ctx) ir_if(op[0]); 1447 instructions->push_tail(stmt); 1448 1449 then_instructions.move_nodes_to(& stmt->then_instructions); 1450 ir_dereference *const then_deref = 1451 new(ctx) ir_dereference_variable(tmp); 1452 ir_assignment *const then_assign = 1453 new(ctx) ir_assignment(then_deref, op[1]); 1454 stmt->then_instructions.push_tail(then_assign); 1455 1456 else_instructions.move_nodes_to(& stmt->else_instructions); 1457 ir_dereference *const else_deref = 1458 new(ctx) ir_dereference_variable(tmp); 1459 ir_assignment *const else_assign = 1460 new(ctx) ir_assignment(else_deref, op[2]); 1461 stmt->else_instructions.push_tail(else_assign); 1462 1463 result = new(ctx) ir_dereference_variable(tmp); 1464 } 1465 break; 1466 } 1467 1468 case ast_pre_inc: 1469 case ast_pre_dec: { 1470 this->non_lvalue_description = (this->oper == ast_pre_inc) 1471 ? "pre-increment operation" : "pre-decrement operation"; 1472 1473 op[0] = this->subexpressions[0]->hir(instructions, state); 1474 op[1] = constant_one_for_inc_dec(ctx, op[0]->type); 1475 1476 type = arithmetic_result_type(op[0], op[1], false, state, & loc); 1477 1478 ir_rvalue *temp_rhs; 1479 temp_rhs = new(ctx) ir_expression(operations[this->oper], type, 1480 op[0], op[1]); 1481 1482 result = do_assignment(instructions, state, 1483 this->subexpressions[0]->non_lvalue_description, 1484 op[0]->clone(ctx, NULL), temp_rhs, false, 1485 this->subexpressions[0]->get_location()); 1486 error_emitted = op[0]->type->is_error(); 1487 break; 1488 } 1489 1490 case ast_post_inc: 1491 case ast_post_dec: { 1492 this->non_lvalue_description = (this->oper == ast_post_inc) 1493 ? "post-increment operation" : "post-decrement operation"; 1494 op[0] = this->subexpressions[0]->hir(instructions, state); 1495 op[1] = constant_one_for_inc_dec(ctx, op[0]->type); 1496 1497 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1498 1499 type = arithmetic_result_type(op[0], op[1], false, state, & loc); 1500 1501 ir_rvalue *temp_rhs; 1502 temp_rhs = new(ctx) ir_expression(operations[this->oper], type, 1503 op[0], op[1]); 1504 1505 /* Get a temporary of a copy of the lvalue before it's modified. 1506 * This may get thrown away later. 1507 */ 1508 result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL)); 1509 1510 (void)do_assignment(instructions, state, 1511 this->subexpressions[0]->non_lvalue_description, 1512 op[0]->clone(ctx, NULL), temp_rhs, false, 1513 this->subexpressions[0]->get_location()); 1514 1515 error_emitted = op[0]->type->is_error(); 1516 break; 1517 } 1518 1519 case ast_field_selection: 1520 result = _mesa_ast_field_selection_to_hir(this, instructions, state); 1521 break; 1522 1523 case ast_array_index: { 1524 YYLTYPE index_loc = subexpressions[1]->get_location(); 1525 1526 op[0] = subexpressions[0]->hir(instructions, state); 1527 op[1] = subexpressions[1]->hir(instructions, state); 1528 1529 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 1530 1531 ir_rvalue *const array = op[0]; 1532 1533 result = new(ctx) ir_dereference_array(op[0], op[1]); 1534 1535 /* Do not use op[0] after this point. Use array. 1536 */ 1537 op[0] = NULL; 1538 1539 1540 if (error_emitted) 1541 break; 1542 1543 if (!array->type->is_array() 1544 && !array->type->is_matrix() 1545 && !array->type->is_vector()) { 1546 _mesa_glsl_error(& index_loc, state, 1547 "cannot dereference non-array / non-matrix / " 1548 "non-vector"); 1549 error_emitted = true; 1550 } 1551 1552 if (!op[1]->type->is_integer()) { 1553 _mesa_glsl_error(& index_loc, state, 1554 "array index must be integer type"); 1555 error_emitted = true; 1556 } else if (!op[1]->type->is_scalar()) { 1557 _mesa_glsl_error(& index_loc, state, 1558 "array index must be scalar"); 1559 error_emitted = true; 1560 } 1561 1562 /* If the array index is a constant expression and the array has a 1563 * declared size, ensure that the access is in-bounds. If the array 1564 * index is not a constant expression, ensure that the array has a 1565 * declared size. 1566 */ 1567 ir_constant *const const_index = op[1]->constant_expression_value(); 1568 if (const_index != NULL) { 1569 const int idx = const_index->value.i[0]; 1570 const char *type_name; 1571 unsigned bound = 0; 1572 1573 if (array->type->is_matrix()) { 1574 type_name = "matrix"; 1575 } else if (array->type->is_vector()) { 1576 type_name = "vector"; 1577 } else { 1578 type_name = "array"; 1579 } 1580 1581 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec: 1582 * 1583 * "It is illegal to declare an array with a size, and then 1584 * later (in the same shader) index the same array with an 1585 * integral constant expression greater than or equal to the 1586 * declared size. It is also illegal to index an array with a 1587 * negative constant expression." 1588 */ 1589 if (array->type->is_matrix()) { 1590 if (array->type->row_type()->vector_elements <= idx) { 1591 bound = array->type->row_type()->vector_elements; 1592 } 1593 } else if (array->type->is_vector()) { 1594 if (array->type->vector_elements <= idx) { 1595 bound = array->type->vector_elements; 1596 } 1597 } else { 1598 if ((array->type->array_size() > 0) 1599 && (array->type->array_size() <= idx)) { 1600 bound = array->type->array_size(); 1601 } 1602 } 1603 1604 if (bound > 0) { 1605 _mesa_glsl_error(& loc, state, "%s index must be < %u", 1606 type_name, bound); 1607 error_emitted = true; 1608 } else if (idx < 0) { 1609 _mesa_glsl_error(& loc, state, "%s index must be >= 0", 1610 type_name); 1611 error_emitted = true; 1612 } 1613 1614 if (array->type->is_array()) { 1615 /* If the array is a variable dereference, it dereferences the 1616 * whole array, by definition. Use this to get the variable. 1617 * 1618 * FINISHME: Should some methods for getting / setting / testing 1619 * FINISHME: array access limits be added to ir_dereference? 1620 */ 1621 ir_variable *const v = array->whole_variable_referenced(); 1622 if ((v != NULL) && (unsigned(idx) > v->max_array_access)) { 1623 v->max_array_access = idx; 1624 1625 /* Check whether this access will, as a side effect, implicitly 1626 * cause the size of a built-in array to be too large. 1627 */ 1628 if (check_builtin_array_max_size(v->name, idx+1, loc, state)) 1629 error_emitted = true; 1630 } 1631 } 1632 } else if (array->type->array_size() == 0) { 1633 _mesa_glsl_error(&loc, state, "unsized array index must be constant"); 1634 } else { 1635 if (array->type->is_array()) { 1636 /* whole_variable_referenced can return NULL if the array is a 1637 * member of a structure. In this case it is safe to not update 1638 * the max_array_access field because it is never used for fields 1639 * of structures. 1640 */ 1641 ir_variable *v = array->whole_variable_referenced(); 1642 if (v != NULL) 1643 v->max_array_access = array->type->array_size() - 1; 1644 } 1645 } 1646 1647 /* From page 23 (29 of the PDF) of the GLSL 1.30 spec: 1648 * 1649 * "Samplers aggregated into arrays within a shader (using square 1650 * brackets [ ]) can only be indexed with integral constant 1651 * expressions [...]." 1652 * 1653 * This restriction was added in GLSL 1.30. Shaders using earlier version 1654 * of the language should not be rejected by the compiler front-end for 1655 * using this construct. This allows useful things such as using a loop 1656 * counter as the index to an array of samplers. If the loop in unrolled, 1657 * the code should compile correctly. Instead, emit a warning. 1658 */ 1659 if (array->type->is_array() && 1660 array->type->element_type()->is_sampler() && 1661 const_index == NULL) { 1662 1663 if (state->language_version == 100) { 1664 _mesa_glsl_warning(&loc, state, 1665 "sampler arrays indexed with non-constant " 1666 "expressions is optional in GLSL ES 1.00"); 1667 } else if (state->language_version < 130) { 1668 _mesa_glsl_warning(&loc, state, 1669 "sampler arrays indexed with non-constant " 1670 "expressions is forbidden in GLSL 1.30 and " 1671 "later"); 1672 } else { 1673 _mesa_glsl_error(&loc, state, 1674 "sampler arrays indexed with non-constant " 1675 "expressions is forbidden in GLSL 1.30 and " 1676 "later"); 1677 error_emitted = true; 1678 } 1679 } 1680 1681 if (error_emitted) 1682 result->type = glsl_type::error_type; 1683 1684 break; 1685 } 1686 1687 case ast_function_call: 1688 /* Should *NEVER* get here. ast_function_call should always be handled 1689 * by ast_function_expression::hir. 1690 */ 1691 assert(0); 1692 break; 1693 1694 case ast_identifier: { 1695 /* ast_identifier can appear several places in a full abstract syntax 1696 * tree. This particular use must be at location specified in the grammar 1697 * as 'variable_identifier'. 1698 */ 1699 ir_variable *var = 1700 state->symbols->get_variable(this->primary_expression.identifier); 1701 1702 if (var != NULL) { 1703 var->used = true; 1704 result = new(ctx) ir_dereference_variable(var); 1705 } else { 1706 _mesa_glsl_error(& loc, state, "`%s' undeclared", 1707 this->primary_expression.identifier); 1708 1709 result = ir_rvalue::error_value(ctx); 1710 error_emitted = true; 1711 } 1712 break; 1713 } 1714 1715 case ast_int_constant: 1716 result = new(ctx) ir_constant(this->primary_expression.int_constant); 1717 break; 1718 1719 case ast_uint_constant: 1720 result = new(ctx) ir_constant(this->primary_expression.uint_constant); 1721 break; 1722 1723 case ast_float_constant: 1724 result = new(ctx) ir_constant(this->primary_expression.float_constant); 1725 break; 1726 1727 case ast_bool_constant: 1728 result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant)); 1729 break; 1730 1731 case ast_sequence: { 1732 /* It should not be possible to generate a sequence in the AST without 1733 * any expressions in it. 1734 */ 1735 assert(!this->expressions.is_empty()); 1736 1737 /* The r-value of a sequence is the last expression in the sequence. If 1738 * the other expressions in the sequence do not have side-effects (and 1739 * therefore add instructions to the instruction list), they get dropped 1740 * on the floor. 1741 */ 1742 exec_node *previous_tail_pred = NULL; 1743 YYLTYPE previous_operand_loc = loc; 1744 1745 foreach_list_typed (ast_node, ast, link, &this->expressions) { 1746 /* If one of the operands of comma operator does not generate any 1747 * code, we want to emit a warning. At each pass through the loop 1748 * previous_tail_pred will point to the last instruction in the 1749 * stream *before* processing the previous operand. Naturally, 1750 * instructions->tail_pred will point to the last instruction in the 1751 * stream *after* processing the previous operand. If the two 1752 * pointers match, then the previous operand had no effect. 1753 * 1754 * The warning behavior here differs slightly from GCC. GCC will 1755 * only emit a warning if none of the left-hand operands have an 1756 * effect. However, it will emit a warning for each. I believe that 1757 * there are some cases in C (especially with GCC extensions) where 1758 * it is useful to have an intermediate step in a sequence have no 1759 * effect, but I don't think these cases exist in GLSL. Either way, 1760 * it would be a giant hassle to replicate that behavior. 1761 */ 1762 if (previous_tail_pred == instructions->tail_pred) { 1763 _mesa_glsl_warning(&previous_operand_loc, state, 1764 "left-hand operand of comma expression has " 1765 "no effect"); 1766 } 1767 1768 /* tail_pred is directly accessed instead of using the get_tail() 1769 * method for performance reasons. get_tail() has extra code to 1770 * return NULL when the list is empty. We don't care about that 1771 * here, so using tail_pred directly is fine. 1772 */ 1773 previous_tail_pred = instructions->tail_pred; 1774 previous_operand_loc = ast->get_location(); 1775 1776 result = ast->hir(instructions, state); 1777 } 1778 1779 /* Any errors should have already been emitted in the loop above. 1780 */ 1781 error_emitted = true; 1782 break; 1783 } 1784 } 1785 type = NULL; /* use result->type, not type. */ 1786 assert(result != NULL); 1787 1788 if (result->type->is_error() && !error_emitted) 1789 _mesa_glsl_error(& loc, state, "type mismatch"); 1790 1791 return result; 1792} 1793 1794 1795ir_rvalue * 1796ast_expression_statement::hir(exec_list *instructions, 1797 struct _mesa_glsl_parse_state *state) 1798{ 1799 /* It is possible to have expression statements that don't have an 1800 * expression. This is the solitary semicolon: 1801 * 1802 * for (i = 0; i < 5; i++) 1803 * ; 1804 * 1805 * In this case the expression will be NULL. Test for NULL and don't do 1806 * anything in that case. 1807 */ 1808 if (expression != NULL) 1809 expression->hir(instructions, state); 1810 1811 /* Statements do not have r-values. 1812 */ 1813 return NULL; 1814} 1815 1816 1817ir_rvalue * 1818ast_compound_statement::hir(exec_list *instructions, 1819 struct _mesa_glsl_parse_state *state) 1820{ 1821 if (new_scope) 1822 state->symbols->push_scope(); 1823 1824 foreach_list_typed (ast_node, ast, link, &this->statements) 1825 ast->hir(instructions, state); 1826 1827 if (new_scope) 1828 state->symbols->pop_scope(); 1829 1830 /* Compound statements do not have r-values. 1831 */ 1832 return NULL; 1833} 1834 1835 1836static const glsl_type * 1837process_array_type(YYLTYPE *loc, const glsl_type *base, ast_node *array_size, 1838 struct _mesa_glsl_parse_state *state) 1839{ 1840 unsigned length = 0; 1841 1842 /* From page 19 (page 25) of the GLSL 1.20 spec: 1843 * 1844 * "Only one-dimensional arrays may be declared." 1845 */ 1846 if (base->is_array()) { 1847 _mesa_glsl_error(loc, state, 1848 "invalid array of `%s' (only one-dimensional arrays " 1849 "may be declared)", 1850 base->name); 1851 return glsl_type::error_type; 1852 } 1853 1854 if (array_size != NULL) { 1855 exec_list dummy_instructions; 1856 ir_rvalue *const ir = array_size->hir(& dummy_instructions, state); 1857 YYLTYPE loc = array_size->get_location(); 1858 1859 if (ir != NULL) { 1860 if (!ir->type->is_integer()) { 1861 _mesa_glsl_error(& loc, state, "array size must be integer type"); 1862 } else if (!ir->type->is_scalar()) { 1863 _mesa_glsl_error(& loc, state, "array size must be scalar type"); 1864 } else { 1865 ir_constant *const size = ir->constant_expression_value(); 1866 1867 if (size == NULL) { 1868 _mesa_glsl_error(& loc, state, "array size must be a " 1869 "constant valued expression"); 1870 } else if (size->value.i[0] <= 0) { 1871 _mesa_glsl_error(& loc, state, "array size must be > 0"); 1872 } else { 1873 assert(size->type == ir->type); 1874 length = size->value.u[0]; 1875 1876 /* If the array size is const (and we've verified that 1877 * it is) then no instructions should have been emitted 1878 * when we converted it to HIR. If they were emitted, 1879 * then either the array size isn't const after all, or 1880 * we are emitting unnecessary instructions. 1881 */ 1882 assert(dummy_instructions.is_empty()); 1883 } 1884 } 1885 } 1886 } else if (state->es_shader) { 1887 /* Section 10.17 of the GLSL ES 1.00 specification states that unsized 1888 * array declarations have been removed from the language. 1889 */ 1890 _mesa_glsl_error(loc, state, "unsized array declarations are not " 1891 "allowed in GLSL ES 1.00."); 1892 } 1893 1894 return glsl_type::get_array_instance(base, length); 1895} 1896 1897 1898const glsl_type * 1899ast_type_specifier::glsl_type(const char **name, 1900 struct _mesa_glsl_parse_state *state) const 1901{ 1902 const struct glsl_type *type; 1903 1904 type = state->symbols->get_type(this->type_name); 1905 *name = this->type_name; 1906 1907 if (this->is_array) { 1908 YYLTYPE loc = this->get_location(); 1909 type = process_array_type(&loc, type, this->array_size, state); 1910 } 1911 1912 return type; 1913} 1914 1915 1916static void 1917apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, 1918 ir_variable *var, 1919 struct _mesa_glsl_parse_state *state, 1920 YYLTYPE *loc) 1921{ 1922 if (qual->flags.q.invariant) { 1923 if (var->used) { 1924 _mesa_glsl_error(loc, state, 1925 "variable `%s' may not be redeclared " 1926 "`invariant' after being used", 1927 var->name); 1928 } else { 1929 var->invariant = 1; 1930 } 1931 } 1932 1933 if (qual->flags.q.constant || qual->flags.q.attribute 1934 || qual->flags.q.uniform 1935 || (qual->flags.q.varying && (state->target == fragment_shader))) 1936 var->read_only = 1; 1937 1938 if (qual->flags.q.centroid) 1939 var->centroid = 1; 1940 1941 if (qual->flags.q.attribute && state->target != vertex_shader) { 1942 var->type = glsl_type::error_type; 1943 _mesa_glsl_error(loc, state, 1944 "`attribute' variables may not be declared in the " 1945 "%s shader", 1946 _mesa_glsl_shader_target_name(state->target)); 1947 } 1948 1949 /* From page 25 (page 31 of the PDF) of the GLSL 1.10 spec: 1950 * 1951 * "The varying qualifier can be used only with the data types 1952 * float, vec2, vec3, vec4, mat2, mat3, and mat4, or arrays of 1953 * these." 1954 */ 1955 if (qual->flags.q.varying) { 1956 const glsl_type *non_array_type; 1957 1958 if (var->type && var->type->is_array()) 1959 non_array_type = var->type->fields.array; 1960 else 1961 non_array_type = var->type; 1962 1963 if (non_array_type && non_array_type->base_type != GLSL_TYPE_FLOAT) { 1964 var->type = glsl_type::error_type; 1965 _mesa_glsl_error(loc, state, 1966 "varying variables must be of base type float"); 1967 } 1968 } 1969 1970 /* If there is no qualifier that changes the mode of the variable, leave 1971 * the setting alone. 1972 */ 1973 if (qual->flags.q.in && qual->flags.q.out) 1974 var->mode = ir_var_inout; 1975 else if (qual->flags.q.attribute || qual->flags.q.in 1976 || (qual->flags.q.varying && (state->target == fragment_shader))) 1977 var->mode = ir_var_in; 1978 else if (qual->flags.q.out 1979 || (qual->flags.q.varying && (state->target == vertex_shader))) 1980 var->mode = ir_var_out; 1981 else if (qual->flags.q.uniform) 1982 var->mode = ir_var_uniform; 1983 1984 if (state->all_invariant && (state->current_function == NULL)) { 1985 switch (state->target) { 1986 case vertex_shader: 1987 if (var->mode == ir_var_out) 1988 var->invariant = true; 1989 break; 1990 case geometry_shader: 1991 if ((var->mode == ir_var_in) || (var->mode == ir_var_out)) 1992 var->invariant = true; 1993 break; 1994 case fragment_shader: 1995 if (var->mode == ir_var_in) 1996 var->invariant = true; 1997 break; 1998 } 1999 } 2000 2001 if (qual->flags.q.flat) 2002 var->interpolation = INTERP_QUALIFIER_FLAT; 2003 else if (qual->flags.q.noperspective) 2004 var->interpolation = INTERP_QUALIFIER_NOPERSPECTIVE; 2005 else if (qual->flags.q.smooth) 2006 var->interpolation = INTERP_QUALIFIER_SMOOTH; 2007 else 2008 var->interpolation = INTERP_QUALIFIER_NONE; 2009 2010 if (var->interpolation != INTERP_QUALIFIER_NONE && 2011 !(state->target == vertex_shader && var->mode == ir_var_out) && 2012 !(state->target == fragment_shader && var->mode == ir_var_in)) { 2013 const char *qual_string = NULL; 2014 switch (var->interpolation) { 2015 case INTERP_QUALIFIER_FLAT: 2016 qual_string = "flat"; 2017 break; 2018 case INTERP_QUALIFIER_NOPERSPECTIVE: 2019 qual_string = "noperspective"; 2020 break; 2021 case INTERP_QUALIFIER_SMOOTH: 2022 qual_string = "smooth"; 2023 break; 2024 } 2025 2026 _mesa_glsl_error(loc, state, 2027 "interpolation qualifier `%s' can only be applied to " 2028 "vertex shader outputs and fragment shader inputs.", 2029 qual_string); 2030 2031 } 2032 2033 var->pixel_center_integer = qual->flags.q.pixel_center_integer; 2034 var->origin_upper_left = qual->flags.q.origin_upper_left; 2035 if ((qual->flags.q.origin_upper_left || qual->flags.q.pixel_center_integer) 2036 && (strcmp(var->name, "gl_FragCoord") != 0)) { 2037 const char *const qual_string = (qual->flags.q.origin_upper_left) 2038 ? "origin_upper_left" : "pixel_center_integer"; 2039 2040 _mesa_glsl_error(loc, state, 2041 "layout qualifier `%s' can only be applied to " 2042 "fragment shader input `gl_FragCoord'", 2043 qual_string); 2044 } 2045 2046 if (qual->flags.q.explicit_location) { 2047 const bool global_scope = (state->current_function == NULL); 2048 bool fail = false; 2049 const char *string = ""; 2050 2051 /* In the vertex shader only shader inputs can be given explicit 2052 * locations. 2053 * 2054 * In the fragment shader only shader outputs can be given explicit 2055 * locations. 2056 */ 2057 switch (state->target) { 2058 case vertex_shader: 2059 if (!global_scope || (var->mode != ir_var_in)) { 2060 fail = true; 2061 string = "input"; 2062 } 2063 break; 2064 2065 case geometry_shader: 2066 _mesa_glsl_error(loc, state, 2067 "geometry shader variables cannot be given " 2068 "explicit locations\n"); 2069 break; 2070 2071 case fragment_shader: 2072 if (!global_scope || (var->mode != ir_var_out)) { 2073 fail = true; 2074 string = "output"; 2075 } 2076 break; 2077 }; 2078 2079 if (fail) { 2080 _mesa_glsl_error(loc, state, 2081 "only %s shader %s variables can be given an " 2082 "explicit location\n", 2083 _mesa_glsl_shader_target_name(state->target), 2084 string); 2085 } else { 2086 var->explicit_location = true; 2087 2088 /* This bit of silliness is needed because invalid explicit locations 2089 * are supposed to be flagged during linking. Small negative values 2090 * biased by VERT_ATTRIB_GENERIC0 or FRAG_RESULT_DATA0 could alias 2091 * built-in values (e.g., -16+VERT_ATTRIB_GENERIC0 = VERT_ATTRIB_POS). 2092 * The linker needs to be able to differentiate these cases. This 2093 * ensures that negative values stay negative. 2094 */ 2095 if (qual->location >= 0) { 2096 var->location = (state->target == vertex_shader) 2097 ? (qual->location + VERT_ATTRIB_GENERIC0) 2098 : (qual->location + FRAG_RESULT_DATA0); 2099 } else { 2100 var->location = qual->location; 2101 } 2102 if (qual->flags.q.explicit_index) { 2103 var->explicit_index = true; 2104 var->index = qual->index; 2105 } 2106 } 2107 } else if (qual->flags.q.explicit_index) { 2108 _mesa_glsl_error(loc, state, 2109 "explicit index requires explicit location\n"); 2110 } 2111 2112 /* Does the declaration use the 'layout' keyword? 2113 */ 2114 const bool uses_layout = qual->flags.q.pixel_center_integer 2115 || qual->flags.q.origin_upper_left 2116 || qual->flags.q.explicit_location; /* no need for index since it relies on location */ 2117 2118 /* Does the declaration use the deprecated 'attribute' or 'varying' 2119 * keywords? 2120 */ 2121 const bool uses_deprecated_qualifier = qual->flags.q.attribute 2122 || qual->flags.q.varying; 2123 2124 /* Is the 'layout' keyword used with parameters that allow relaxed checking. 2125 * Many implementations of GL_ARB_fragment_coord_conventions_enable and some 2126 * implementations (only Mesa?) GL_ARB_explicit_attrib_location_enable 2127 * allowed the layout qualifier to be used with 'varying' and 'attribute'. 2128 * These extensions and all following extensions that add the 'layout' 2129 * keyword have been modified to require the use of 'in' or 'out'. 2130 * 2131 * The following extension do not allow the deprecated keywords: 2132 * 2133 * GL_AMD_conservative_depth 2134 * GL_ARB_conservative_depth 2135 * GL_ARB_gpu_shader5 2136 * GL_ARB_separate_shader_objects 2137 * GL_ARB_tesselation_shader 2138 * GL_ARB_transform_feedback3 2139 * GL_ARB_uniform_buffer_object 2140 * 2141 * It is unknown whether GL_EXT_shader_image_load_store or GL_NV_gpu_shader5 2142 * allow layout with the deprecated keywords. 2143 */ 2144 const bool relaxed_layout_qualifier_checking = 2145 state->ARB_fragment_coord_conventions_enable; 2146 2147 if (uses_layout && uses_deprecated_qualifier) { 2148 if (relaxed_layout_qualifier_checking) { 2149 _mesa_glsl_warning(loc, state, 2150 "`layout' qualifier may not be used with " 2151 "`attribute' or `varying'"); 2152 } else { 2153 _mesa_glsl_error(loc, state, 2154 "`layout' qualifier may not be used with " 2155 "`attribute' or `varying'"); 2156 } 2157 } 2158 2159 /* Layout qualifiers for gl_FragDepth, which are enabled by extension 2160 * AMD_conservative_depth. 2161 */ 2162 int depth_layout_count = qual->flags.q.depth_any 2163 + qual->flags.q.depth_greater 2164 + qual->flags.q.depth_less 2165 + qual->flags.q.depth_unchanged; 2166 if (depth_layout_count > 0 2167 && !state->AMD_conservative_depth_enable 2168 && !state->ARB_conservative_depth_enable) { 2169 _mesa_glsl_error(loc, state, 2170 "extension GL_AMD_conservative_depth or " 2171 "GL_ARB_conservative_depth must be enabled " 2172 "to use depth layout qualifiers"); 2173 } else if (depth_layout_count > 0 2174 && strcmp(var->name, "gl_FragDepth") != 0) { 2175 _mesa_glsl_error(loc, state, 2176 "depth layout qualifiers can be applied only to " 2177 "gl_FragDepth"); 2178 } else if (depth_layout_count > 1 2179 && strcmp(var->name, "gl_FragDepth") == 0) { 2180 _mesa_glsl_error(loc, state, 2181 "at most one depth layout qualifier can be applied to " 2182 "gl_FragDepth"); 2183 } 2184 if (qual->flags.q.depth_any) 2185 var->depth_layout = ir_depth_layout_any; 2186 else if (qual->flags.q.depth_greater) 2187 var->depth_layout = ir_depth_layout_greater; 2188 else if (qual->flags.q.depth_less) 2189 var->depth_layout = ir_depth_layout_less; 2190 else if (qual->flags.q.depth_unchanged) 2191 var->depth_layout = ir_depth_layout_unchanged; 2192 else 2193 var->depth_layout = ir_depth_layout_none; 2194} 2195 2196/** 2197 * Get the variable that is being redeclared by this declaration 2198 * 2199 * Semantic checks to verify the validity of the redeclaration are also 2200 * performed. If semantic checks fail, compilation error will be emitted via 2201 * \c _mesa_glsl_error, but a non-\c NULL pointer will still be returned. 2202 * 2203 * \returns 2204 * A pointer to an existing variable in the current scope if the declaration 2205 * is a redeclaration, \c NULL otherwise. 2206 */ 2207ir_variable * 2208get_variable_being_redeclared(ir_variable *var, ast_declaration *decl, 2209 struct _mesa_glsl_parse_state *state) 2210{ 2211 /* Check if this declaration is actually a re-declaration, either to 2212 * resize an array or add qualifiers to an existing variable. 2213 * 2214 * This is allowed for variables in the current scope, or when at 2215 * global scope (for built-ins in the implicit outer scope). 2216 */ 2217 ir_variable *earlier = state->symbols->get_variable(decl->identifier); 2218 if (earlier == NULL || 2219 (state->current_function != NULL && 2220 !state->symbols->name_declared_this_scope(decl->identifier))) { 2221 return NULL; 2222 } 2223 2224 2225 YYLTYPE loc = decl->get_location(); 2226 2227 /* From page 24 (page 30 of the PDF) of the GLSL 1.50 spec, 2228 * 2229 * "It is legal to declare an array without a size and then 2230 * later re-declare the same name as an array of the same 2231 * type and specify a size." 2232 */ 2233 if ((earlier->type->array_size() == 0) 2234 && var->type->is_array() 2235 && (var->type->element_type() == earlier->type->element_type())) { 2236 /* FINISHME: This doesn't match the qualifiers on the two 2237 * FINISHME: declarations. It's not 100% clear whether this is 2238 * FINISHME: required or not. 2239 */ 2240 2241 const unsigned size = unsigned(var->type->array_size()); 2242 check_builtin_array_max_size(var->name, size, loc, state); 2243 if ((size > 0) && (size <= earlier->max_array_access)) { 2244 _mesa_glsl_error(& loc, state, "array size must be > %u due to " 2245 "previous access", 2246 earlier->max_array_access); 2247 } 2248 2249 earlier->type = var->type; 2250 delete var; 2251 var = NULL; 2252 } else if (state->ARB_fragment_coord_conventions_enable 2253 && strcmp(var->name, "gl_FragCoord") == 0 2254 && earlier->type == var->type 2255 && earlier->mode == var->mode) { 2256 /* Allow redeclaration of gl_FragCoord for ARB_fcc layout 2257 * qualifiers. 2258 */ 2259 earlier->origin_upper_left = var->origin_upper_left; 2260 earlier->pixel_center_integer = var->pixel_center_integer; 2261 2262 /* According to section 4.3.7 of the GLSL 1.30 spec, 2263 * the following built-in varaibles can be redeclared with an 2264 * interpolation qualifier: 2265 * * gl_FrontColor 2266 * * gl_BackColor 2267 * * gl_FrontSecondaryColor 2268 * * gl_BackSecondaryColor 2269 * * gl_Color 2270 * * gl_SecondaryColor 2271 */ 2272 } else if (state->language_version >= 130 2273 && (strcmp(var->name, "gl_FrontColor") == 0 2274 || strcmp(var->name, "gl_BackColor") == 0 2275 || strcmp(var->name, "gl_FrontSecondaryColor") == 0 2276 || strcmp(var->name, "gl_BackSecondaryColor") == 0 2277 || strcmp(var->name, "gl_Color") == 0 2278 || strcmp(var->name, "gl_SecondaryColor") == 0) 2279 && earlier->type == var->type 2280 && earlier->mode == var->mode) { 2281 earlier->interpolation = var->interpolation; 2282 2283 /* Layout qualifiers for gl_FragDepth. */ 2284 } else if ((state->AMD_conservative_depth_enable || 2285 state->ARB_conservative_depth_enable) 2286 && strcmp(var->name, "gl_FragDepth") == 0 2287 && earlier->type == var->type 2288 && earlier->mode == var->mode) { 2289 2290 /** From the AMD_conservative_depth spec: 2291 * Within any shader, the first redeclarations of gl_FragDepth 2292 * must appear before any use of gl_FragDepth. 2293 */ 2294 if (earlier->used) { 2295 _mesa_glsl_error(&loc, state, 2296 "the first redeclaration of gl_FragDepth " 2297 "must appear before any use of gl_FragDepth"); 2298 } 2299 2300 /* Prevent inconsistent redeclaration of depth layout qualifier. */ 2301 if (earlier->depth_layout != ir_depth_layout_none 2302 && earlier->depth_layout != var->depth_layout) { 2303 _mesa_glsl_error(&loc, state, 2304 "gl_FragDepth: depth layout is declared here " 2305 "as '%s, but it was previously declared as " 2306 "'%s'", 2307 depth_layout_string(var->depth_layout), 2308 depth_layout_string(earlier->depth_layout)); 2309 } 2310 2311 earlier->depth_layout = var->depth_layout; 2312 2313 } else { 2314 _mesa_glsl_error(&loc, state, "`%s' redeclared", decl->identifier); 2315 } 2316 2317 return earlier; 2318} 2319 2320/** 2321 * Generate the IR for an initializer in a variable declaration 2322 */ 2323ir_rvalue * 2324process_initializer(ir_variable *var, ast_declaration *decl, 2325 ast_fully_specified_type *type, 2326 exec_list *initializer_instructions, 2327 struct _mesa_glsl_parse_state *state) 2328{ 2329 ir_rvalue *result = NULL; 2330 2331 YYLTYPE initializer_loc = decl->initializer->get_location(); 2332 2333 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec: 2334 * 2335 * "All uniform variables are read-only and are initialized either 2336 * directly by an application via API commands, or indirectly by 2337 * OpenGL." 2338 */ 2339 if ((state->language_version <= 110) 2340 && (var->mode == ir_var_uniform)) { 2341 _mesa_glsl_error(& initializer_loc, state, 2342 "cannot initialize uniforms in GLSL 1.10"); 2343 } 2344 2345 if (var->type->is_sampler()) { 2346 _mesa_glsl_error(& initializer_loc, state, 2347 "cannot initialize samplers"); 2348 } 2349 2350 if ((var->mode == ir_var_in) && (state->current_function == NULL)) { 2351 _mesa_glsl_error(& initializer_loc, state, 2352 "cannot initialize %s shader input / %s", 2353 _mesa_glsl_shader_target_name(state->target), 2354 (state->target == vertex_shader) 2355 ? "attribute" : "varying"); 2356 } 2357 2358 ir_dereference *const lhs = new(state) ir_dereference_variable(var); 2359 ir_rvalue *rhs = decl->initializer->hir(initializer_instructions, 2360 state); 2361 2362 /* Calculate the constant value if this is a const or uniform 2363 * declaration. 2364 */ 2365 if (type->qualifier.flags.q.constant 2366 || type->qualifier.flags.q.uniform) { 2367 ir_rvalue *new_rhs = validate_assignment(state, var->type, rhs, true); 2368 if (new_rhs != NULL) { 2369 rhs = new_rhs; 2370 2371 ir_constant *constant_value = rhs->constant_expression_value(); 2372 if (!constant_value) { 2373 _mesa_glsl_error(& initializer_loc, state, 2374 "initializer of %s variable `%s' must be a " 2375 "constant expression", 2376 (type->qualifier.flags.q.constant) 2377 ? "const" : "uniform", 2378 decl->identifier); 2379 if (var->type->is_numeric()) { 2380 /* Reduce cascading errors. */ 2381 var->constant_value = ir_constant::zero(state, var->type); 2382 } 2383 } else { 2384 rhs = constant_value; 2385 var->constant_value = constant_value; 2386 } 2387 } else { 2388 _mesa_glsl_error(&initializer_loc, state, 2389 "initializer of type %s cannot be assigned to " 2390 "variable of type %s", 2391 rhs->type->name, var->type->name); 2392 if (var->type->is_numeric()) { 2393 /* Reduce cascading errors. */ 2394 var->constant_value = ir_constant::zero(state, var->type); 2395 } 2396 } 2397 } 2398 2399 if (rhs && !rhs->type->is_error()) { 2400 bool temp = var->read_only; 2401 if (type->qualifier.flags.q.constant) 2402 var->read_only = false; 2403 2404 /* Never emit code to initialize a uniform. 2405 */ 2406 const glsl_type *initializer_type; 2407 if (!type->qualifier.flags.q.uniform) { 2408 result = do_assignment(initializer_instructions, state, 2409 NULL, 2410 lhs, rhs, true, 2411 type->get_location()); 2412 initializer_type = result->type; 2413 } else 2414 initializer_type = rhs->type; 2415 2416 var->constant_initializer = rhs->constant_expression_value(); 2417 var->has_initializer = true; 2418 2419 /* If the declared variable is an unsized array, it must inherrit 2420 * its full type from the initializer. A declaration such as 2421 * 2422 * uniform float a[] = float[](1.0, 2.0, 3.0, 3.0); 2423 * 2424 * becomes 2425 * 2426 * uniform float a[4] = float[](1.0, 2.0, 3.0, 3.0); 2427 * 2428 * The assignment generated in the if-statement (below) will also 2429 * automatically handle this case for non-uniforms. 2430 * 2431 * If the declared variable is not an array, the types must 2432 * already match exactly. As a result, the type assignment 2433 * here can be done unconditionally. For non-uniforms the call 2434 * to do_assignment can change the type of the initializer (via 2435 * the implicit conversion rules). For uniforms the initializer 2436 * must be a constant expression, and the type of that expression 2437 * was validated above. 2438 */ 2439 var->type = initializer_type; 2440 2441 var->read_only = temp; 2442 } 2443 2444 return result; 2445} 2446 2447ir_rvalue * 2448ast_declarator_list::hir(exec_list *instructions, 2449 struct _mesa_glsl_parse_state *state) 2450{ 2451 void *ctx = state; 2452 const struct glsl_type *decl_type; 2453 const char *type_name = NULL; 2454 ir_rvalue *result = NULL; 2455 YYLTYPE loc = this->get_location(); 2456 2457 /* From page 46 (page 52 of the PDF) of the GLSL 1.50 spec: 2458 * 2459 * "To ensure that a particular output variable is invariant, it is 2460 * necessary to use the invariant qualifier. It can either be used to 2461 * qualify a previously declared variable as being invariant 2462 * 2463 * invariant gl_Position; // make existing gl_Position be invariant" 2464 * 2465 * In these cases the parser will set the 'invariant' flag in the declarator 2466 * list, and the type will be NULL. 2467 */ 2468 if (this->invariant) { 2469 assert(this->type == NULL); 2470 2471 if (state->current_function != NULL) { 2472 _mesa_glsl_error(& loc, state, 2473 "All uses of `invariant' keyword must be at global " 2474 "scope\n"); 2475 } 2476 2477 foreach_list_typed (ast_declaration, decl, link, &this->declarations) { 2478 assert(!decl->is_array); 2479 assert(decl->array_size == NULL); 2480 assert(decl->initializer == NULL); 2481 2482 ir_variable *const earlier = 2483 state->symbols->get_variable(decl->identifier); 2484 if (earlier == NULL) { 2485 _mesa_glsl_error(& loc, state, 2486 "Undeclared variable `%s' cannot be marked " 2487 "invariant\n", decl->identifier); 2488 } else if ((state->target == vertex_shader) 2489 && (earlier->mode != ir_var_out)) { 2490 _mesa_glsl_error(& loc, state, 2491 "`%s' cannot be marked invariant, vertex shader " 2492 "outputs only\n", decl->identifier); 2493 } else if ((state->target == fragment_shader) 2494 && (earlier->mode != ir_var_in)) { 2495 _mesa_glsl_error(& loc, state, 2496 "`%s' cannot be marked invariant, fragment shader " 2497 "inputs only\n", decl->identifier); 2498 } else if (earlier->used) { 2499 _mesa_glsl_error(& loc, state, 2500 "variable `%s' may not be redeclared " 2501 "`invariant' after being used", 2502 earlier->name); 2503 } else { 2504 earlier->invariant = true; 2505 } 2506 } 2507 2508 /* Invariant redeclarations do not have r-values. 2509 */ 2510 return NULL; 2511 } 2512 2513 assert(this->type != NULL); 2514 assert(!this->invariant); 2515 2516 /* The type specifier may contain a structure definition. Process that 2517 * before any of the variable declarations. 2518 */ 2519 (void) this->type->specifier->hir(instructions, state); 2520 2521 decl_type = this->type->specifier->glsl_type(& type_name, state); 2522 if (this->declarations.is_empty()) { 2523 /* If there is no structure involved in the program text, there are two 2524 * possible scenarios: 2525 * 2526 * - The program text contained something like 'vec4;'. This is an 2527 * empty declaration. It is valid but weird. Emit a warning. 2528 * 2529 * - The program text contained something like 'S;' and 'S' is not the 2530 * name of a known structure type. This is both invalid and weird. 2531 * Emit an error. 2532 * 2533 * Note that if decl_type is NULL and there is a structure involved, 2534 * there must have been some sort of error with the structure. In this 2535 * case we assume that an error was already generated on this line of 2536 * code for the structure. There is no need to generate an additional, 2537 * confusing error. 2538 */ 2539 assert(this->type->specifier->structure == NULL || decl_type != NULL 2540 || state->error); 2541 if (this->type->specifier->structure == NULL) { 2542 if (decl_type != NULL) { 2543 _mesa_glsl_warning(&loc, state, "empty declaration"); 2544 } else { 2545 _mesa_glsl_error(&loc, state, 2546 "invalid type `%s' in empty declaration", 2547 type_name); 2548 } 2549 } 2550 } 2551 2552 foreach_list_typed (ast_declaration, decl, link, &this->declarations) { 2553 const struct glsl_type *var_type; 2554 ir_variable *var; 2555 2556 /* FINISHME: Emit a warning if a variable declaration shadows a 2557 * FINISHME: declaration at a higher scope. 2558 */ 2559 2560 if ((decl_type == NULL) || decl_type->is_void()) { 2561 if (type_name != NULL) { 2562 _mesa_glsl_error(& loc, state, 2563 "invalid type `%s' in declaration of `%s'", 2564 type_name, decl->identifier); 2565 } else { 2566 _mesa_glsl_error(& loc, state, 2567 "invalid type in declaration of `%s'", 2568 decl->identifier); 2569 } 2570 continue; 2571 } 2572 2573 if (decl->is_array) { 2574 var_type = process_array_type(&loc, decl_type, decl->array_size, 2575 state); 2576 if (var_type->is_error()) 2577 continue; 2578 } else { 2579 var_type = decl_type; 2580 } 2581 2582 var = new(ctx) ir_variable(var_type, decl->identifier, ir_var_auto); 2583 2584 /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification; 2585 * 2586 * "Global variables can only use the qualifiers const, 2587 * attribute, uni form, or varying. Only one may be 2588 * specified. 2589 * 2590 * Local variables can only use the qualifier const." 2591 * 2592 * This is relaxed in GLSL 1.30. It is also relaxed by any extension 2593 * that adds the 'layout' keyword. 2594 */ 2595 if ((state->language_version < 130) 2596 && !state->ARB_explicit_attrib_location_enable 2597 && !state->ARB_fragment_coord_conventions_enable) { 2598 if (this->type->qualifier.flags.q.out) { 2599 _mesa_glsl_error(& loc, state, 2600 "`out' qualifier in declaration of `%s' " 2601 "only valid for function parameters in %s.", 2602 decl->identifier, state->version_string); 2603 } 2604 if (this->type->qualifier.flags.q.in) { 2605 _mesa_glsl_error(& loc, state, 2606 "`in' qualifier in declaration of `%s' " 2607 "only valid for function parameters in %s.", 2608 decl->identifier, state->version_string); 2609 } 2610 /* FINISHME: Test for other invalid qualifiers. */ 2611 } 2612 2613 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, 2614 & loc); 2615 2616 if (this->type->qualifier.flags.q.invariant) { 2617 if ((state->target == vertex_shader) && !(var->mode == ir_var_out || 2618 var->mode == ir_var_inout)) { 2619 /* FINISHME: Note that this doesn't work for invariant on 2620 * a function signature outval 2621 */ 2622 _mesa_glsl_error(& loc, state, 2623 "`%s' cannot be marked invariant, vertex shader " 2624 "outputs only\n", var->name); 2625 } else if ((state->target == fragment_shader) && 2626 !(var->mode == ir_var_in || var->mode == ir_var_inout)) { 2627 /* FINISHME: Note that this doesn't work for invariant on 2628 * a function signature inval 2629 */ 2630 _mesa_glsl_error(& loc, state, 2631 "`%s' cannot be marked invariant, fragment shader " 2632 "inputs only\n", var->name); 2633 } 2634 } 2635 2636 if (state->current_function != NULL) { 2637 const char *mode = NULL; 2638 const char *extra = ""; 2639 2640 /* There is no need to check for 'inout' here because the parser will 2641 * only allow that in function parameter lists. 2642 */ 2643 if (this->type->qualifier.flags.q.attribute) { 2644 mode = "attribute"; 2645 } else if (this->type->qualifier.flags.q.uniform) { 2646 mode = "uniform"; 2647 } else if (this->type->qualifier.flags.q.varying) { 2648 mode = "varying"; 2649 } else if (this->type->qualifier.flags.q.in) { 2650 mode = "in"; 2651 extra = " or in function parameter list"; 2652 } else if (this->type->qualifier.flags.q.out) { 2653 mode = "out"; 2654 extra = " or in function parameter list"; 2655 } 2656 2657 if (mode) { 2658 _mesa_glsl_error(& loc, state, 2659 "%s variable `%s' must be declared at " 2660 "global scope%s", 2661 mode, var->name, extra); 2662 } 2663 } else if (var->mode == ir_var_in) { 2664 var->read_only = true; 2665 2666 if (state->target == vertex_shader) { 2667 bool error_emitted = false; 2668 2669 /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: 2670 * 2671 * "Vertex shader inputs can only be float, floating-point 2672 * vectors, matrices, signed and unsigned integers and integer 2673 * vectors. Vertex shader inputs can also form arrays of these 2674 * types, but not structures." 2675 * 2676 * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec: 2677 * 2678 * "Vertex shader inputs can only be float, floating-point 2679 * vectors, matrices, signed and unsigned integers and integer 2680 * vectors. They cannot be arrays or structures." 2681 * 2682 * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec: 2683 * 2684 * "The attribute qualifier can be used only with float, 2685 * floating-point vectors, and matrices. Attribute variables 2686 * cannot be declared as arrays or structures." 2687 */ 2688 const glsl_type *check_type = var->type->is_array() 2689 ? var->type->fields.array : var->type; 2690 2691 switch (check_type->base_type) { 2692 case GLSL_TYPE_FLOAT: 2693 break; 2694 case GLSL_TYPE_UINT: 2695 case GLSL_TYPE_INT: 2696 if (state->language_version > 120) 2697 break; 2698 /* FALLTHROUGH */ 2699 default: 2700 _mesa_glsl_error(& loc, state, 2701 "vertex shader input / attribute cannot have " 2702 "type %s`%s'", 2703 var->type->is_array() ? "array of " : "", 2704 check_type->name); 2705 error_emitted = true; 2706 } 2707 2708 if (!error_emitted && (state->language_version <= 130) 2709 && var->type->is_array()) { 2710 _mesa_glsl_error(& loc, state, 2711 "vertex shader input / attribute cannot have " 2712 "array type"); 2713 error_emitted = true; 2714 } 2715 } 2716 } 2717 2718 /* Integer vertex outputs must be qualified with 'flat'. 2719 * 2720 * From section 4.3.6 of the GLSL 1.30 spec: 2721 * "If a vertex output is a signed or unsigned integer or integer 2722 * vector, then it must be qualified with the interpolation qualifier 2723 * flat." 2724 */ 2725 if (state->language_version >= 130 2726 && state->target == vertex_shader 2727 && state->current_function == NULL 2728 && var->type->is_integer() 2729 && var->mode == ir_var_out 2730 && var->interpolation != INTERP_QUALIFIER_FLAT) { 2731 2732 _mesa_glsl_error(&loc, state, "If a vertex output is an integer, " 2733 "then it must be qualified with 'flat'"); 2734 } 2735 2736 2737 /* Interpolation qualifiers cannot be applied to 'centroid' and 2738 * 'centroid varying'. 2739 * 2740 * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec: 2741 * "interpolation qualifiers may only precede the qualifiers in, 2742 * centroid in, out, or centroid out in a declaration. They do not apply 2743 * to the deprecated storage qualifiers varying or centroid varying." 2744 */ 2745 if (state->language_version >= 130 2746 && this->type->qualifier.has_interpolation() 2747 && this->type->qualifier.flags.q.varying) { 2748 2749 const char *i = this->type->qualifier.interpolation_string(); 2750 assert(i != NULL); 2751 const char *s; 2752 if (this->type->qualifier.flags.q.centroid) 2753 s = "centroid varying"; 2754 else 2755 s = "varying"; 2756 2757 _mesa_glsl_error(&loc, state, 2758 "qualifier '%s' cannot be applied to the " 2759 "deprecated storage qualifier '%s'", i, s); 2760 } 2761 2762 2763 /* Interpolation qualifiers can only apply to vertex shader outputs and 2764 * fragment shader inputs. 2765 * 2766 * From page 29 (page 35 of the PDF) of the GLSL 1.30 spec: 2767 * "Outputs from a vertex shader (out) and inputs to a fragment 2768 * shader (in) can be further qualified with one or more of these 2769 * interpolation qualifiers" 2770 */ 2771 if (state->language_version >= 130 2772 && this->type->qualifier.has_interpolation()) { 2773 2774 const char *i = this->type->qualifier.interpolation_string(); 2775 assert(i != NULL); 2776 2777 switch (state->target) { 2778 case vertex_shader: 2779 if (this->type->qualifier.flags.q.in) { 2780 _mesa_glsl_error(&loc, state, 2781 "qualifier '%s' cannot be applied to vertex " 2782 "shader inputs", i); 2783 } 2784 break; 2785 case fragment_shader: 2786 if (this->type->qualifier.flags.q.out) { 2787 _mesa_glsl_error(&loc, state, 2788 "qualifier '%s' cannot be applied to fragment " 2789 "shader outputs", i); 2790 } 2791 break; 2792 default: 2793 assert(0); 2794 } 2795 } 2796 2797 2798 /* From section 4.3.4 of the GLSL 1.30 spec: 2799 * "It is an error to use centroid in in a vertex shader." 2800 */ 2801 if (state->language_version >= 130 2802 && this->type->qualifier.flags.q.centroid 2803 && this->type->qualifier.flags.q.in 2804 && state->target == vertex_shader) { 2805 2806 _mesa_glsl_error(&loc, state, 2807 "'centroid in' cannot be used in a vertex shader"); 2808 } 2809 2810 2811 /* Precision qualifiers exists only in GLSL versions 1.00 and >= 1.30. 2812 */ 2813 if (this->type->specifier->precision != ast_precision_none 2814 && state->language_version != 100 2815 && state->language_version < 130) { 2816 2817 _mesa_glsl_error(&loc, state, 2818 "precision qualifiers are supported only in GLSL ES " 2819 "1.00, and GLSL 1.30 and later"); 2820 } 2821 2822 2823 /* Precision qualifiers only apply to floating point and integer types. 2824 * 2825 * From section 4.5.2 of the GLSL 1.30 spec: 2826 * "Any floating point or any integer declaration can have the type 2827 * preceded by one of these precision qualifiers [...] Literal 2828 * constants do not have precision qualifiers. Neither do Boolean 2829 * variables. 2830 * 2831 * In GLSL ES, sampler types are also allowed. 2832 * 2833 * From page 87 of the GLSL ES spec: 2834 * "RESOLUTION: Allow sampler types to take a precision qualifier." 2835 */ 2836 if (this->type->specifier->precision != ast_precision_none 2837 && !var->type->is_float() 2838 && !var->type->is_integer() 2839 && !(var->type->is_sampler() && state->es_shader) 2840 && !(var->type->is_array() 2841 && (var->type->fields.array->is_float() 2842 || var->type->fields.array->is_integer()))) { 2843 2844 _mesa_glsl_error(&loc, state, 2845 "precision qualifiers apply only to floating point" 2846 "%s types", state->es_shader ? ", integer, and sampler" 2847 : "and integer"); 2848 } 2849 2850 /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec: 2851 * 2852 * "[Sampler types] can only be declared as function 2853 * parameters or uniform variables (see Section 4.3.5 2854 * "Uniform")". 2855 */ 2856 if (var_type->contains_sampler() && 2857 !this->type->qualifier.flags.q.uniform) { 2858 _mesa_glsl_error(&loc, state, "samplers must be declared uniform"); 2859 } 2860 2861 /* Process the initializer and add its instructions to a temporary 2862 * list. This list will be added to the instruction stream (below) after 2863 * the declaration is added. This is done because in some cases (such as 2864 * redeclarations) the declaration may not actually be added to the 2865 * instruction stream. 2866 */ 2867 exec_list initializer_instructions; 2868 ir_variable *earlier = get_variable_being_redeclared(var, decl, state); 2869 2870 if (decl->initializer != NULL) { 2871 result = process_initializer((earlier == NULL) ? var : earlier, 2872 decl, this->type, 2873 &initializer_instructions, state); 2874 } 2875 2876 /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec: 2877 * 2878 * "It is an error to write to a const variable outside of 2879 * its declaration, so they must be initialized when 2880 * declared." 2881 */ 2882 if (this->type->qualifier.flags.q.constant && decl->initializer == NULL) { 2883 _mesa_glsl_error(& loc, state, 2884 "const declaration of `%s' must be initialized", 2885 decl->identifier); 2886 } 2887 2888 /* If the declaration is not a redeclaration, there are a few additional 2889 * semantic checks that must be applied. In addition, variable that was 2890 * created for the declaration should be added to the IR stream. 2891 */ 2892 if (earlier == NULL) { 2893 /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec, 2894 * 2895 * "Identifiers starting with "gl_" are reserved for use by 2896 * OpenGL, and may not be declared in a shader as either a 2897 * variable or a function." 2898 */ 2899 if (strncmp(decl->identifier, "gl_", 3) == 0) 2900 _mesa_glsl_error(& loc, state, 2901 "identifier `%s' uses reserved `gl_' prefix", 2902 decl->identifier); 2903 else if (strstr(decl->identifier, "__")) { 2904 /* From page 14 (page 20 of the PDF) of the GLSL 1.10 2905 * spec: 2906 * 2907 * "In addition, all identifiers containing two 2908 * consecutive underscores (__) are reserved as 2909 * possible future keywords." 2910 */ 2911 _mesa_glsl_error(& loc, state, 2912 "identifier `%s' uses reserved `__' string", 2913 decl->identifier); 2914 } 2915 2916 /* Add the variable to the symbol table. Note that the initializer's 2917 * IR was already processed earlier (though it hasn't been emitted 2918 * yet), without the variable in scope. 2919 * 2920 * This differs from most C-like languages, but it follows the GLSL 2921 * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50 2922 * spec: 2923 * 2924 * "Within a declaration, the scope of a name starts immediately 2925 * after the initializer if present or immediately after the name 2926 * being declared if not." 2927 */ 2928 if (!state->symbols->add_variable(var)) { 2929 YYLTYPE loc = this->get_location(); 2930 _mesa_glsl_error(&loc, state, "name `%s' already taken in the " 2931 "current scope", decl->identifier); 2932 continue; 2933 } 2934 2935 /* Push the variable declaration to the top. It means that all the 2936 * variable declarations will appear in a funny last-to-first order, 2937 * but otherwise we run into trouble if a function is prototyped, a 2938 * global var is decled, then the function is defined with usage of 2939 * the global var. See glslparsertest's CorrectModule.frag. 2940 */ 2941 instructions->push_head(var); 2942 } 2943 2944 instructions->append_list(&initializer_instructions); 2945 } 2946 2947 2948 /* Generally, variable declarations do not have r-values. However, 2949 * one is used for the declaration in 2950 * 2951 * while (bool b = some_condition()) { 2952 * ... 2953 * } 2954 * 2955 * so we return the rvalue from the last seen declaration here. 2956 */ 2957 return result; 2958} 2959 2960 2961ir_rvalue * 2962ast_parameter_declarator::hir(exec_list *instructions, 2963 struct _mesa_glsl_parse_state *state) 2964{ 2965 void *ctx = state; 2966 const struct glsl_type *type; 2967 const char *name = NULL; 2968 YYLTYPE loc = this->get_location(); 2969 2970 type = this->type->specifier->glsl_type(& name, state); 2971 2972 if (type == NULL) { 2973 if (name != NULL) { 2974 _mesa_glsl_error(& loc, state, 2975 "invalid type `%s' in declaration of `%s'", 2976 name, this->identifier); 2977 } else { 2978 _mesa_glsl_error(& loc, state, 2979 "invalid type in declaration of `%s'", 2980 this->identifier); 2981 } 2982 2983 type = glsl_type::error_type; 2984 } 2985 2986 /* From page 62 (page 68 of the PDF) of the GLSL 1.50 spec: 2987 * 2988 * "Functions that accept no input arguments need not use void in the 2989 * argument list because prototypes (or definitions) are required and 2990 * therefore there is no ambiguity when an empty argument list "( )" is 2991 * declared. The idiom "(void)" as a parameter list is provided for 2992 * convenience." 2993 * 2994 * Placing this check here prevents a void parameter being set up 2995 * for a function, which avoids tripping up checks for main taking 2996 * parameters and lookups of an unnamed symbol. 2997 */ 2998 if (type->is_void()) { 2999 if (this->identifier != NULL) 3000 _mesa_glsl_error(& loc, state, 3001 "named parameter cannot have type `void'"); 3002 3003 is_void = true; 3004 return NULL; 3005 } 3006 3007 if (formal_parameter && (this->identifier == NULL)) { 3008 _mesa_glsl_error(& loc, state, "formal parameter lacks a name"); 3009 return NULL; 3010 } 3011 3012 /* This only handles "vec4 foo[..]". The earlier specifier->glsl_type(...) 3013 * call already handled the "vec4[..] foo" case. 3014 */ 3015 if (this->is_array) { 3016 type = process_array_type(&loc, type, this->array_size, state); 3017 } 3018 3019 if (!type->is_error() && type->array_size() == 0) { 3020 _mesa_glsl_error(&loc, state, "arrays passed as parameters must have " 3021 "a declared size."); 3022 type = glsl_type::error_type; 3023 } 3024 3025 is_void = false; 3026 ir_variable *var = new(ctx) ir_variable(type, this->identifier, ir_var_in); 3027 3028 /* Apply any specified qualifiers to the parameter declaration. Note that 3029 * for function parameters the default mode is 'in'. 3030 */ 3031 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc); 3032 3033 /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec: 3034 * 3035 * "Samplers cannot be treated as l-values; hence cannot be used 3036 * as out or inout function parameters, nor can they be assigned 3037 * into." 3038 */ 3039 if ((var->mode == ir_var_inout || var->mode == ir_var_out) 3040 && type->contains_sampler()) { 3041 _mesa_glsl_error(&loc, state, "out and inout parameters cannot contain samplers"); 3042 type = glsl_type::error_type; 3043 } 3044 3045 /* From page 39 (page 45 of the PDF) of the GLSL 1.10 spec: 3046 * 3047 * "When calling a function, expressions that do not evaluate to 3048 * l-values cannot be passed to parameters declared as out or inout." 3049 * 3050 * From page 32 (page 38 of the PDF) of the GLSL 1.10 spec: 3051 * 3052 * "Other binary or unary expressions, non-dereferenced arrays, 3053 * function names, swizzles with repeated fields, and constants 3054 * cannot be l-values." 3055 * 3056 * So for GLSL 1.10, passing an array as an out or inout parameter is not 3057 * allowed. This restriction is removed in GLSL 1.20, and in GLSL ES. 3058 */ 3059 if ((var->mode == ir_var_inout || var->mode == ir_var_out) 3060 && type->is_array() && state->language_version == 110) { 3061 _mesa_glsl_error(&loc, state, "Arrays cannot be out or inout parameters in GLSL 1.10"); 3062 type = glsl_type::error_type; 3063 } 3064 3065 instructions->push_tail(var); 3066 3067 /* Parameter declarations do not have r-values. 3068 */ 3069 return NULL; 3070} 3071 3072 3073void 3074ast_parameter_declarator::parameters_to_hir(exec_list *ast_parameters, 3075 bool formal, 3076 exec_list *ir_parameters, 3077 _mesa_glsl_parse_state *state) 3078{ 3079 ast_parameter_declarator *void_param = NULL; 3080 unsigned count = 0; 3081 3082 foreach_list_typed (ast_parameter_declarator, param, link, ast_parameters) { 3083 param->formal_parameter = formal; 3084 param->hir(ir_parameters, state); 3085 3086 if (param->is_void) 3087 void_param = param; 3088 3089 count++; 3090 } 3091 3092 if ((void_param != NULL) && (count > 1)) { 3093 YYLTYPE loc = void_param->get_location(); 3094 3095 _mesa_glsl_error(& loc, state, 3096 "`void' parameter must be only parameter"); 3097 } 3098} 3099 3100 3101void 3102emit_function(_mesa_glsl_parse_state *state, ir_function *f) 3103{ 3104 /* IR invariants disallow function declarations or definitions 3105 * nested within other function definitions. But there is no 3106 * requirement about the relative order of function declarations 3107 * and definitions with respect to one another. So simply insert 3108 * the new ir_function block at the end of the toplevel instruction 3109 * list. 3110 */ 3111 state->toplevel_ir->push_tail(f); 3112} 3113 3114 3115ir_rvalue * 3116ast_function::hir(exec_list *instructions, 3117 struct _mesa_glsl_parse_state *state) 3118{ 3119 void *ctx = state; 3120 ir_function *f = NULL; 3121 ir_function_signature *sig = NULL; 3122 exec_list hir_parameters; 3123 3124 const char *const name = identifier; 3125 3126 /* New functions are always added to the top-level IR instruction stream, 3127 * so this instruction list pointer is ignored. See also emit_function 3128 * (called below). 3129 */ 3130 (void) instructions; 3131 3132 /* From page 21 (page 27 of the PDF) of the GLSL 1.20 spec, 3133 * 3134 * "Function declarations (prototypes) cannot occur inside of functions; 3135 * they must be at global scope, or for the built-in functions, outside 3136 * the global scope." 3137 * 3138 * From page 27 (page 33 of the PDF) of the GLSL ES 1.00.16 spec, 3139 * 3140 * "User defined functions may only be defined within the global scope." 3141 * 3142 * Note that this language does not appear in GLSL 1.10. 3143 */ 3144 if ((state->current_function != NULL) && (state->language_version != 110)) { 3145 YYLTYPE loc = this->get_location(); 3146 _mesa_glsl_error(&loc, state, 3147 "declaration of function `%s' not allowed within " 3148 "function body", name); 3149 } 3150 3151 /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec, 3152 * 3153 * "Identifiers starting with "gl_" are reserved for use by 3154 * OpenGL, and may not be declared in a shader as either a 3155 * variable or a function." 3156 */ 3157 if (strncmp(name, "gl_", 3) == 0) { 3158 YYLTYPE loc = this->get_location(); 3159 _mesa_glsl_error(&loc, state, 3160 "identifier `%s' uses reserved `gl_' prefix", name); 3161 } 3162 3163 /* Convert the list of function parameters to HIR now so that they can be 3164 * used below to compare this function's signature with previously seen 3165 * signatures for functions with the same name. 3166 */ 3167 ast_parameter_declarator::parameters_to_hir(& this->parameters, 3168 is_definition, 3169 & hir_parameters, state); 3170 3171 const char *return_type_name; 3172 const glsl_type *return_type = 3173 this->return_type->specifier->glsl_type(& return_type_name, state); 3174 3175 if (!return_type) { 3176 YYLTYPE loc = this->get_location(); 3177 _mesa_glsl_error(&loc, state, 3178 "function `%s' has undeclared return type `%s'", 3179 name, return_type_name); 3180 return_type = glsl_type::error_type; 3181 } 3182 3183 /* From page 56 (page 62 of the PDF) of the GLSL 1.30 spec: 3184 * "No qualifier is allowed on the return type of a function." 3185 */ 3186 if (this->return_type->has_qualifiers()) { 3187 YYLTYPE loc = this->get_location(); 3188 _mesa_glsl_error(& loc, state, 3189 "function `%s' return type has qualifiers", name); 3190 } 3191 3192 /* From page 17 (page 23 of the PDF) of the GLSL 1.20 spec: 3193 * 3194 * "[Sampler types] can only be declared as function parameters 3195 * or uniform variables (see Section 4.3.5 "Uniform")". 3196 */ 3197 if (return_type->contains_sampler()) { 3198 YYLTYPE loc = this->get_location(); 3199 _mesa_glsl_error(&loc, state, 3200 "function `%s' return type can't contain a sampler", 3201 name); 3202 } 3203 3204 /* Verify that this function's signature either doesn't match a previously 3205 * seen signature for a function with the same name, or, if a match is found, 3206 * that the previously seen signature does not have an associated definition. 3207 */ 3208 f = state->symbols->get_function(name); 3209 if (f != NULL && (state->es_shader || f->has_user_signature())) { 3210 sig = f->exact_matching_signature(&hir_parameters); 3211 if (sig != NULL) { 3212 const char *badvar = sig->qualifiers_match(&hir_parameters); 3213 if (badvar != NULL) { 3214 YYLTYPE loc = this->get_location(); 3215 3216 _mesa_glsl_error(&loc, state, "function `%s' parameter `%s' " 3217 "qualifiers don't match prototype", name, badvar); 3218 } 3219 3220 if (sig->return_type != return_type) { 3221 YYLTYPE loc = this->get_location(); 3222 3223 _mesa_glsl_error(&loc, state, "function `%s' return type doesn't " 3224 "match prototype", name); 3225 } 3226 3227 if (is_definition && sig->is_defined) { 3228 YYLTYPE loc = this->get_location(); 3229 3230 _mesa_glsl_error(& loc, state, "function `%s' redefined", name); 3231 } 3232 } 3233 } else { 3234 f = new(ctx) ir_function(name); 3235 if (!state->symbols->add_function(f)) { 3236 /* This function name shadows a non-function use of the same name. */ 3237 YYLTYPE loc = this->get_location(); 3238 3239 _mesa_glsl_error(&loc, state, "function name `%s' conflicts with " 3240 "non-function", name); 3241 return NULL; 3242 } 3243 3244 emit_function(state, f); 3245 } 3246 3247 /* Verify the return type of main() */ 3248 if (strcmp(name, "main") == 0) { 3249 if (! return_type->is_void()) { 3250 YYLTYPE loc = this->get_location(); 3251 3252 _mesa_glsl_error(& loc, state, "main() must return void"); 3253 } 3254 3255 if (!hir_parameters.is_empty()) { 3256 YYLTYPE loc = this->get_location(); 3257 3258 _mesa_glsl_error(& loc, state, "main() must not take any parameters"); 3259 } 3260 } 3261 3262 /* Finish storing the information about this new function in its signature. 3263 */ 3264 if (sig == NULL) { 3265 sig = new(ctx) ir_function_signature(return_type); 3266 f->add_signature(sig); 3267 } 3268 3269 sig->replace_parameters(&hir_parameters); 3270 signature = sig; 3271 3272 /* Function declarations (prototypes) do not have r-values. 3273 */ 3274 return NULL; 3275} 3276 3277 3278ir_rvalue * 3279ast_function_definition::hir(exec_list *instructions, 3280 struct _mesa_glsl_parse_state *state) 3281{ 3282 prototype->is_definition = true; 3283 prototype->hir(instructions, state); 3284 3285 ir_function_signature *signature = prototype->signature; 3286 if (signature == NULL) 3287 return NULL; 3288 3289 assert(state->current_function == NULL); 3290 state->current_function = signature; 3291 state->found_return = false; 3292 3293 /* Duplicate parameters declared in the prototype as concrete variables. 3294 * Add these to the symbol table. 3295 */ 3296 state->symbols->push_scope(); 3297 foreach_iter(exec_list_iterator, iter, signature->parameters) { 3298 ir_variable *const var = ((ir_instruction *) iter.get())->as_variable(); 3299 3300 assert(var != NULL); 3301 3302 /* The only way a parameter would "exist" is if two parameters have 3303 * the same name. 3304 */ 3305 if (state->symbols->name_declared_this_scope(var->name)) { 3306 YYLTYPE loc = this->get_location(); 3307 3308 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name); 3309 } else { 3310 state->symbols->add_variable(var); 3311 } 3312 } 3313 3314 /* Convert the body of the function to HIR. */ 3315 this->body->hir(&signature->body, state); 3316 signature->is_defined = true; 3317 3318 state->symbols->pop_scope(); 3319 3320 assert(state->current_function == signature); 3321 state->current_function = NULL; 3322 3323 if (!signature->return_type->is_void() && !state->found_return) { 3324 YYLTYPE loc = this->get_location(); 3325 _mesa_glsl_error(& loc, state, "function `%s' has non-void return type " 3326 "%s, but no return statement", 3327 signature->function_name(), 3328 signature->return_type->name); 3329 } 3330 3331 /* Function definitions do not have r-values. 3332 */ 3333 return NULL; 3334} 3335 3336 3337ir_rvalue * 3338ast_jump_statement::hir(exec_list *instructions, 3339 struct _mesa_glsl_parse_state *state) 3340{ 3341 void *ctx = state; 3342 3343 switch (mode) { 3344 case ast_return: { 3345 ir_return *inst; 3346 assert(state->current_function); 3347 3348 if (opt_return_value) { 3349 ir_rvalue *const ret = opt_return_value->hir(instructions, state); 3350 3351 /* The value of the return type can be NULL if the shader says 3352 * 'return foo();' and foo() is a function that returns void. 3353 * 3354 * NOTE: The GLSL spec doesn't say that this is an error. The type 3355 * of the return value is void. If the return type of the function is 3356 * also void, then this should compile without error. Seriously. 3357 */ 3358 const glsl_type *const ret_type = 3359 (ret == NULL) ? glsl_type::void_type : ret->type; 3360 3361 /* Implicit conversions are not allowed for return values. */ 3362 if (state->current_function->return_type != ret_type) { 3363 YYLTYPE loc = this->get_location(); 3364 3365 _mesa_glsl_error(& loc, state, 3366 "`return' with wrong type %s, in function `%s' " 3367 "returning %s", 3368 ret_type->name, 3369 state->current_function->function_name(), 3370 state->current_function->return_type->name); 3371 } 3372 3373 inst = new(ctx) ir_return(ret); 3374 } else { 3375 if (state->current_function->return_type->base_type != 3376 GLSL_TYPE_VOID) { 3377 YYLTYPE loc = this->get_location(); 3378 3379 _mesa_glsl_error(& loc, state, 3380 "`return' with no value, in function %s returning " 3381 "non-void", 3382 state->current_function->function_name()); 3383 } 3384 inst = new(ctx) ir_return; 3385 } 3386 3387 state->found_return = true; 3388 instructions->push_tail(inst); 3389 break; 3390 } 3391 3392 case ast_discard: 3393 if (state->target != fragment_shader) { 3394 YYLTYPE loc = this->get_location(); 3395 3396 _mesa_glsl_error(& loc, state, 3397 "`discard' may only appear in a fragment shader"); 3398 } 3399 instructions->push_tail(new(ctx) ir_discard); 3400 break; 3401 3402 case ast_break: 3403 case ast_continue: 3404 if (mode == ast_continue && 3405 state->loop_nesting_ast == NULL) { 3406 YYLTYPE loc = this->get_location(); 3407 3408 _mesa_glsl_error(& loc, state, 3409 "continue may only appear in a loop"); 3410 } else if (mode == ast_break && 3411 state->loop_nesting_ast == NULL && 3412 state->switch_state.switch_nesting_ast == NULL) { 3413 YYLTYPE loc = this->get_location(); 3414 3415 _mesa_glsl_error(& loc, state, 3416 "break may only appear in a loop or a switch"); 3417 } else { 3418 /* For a loop, inline the for loop expression again, 3419 * since we don't know where near the end of 3420 * the loop body the normal copy of it 3421 * is going to be placed. 3422 */ 3423 if (state->loop_nesting_ast != NULL && 3424 mode == ast_continue && 3425 state->loop_nesting_ast->rest_expression) { 3426 state->loop_nesting_ast->rest_expression->hir(instructions, 3427 state); 3428 } 3429 3430 if (state->switch_state.is_switch_innermost && 3431 mode == ast_break) { 3432 /* Force break out of switch by setting is_break switch state. 3433 */ 3434 ir_variable *const is_break_var = state->switch_state.is_break_var; 3435 ir_dereference_variable *const deref_is_break_var = 3436 new(ctx) ir_dereference_variable(is_break_var); 3437 ir_constant *const true_val = new(ctx) ir_constant(true); 3438 ir_assignment *const set_break_var = 3439 new(ctx) ir_assignment(deref_is_break_var, true_val); 3440 3441 instructions->push_tail(set_break_var); 3442 } 3443 else { 3444 ir_loop_jump *const jump = 3445 new(ctx) ir_loop_jump((mode == ast_break) 3446 ? ir_loop_jump::jump_break 3447 : ir_loop_jump::jump_continue); 3448 instructions->push_tail(jump); 3449 } 3450 } 3451 3452 break; 3453 } 3454 3455 /* Jump instructions do not have r-values. 3456 */ 3457 return NULL; 3458} 3459 3460 3461ir_rvalue * 3462ast_selection_statement::hir(exec_list *instructions, 3463 struct _mesa_glsl_parse_state *state) 3464{ 3465 void *ctx = state; 3466 3467 ir_rvalue *const condition = this->condition->hir(instructions, state); 3468 3469 /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec: 3470 * 3471 * "Any expression whose type evaluates to a Boolean can be used as the 3472 * conditional expression bool-expression. Vector types are not accepted 3473 * as the expression to if." 3474 * 3475 * The checks are separated so that higher quality diagnostics can be 3476 * generated for cases where both rules are violated. 3477 */ 3478 if (!condition->type->is_boolean() || !condition->type->is_scalar()) { 3479 YYLTYPE loc = this->condition->get_location(); 3480 3481 _mesa_glsl_error(& loc, state, "if-statement condition must be scalar " 3482 "boolean"); 3483 } 3484 3485 ir_if *const stmt = new(ctx) ir_if(condition); 3486 3487 if (then_statement != NULL) { 3488 state->symbols->push_scope(); 3489 then_statement->hir(& stmt->then_instructions, state); 3490 state->symbols->pop_scope(); 3491 } 3492 3493 if (else_statement != NULL) { 3494 state->symbols->push_scope(); 3495 else_statement->hir(& stmt->else_instructions, state); 3496 state->symbols->pop_scope(); 3497 } 3498 3499 instructions->push_tail(stmt); 3500 3501 /* if-statements do not have r-values. 3502 */ 3503 return NULL; 3504} 3505 3506 3507ir_rvalue * 3508ast_switch_statement::hir(exec_list *instructions, 3509 struct _mesa_glsl_parse_state *state) 3510{ 3511 void *ctx = state; 3512 3513 ir_rvalue *const test_expression = 3514 this->test_expression->hir(instructions, state); 3515 3516 /* From page 66 (page 55 of the PDF) of the GLSL 1.50 spec: 3517 * 3518 * "The type of init-expression in a switch statement must be a 3519 * scalar integer." 3520 */ 3521 if (!test_expression->type->is_scalar() || 3522 !test_expression->type->is_integer()) { 3523 YYLTYPE loc = this->test_expression->get_location(); 3524 3525 _mesa_glsl_error(& loc, 3526 state, 3527 "switch-statement expression must be scalar " 3528 "integer"); 3529 } 3530 3531 /* Track the switch-statement nesting in a stack-like manner. 3532 */ 3533 struct glsl_switch_state saved = state->switch_state; 3534 3535 state->switch_state.is_switch_innermost = true; 3536 state->switch_state.switch_nesting_ast = this; 3537 state->switch_state.labels_ht = hash_table_ctor(0, hash_table_pointer_hash, 3538 hash_table_pointer_compare); 3539 state->switch_state.previous_default = NULL; 3540 3541 /* Initalize is_fallthru state to false. 3542 */ 3543 ir_rvalue *const is_fallthru_val = new (ctx) ir_constant(false); 3544 state->switch_state.is_fallthru_var = 3545 new(ctx) ir_variable(glsl_type::bool_type, 3546 "switch_is_fallthru_tmp", 3547 ir_var_temporary); 3548 instructions->push_tail(state->switch_state.is_fallthru_var); 3549 3550 ir_dereference_variable *deref_is_fallthru_var = 3551 new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var); 3552 instructions->push_tail(new(ctx) ir_assignment(deref_is_fallthru_var, 3553 is_fallthru_val)); 3554 3555 /* Initalize is_break state to false. 3556 */ 3557 ir_rvalue *const is_break_val = new (ctx) ir_constant(false); 3558 state->switch_state.is_break_var = new(ctx) ir_variable(glsl_type::bool_type, 3559 "switch_is_break_tmp", 3560 ir_var_temporary); 3561 instructions->push_tail(state->switch_state.is_break_var); 3562 3563 ir_dereference_variable *deref_is_break_var = 3564 new(ctx) ir_dereference_variable(state->switch_state.is_break_var); 3565 instructions->push_tail(new(ctx) ir_assignment(deref_is_break_var, 3566 is_break_val)); 3567 3568 /* Cache test expression. 3569 */ 3570 test_to_hir(instructions, state); 3571 3572 /* Emit code for body of switch stmt. 3573 */ 3574 body->hir(instructions, state); 3575 3576 hash_table_dtor(state->switch_state.labels_ht); 3577 3578 state->switch_state = saved; 3579 3580 /* Switch statements do not have r-values. */ 3581 return NULL; 3582} 3583 3584 3585void 3586ast_switch_statement::test_to_hir(exec_list *instructions, 3587 struct _mesa_glsl_parse_state *state) 3588{ 3589 void *ctx = state; 3590 3591 /* Cache value of test expression. */ 3592 ir_rvalue *const test_val = 3593 test_expression->hir(instructions, 3594 state); 3595 3596 state->switch_state.test_var = new(ctx) ir_variable(test_val->type, 3597 "switch_test_tmp", 3598 ir_var_temporary); 3599 ir_dereference_variable *deref_test_var = 3600 new(ctx) ir_dereference_variable(state->switch_state.test_var); 3601 3602 instructions->push_tail(state->switch_state.test_var); 3603 instructions->push_tail(new(ctx) ir_assignment(deref_test_var, test_val)); 3604} 3605 3606 3607ir_rvalue * 3608ast_switch_body::hir(exec_list *instructions, 3609 struct _mesa_glsl_parse_state *state) 3610{ 3611 if (stmts != NULL) 3612 stmts->hir(instructions, state); 3613 3614 /* Switch bodies do not have r-values. */ 3615 return NULL; 3616} 3617 3618ir_rvalue * 3619ast_case_statement_list::hir(exec_list *instructions, 3620 struct _mesa_glsl_parse_state *state) 3621{ 3622 foreach_list_typed (ast_case_statement, case_stmt, link, & this->cases) 3623 case_stmt->hir(instructions, state); 3624 3625 /* Case statements do not have r-values. */ 3626 return NULL; 3627} 3628 3629ir_rvalue * 3630ast_case_statement::hir(exec_list *instructions, 3631 struct _mesa_glsl_parse_state *state) 3632{ 3633 labels->hir(instructions, state); 3634 3635 /* Conditionally set fallthru state based on break state. */ 3636 ir_constant *const false_val = new(state) ir_constant(false); 3637 ir_dereference_variable *const deref_is_fallthru_var = 3638 new(state) ir_dereference_variable(state->switch_state.is_fallthru_var); 3639 ir_dereference_variable *const deref_is_break_var = 3640 new(state) ir_dereference_variable(state->switch_state.is_break_var); 3641 ir_assignment *const reset_fallthru_on_break = 3642 new(state) ir_assignment(deref_is_fallthru_var, 3643 false_val, 3644 deref_is_break_var); 3645 instructions->push_tail(reset_fallthru_on_break); 3646 3647 /* Guard case statements depending on fallthru state. */ 3648 ir_dereference_variable *const deref_fallthru_guard = 3649 new(state) ir_dereference_variable(state->switch_state.is_fallthru_var); 3650 ir_if *const test_fallthru = new(state) ir_if(deref_fallthru_guard); 3651 3652 foreach_list_typed (ast_node, stmt, link, & this->stmts) 3653 stmt->hir(& test_fallthru->then_instructions, state); 3654 3655 instructions->push_tail(test_fallthru); 3656 3657 /* Case statements do not have r-values. */ 3658 return NULL; 3659} 3660 3661 3662ir_rvalue * 3663ast_case_label_list::hir(exec_list *instructions, 3664 struct _mesa_glsl_parse_state *state) 3665{ 3666 foreach_list_typed (ast_case_label, label, link, & this->labels) 3667 label->hir(instructions, state); 3668 3669 /* Case labels do not have r-values. */ 3670 return NULL; 3671} 3672 3673ir_rvalue * 3674ast_case_label::hir(exec_list *instructions, 3675 struct _mesa_glsl_parse_state *state) 3676{ 3677 void *ctx = state; 3678 3679 ir_dereference_variable *deref_fallthru_var = 3680 new(ctx) ir_dereference_variable(state->switch_state.is_fallthru_var); 3681 3682 ir_rvalue *const true_val = new(ctx) ir_constant(true); 3683 3684 /* If not default case, ... */ 3685 if (this->test_value != NULL) { 3686 /* Conditionally set fallthru state based on 3687 * comparison of cached test expression value to case label. 3688 */ 3689 ir_rvalue *const label_rval = this->test_value->hir(instructions, state); 3690 ir_constant *label_const = label_rval->constant_expression_value(); 3691 3692 if (!label_const) { 3693 YYLTYPE loc = this->test_value->get_location(); 3694 3695 _mesa_glsl_error(& loc, state, 3696 "switch statement case label must be a " 3697 "constant expression"); 3698 3699 /* Stuff a dummy value in to allow processing to continue. */ 3700 label_const = new(ctx) ir_constant(0); 3701 } else { 3702 ast_expression *previous_label = (ast_expression *) 3703 hash_table_find(state->switch_state.labels_ht, 3704 (void *)(uintptr_t)label_const->value.u[0]); 3705 3706 if (previous_label) { 3707 YYLTYPE loc = this->test_value->get_location(); 3708 _mesa_glsl_error(& loc, state, 3709 "duplicate case value"); 3710 3711 loc = previous_label->get_location(); 3712 _mesa_glsl_error(& loc, state, 3713 "this is the previous case label"); 3714 } else { 3715 hash_table_insert(state->switch_state.labels_ht, 3716 this->test_value, 3717 (void *)(uintptr_t)label_const->value.u[0]); 3718 } 3719 } 3720 3721 ir_dereference_variable *deref_test_var = 3722 new(ctx) ir_dereference_variable(state->switch_state.test_var); 3723 3724 ir_rvalue *const test_cond = new(ctx) ir_expression(ir_binop_all_equal, 3725 label_const, 3726 deref_test_var); 3727 3728 ir_assignment *set_fallthru_on_test = 3729 new(ctx) ir_assignment(deref_fallthru_var, 3730 true_val, 3731 test_cond); 3732 3733 instructions->push_tail(set_fallthru_on_test); 3734 } else { /* default case */ 3735 if (state->switch_state.previous_default) { 3736 printf("a\n"); 3737 YYLTYPE loc = this->get_location(); 3738 _mesa_glsl_error(& loc, state, 3739 "multiple default labels in one switch"); 3740 3741 printf("b\n"); 3742 3743 loc = state->switch_state.previous_default->get_location(); 3744 _mesa_glsl_error(& loc, state, 3745 "this is the first default label"); 3746 } 3747 state->switch_state.previous_default = this; 3748 3749 /* Set falltrhu state. */ 3750 ir_assignment *set_fallthru = 3751 new(ctx) ir_assignment(deref_fallthru_var, true_val); 3752 3753 instructions->push_tail(set_fallthru); 3754 } 3755 3756 /* Case statements do not have r-values. */ 3757 return NULL; 3758} 3759 3760void 3761ast_iteration_statement::condition_to_hir(ir_loop *stmt, 3762 struct _mesa_glsl_parse_state *state) 3763{ 3764 void *ctx = state; 3765 3766 if (condition != NULL) { 3767 ir_rvalue *const cond = 3768 condition->hir(& stmt->body_instructions, state); 3769 3770 if ((cond == NULL) 3771 || !cond->type->is_boolean() || !cond->type->is_scalar()) { 3772 YYLTYPE loc = condition->get_location(); 3773 3774 _mesa_glsl_error(& loc, state, 3775 "loop condition must be scalar boolean"); 3776 } else { 3777 /* As the first code in the loop body, generate a block that looks 3778 * like 'if (!condition) break;' as the loop termination condition. 3779 */ 3780 ir_rvalue *const not_cond = 3781 new(ctx) ir_expression(ir_unop_logic_not, cond); 3782 3783 ir_if *const if_stmt = new(ctx) ir_if(not_cond); 3784 3785 ir_jump *const break_stmt = 3786 new(ctx) ir_loop_jump(ir_loop_jump::jump_break); 3787 3788 if_stmt->then_instructions.push_tail(break_stmt); 3789 stmt->body_instructions.push_tail(if_stmt); 3790 } 3791 } 3792} 3793 3794 3795ir_rvalue * 3796ast_iteration_statement::hir(exec_list *instructions, 3797 struct _mesa_glsl_parse_state *state) 3798{ 3799 void *ctx = state; 3800 3801 /* For-loops and while-loops start a new scope, but do-while loops do not. 3802 */ 3803 if (mode != ast_do_while) 3804 state->symbols->push_scope(); 3805 3806 if (init_statement != NULL) 3807 init_statement->hir(instructions, state); 3808 3809 ir_loop *const stmt = new(ctx) ir_loop(); 3810 instructions->push_tail(stmt); 3811 3812 /* Track the current loop nesting. */ 3813 ast_iteration_statement *nesting_ast = state->loop_nesting_ast; 3814 3815 state->loop_nesting_ast = this; 3816 3817 /* Likewise, indicate that following code is closest to a loop, 3818 * NOT closest to a switch. 3819 */ 3820 bool saved_is_switch_innermost = state->switch_state.is_switch_innermost; 3821 state->switch_state.is_switch_innermost = false; 3822 3823 if (mode != ast_do_while) 3824 condition_to_hir(stmt, state); 3825 3826 if (body != NULL) 3827 body->hir(& stmt->body_instructions, state); 3828 3829 if (rest_expression != NULL) 3830 rest_expression->hir(& stmt->body_instructions, state); 3831 3832 if (mode == ast_do_while) 3833 condition_to_hir(stmt, state); 3834 3835 if (mode != ast_do_while) 3836 state->symbols->pop_scope(); 3837 3838 /* Restore previous nesting before returning. */ 3839 state->loop_nesting_ast = nesting_ast; 3840 state->switch_state.is_switch_innermost = saved_is_switch_innermost; 3841 3842 /* Loops do not have r-values. 3843 */ 3844 return NULL; 3845} 3846 3847 3848ir_rvalue * 3849ast_type_specifier::hir(exec_list *instructions, 3850 struct _mesa_glsl_parse_state *state) 3851{ 3852 if (!this->is_precision_statement && this->structure == NULL) 3853 return NULL; 3854 3855 YYLTYPE loc = this->get_location(); 3856 3857 if (this->precision != ast_precision_none 3858 && state->language_version != 100 3859 && state->language_version < 130) { 3860 _mesa_glsl_error(&loc, state, 3861 "precision qualifiers exist only in " 3862 "GLSL ES 1.00, and GLSL 1.30 and later"); 3863 return NULL; 3864 } 3865 if (this->precision != ast_precision_none 3866 && this->structure != NULL) { 3867 _mesa_glsl_error(&loc, state, 3868 "precision qualifiers do not apply to structures"); 3869 return NULL; 3870 } 3871 3872 /* If this is a precision statement, check that the type to which it is 3873 * applied is either float or int. 3874 * 3875 * From section 4.5.3 of the GLSL 1.30 spec: 3876 * "The precision statement 3877 * precision precision-qualifier type; 3878 * can be used to establish a default precision qualifier. The type 3879 * field can be either int or float [...]. Any other types or 3880 * qualifiers will result in an error. 3881 */ 3882 if (this->is_precision_statement) { 3883 assert(this->precision != ast_precision_none); 3884 assert(this->structure == NULL); /* The check for structures was 3885 * performed above. */ 3886 if (this->is_array) { 3887 _mesa_glsl_error(&loc, state, 3888 "default precision statements do not apply to " 3889 "arrays"); 3890 return NULL; 3891 } 3892 if (strcmp(this->type_name, "float") != 0 && 3893 strcmp(this->type_name, "int") != 0) { 3894 _mesa_glsl_error(&loc, state, 3895 "default precision statements apply only to types " 3896 "float and int"); 3897 return NULL; 3898 } 3899 3900 /* FINISHME: Translate precision statements into IR. */ 3901 return NULL; 3902 } 3903 3904 if (this->structure != NULL) 3905 return this->structure->hir(instructions, state); 3906 3907 return NULL; 3908} 3909 3910 3911ir_rvalue * 3912ast_struct_specifier::hir(exec_list *instructions, 3913 struct _mesa_glsl_parse_state *state) 3914{ 3915 unsigned decl_count = 0; 3916 3917 /* Make an initial pass over the list of structure fields to determine how 3918 * many there are. Each element in this list is an ast_declarator_list. 3919 * This means that we actually need to count the number of elements in the 3920 * 'declarations' list in each of the elements. 3921 */ 3922 foreach_list_typed (ast_declarator_list, decl_list, link, 3923 &this->declarations) { 3924 foreach_list_const (decl_ptr, & decl_list->declarations) { 3925 decl_count++; 3926 } 3927 } 3928 3929 /* Allocate storage for the structure fields and process the field 3930 * declarations. As the declarations are processed, try to also convert 3931 * the types to HIR. This ensures that structure definitions embedded in 3932 * other structure definitions are processed. 3933 */ 3934 glsl_struct_field *const fields = ralloc_array(state, glsl_struct_field, 3935 decl_count); 3936 3937 unsigned i = 0; 3938 foreach_list_typed (ast_declarator_list, decl_list, link, 3939 &this->declarations) { 3940 const char *type_name; 3941 3942 decl_list->type->specifier->hir(instructions, state); 3943 3944 /* Section 10.9 of the GLSL ES 1.00 specification states that 3945 * embedded structure definitions have been removed from the language. 3946 */ 3947 if (state->es_shader && decl_list->type->specifier->structure != NULL) { 3948 YYLTYPE loc = this->get_location(); 3949 _mesa_glsl_error(&loc, state, "Embedded structure definitions are " 3950 "not allowed in GLSL ES 1.00."); 3951 } 3952 3953 const glsl_type *decl_type = 3954 decl_list->type->specifier->glsl_type(& type_name, state); 3955 3956 foreach_list_typed (ast_declaration, decl, link, 3957 &decl_list->declarations) { 3958 const struct glsl_type *field_type = decl_type; 3959 if (decl->is_array) { 3960 YYLTYPE loc = decl->get_location(); 3961 field_type = process_array_type(&loc, decl_type, decl->array_size, 3962 state); 3963 } 3964 fields[i].type = (field_type != NULL) 3965 ? field_type : glsl_type::error_type; 3966 fields[i].name = decl->identifier; 3967 i++; 3968 } 3969 } 3970 3971 assert(i == decl_count); 3972 3973 const glsl_type *t = 3974 glsl_type::get_record_instance(fields, decl_count, this->name); 3975 3976 YYLTYPE loc = this->get_location(); 3977 if (!state->symbols->add_type(name, t)) { 3978 _mesa_glsl_error(& loc, state, "struct `%s' previously defined", name); 3979 } else { 3980 const glsl_type **s = reralloc(state, state->user_structures, 3981 const glsl_type *, 3982 state->num_user_structures + 1); 3983 if (s != NULL) { 3984 s[state->num_user_structures] = t; 3985 state->user_structures = s; 3986 state->num_user_structures++; 3987 } 3988 } 3989 3990 /* Structure type definitions do not have r-values. 3991 */ 3992 return NULL; 3993} 3994 3995static void 3996detect_conflicting_assignments(struct _mesa_glsl_parse_state *state, 3997 exec_list *instructions) 3998{ 3999 bool gl_FragColor_assigned = false; 4000 bool gl_FragData_assigned = false; 4001 bool user_defined_fs_output_assigned = false; 4002 ir_variable *user_defined_fs_output = NULL; 4003 4004 /* It would be nice to have proper location information. */ 4005 YYLTYPE loc; 4006 memset(&loc, 0, sizeof(loc)); 4007 4008 foreach_list(node, instructions) { 4009 ir_variable *var = ((ir_instruction *)node)->as_variable(); 4010 4011 if (!var || !var->assigned) 4012 continue; 4013 4014 if (strcmp(var->name, "gl_FragColor") == 0) 4015 gl_FragColor_assigned = true; 4016 else if (strcmp(var->name, "gl_FragData") == 0) 4017 gl_FragData_assigned = true; 4018 else if (strncmp(var->name, "gl_", 3) != 0) { 4019 if (state->target == fragment_shader && 4020 (var->mode == ir_var_out || var->mode == ir_var_inout)) { 4021 user_defined_fs_output_assigned = true; 4022 user_defined_fs_output = var; 4023 } 4024 } 4025 } 4026 4027 /* From the GLSL 1.30 spec: 4028 * 4029 * "If a shader statically assigns a value to gl_FragColor, it 4030 * may not assign a value to any element of gl_FragData. If a 4031 * shader statically writes a value to any element of 4032 * gl_FragData, it may not assign a value to 4033 * gl_FragColor. That is, a shader may assign values to either 4034 * gl_FragColor or gl_FragData, but not both. Multiple shaders 4035 * linked together must also consistently write just one of 4036 * these variables. Similarly, if user declared output 4037 * variables are in use (statically assigned to), then the 4038 * built-in variables gl_FragColor and gl_FragData may not be 4039 * assigned to. These incorrect usages all generate compile 4040 * time errors." 4041 */ 4042 if (gl_FragColor_assigned && gl_FragData_assigned) { 4043 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 4044 "`gl_FragColor' and `gl_FragData'\n"); 4045 } else if (gl_FragColor_assigned && user_defined_fs_output_assigned) { 4046 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 4047 "`gl_FragColor' and `%s'\n", 4048 user_defined_fs_output->name); 4049 } else if (gl_FragData_assigned && user_defined_fs_output_assigned) { 4050 _mesa_glsl_error(&loc, state, "fragment shader writes to both " 4051 "`gl_FragData' and `%s'\n", 4052 user_defined_fs_output->name); 4053 } 4054} 4055