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