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