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