ast_to_hir.cpp revision 25711a85c22bed305c9b52b89feb9c600d1892df
1e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson/* 2e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * Copyright © 2010 Intel Corporation 3e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 4e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * Permission is hereby granted, free of charge, to any person obtaining a 5e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * copy of this software and associated documentation files (the "Software"), 6e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * to deal in the Software without restriction, including without limitation 7e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * and/or sell copies of the Software, and to permit persons to whom the 9e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * Software is furnished to do so, subject to the following conditions: 10e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 11e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * The above copyright notice and this permission notice (including the next 12e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * paragraph) shall be included in all copies or substantial portions of the 13e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * Software. 14e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 15e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * DEALINGS IN THE SOFTWARE. 22e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson */ 23e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 24e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson/** 25e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * \file ast_to_hir.c 26e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * Convert abstract syntax to to high-level intermediate reprensentation (HIR). 27e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 28e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * During the conversion to HIR, the majority of the symantic checking is 29e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * preformed on the program. This includes: 30e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 31e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * * Symbol table management 32e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * * Type checking 33e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * * Function binding 34e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 35e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * The majority of this work could be done during parsing, and the parser could 36e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * probably generate HIR directly. However, this results in frequent changes 37e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * to the parser code. Since we do not assume that every system this complier 38e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * is built on will have Flex and Bison installed, we have to store the code 39e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * generated by these tools in our version control system. In other parts of 40e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * the system we've seen problems where a parser was changed but the generated 41e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * code was not committed, merge conflicts where created because two developers 42e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * had slightly different versions of Bison installed, etc. 43e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 44e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * I have also noticed that running Bison generated parsers in GDB is very 45e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * irritating. When you get a segfault on '$$ = $1->foo', you can't very 46e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * well 'print $1' in GDB. 47e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * 48e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * As a result, my preference is to put as little C code as possible in the 49e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson * parser (and lexer) sources. 50e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson */ 51e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include <stdio.h> 52e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "main/imports.h" 53e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "glsl_symbol_table.h" 54e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "glsl_parser_extras.h" 55e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "ast.h" 56e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "glsl_types.h" 57e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson#include "ir.h" 58e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 59e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinsonvoid 60e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson_mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) 61e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson{ 62e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson struct simple_node *ptr; 63e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 64e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson _mesa_glsl_initialize_variables(instructions, state); 65e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson _mesa_glsl_initialize_constructors(instructions, state); 66e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson _mesa_glsl_initialize_functions(instructions, state); 67e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 68e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson state->current_function = NULL; 69e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 70e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson foreach (ptr, & state->translation_unit) { 71e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson ((ast_node *)ptr)->hir(instructions, state); 72e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson } 73e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson} 74e0ae5d7e87b1dd6e789803c1b9615a84bd7488b7Ian Parkinson 75 76/** 77 * If a conversion is available, convert one operand to a different type 78 * 79 * The \c from \c ir_rvalue is converted "in place". 80 * 81 * \param to Type that the operand it to be converted to 82 * \param from Operand that is being converted 83 * \param state GLSL compiler state 84 * 85 * \return 86 * If a conversion is possible (or unnecessary), \c true is returned. 87 * Otherwise \c false is returned. 88 */ 89static bool 90apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, 91 struct _mesa_glsl_parse_state *state) 92{ 93 if (to->base_type == from->type->base_type) 94 return true; 95 96 /* This conversion was added in GLSL 1.20. If the compilation mode is 97 * GLSL 1.10, the conversion is skipped. 98 */ 99 if (state->language_version < 120) 100 return false; 101 102 /* From page 27 (page 33 of the PDF) of the GLSL 1.50 spec: 103 * 104 * "There are no implicit array or structure conversions. For 105 * example, an array of int cannot be implicitly converted to an 106 * array of float. There are no implicit conversions between 107 * signed and unsigned integers." 108 */ 109 /* FINISHME: The above comment is partially a lie. There is int/uint 110 * FINISHME: conversion for immediate constants. 111 */ 112 if (!to->is_float() || !from->type->is_numeric()) 113 return false; 114 115 switch (from->type->base_type) { 116 case GLSL_TYPE_INT: 117 from = new ir_expression(ir_unop_i2f, to, from, NULL); 118 break; 119 case GLSL_TYPE_UINT: 120 from = new ir_expression(ir_unop_u2f, to, from, NULL); 121 break; 122 case GLSL_TYPE_BOOL: 123 assert(!"FINISHME: Convert bool to float."); 124 default: 125 assert(0); 126 } 127 128 return true; 129} 130 131 132static const struct glsl_type * 133arithmetic_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b, 134 bool multiply, 135 struct _mesa_glsl_parse_state *state) 136{ 137 const glsl_type *const type_a = value_a->type; 138 const glsl_type *const type_b = value_b->type; 139 140 /* From GLSL 1.50 spec, page 56: 141 * 142 * "The arithmetic binary operators add (+), subtract (-), 143 * multiply (*), and divide (/) operate on integer and 144 * floating-point scalars, vectors, and matrices." 145 */ 146 if (!type_a->is_numeric() || !type_b->is_numeric()) { 147 return glsl_type::error_type; 148 } 149 150 151 /* "If one operand is floating-point based and the other is 152 * not, then the conversions from Section 4.1.10 "Implicit 153 * Conversions" are applied to the non-floating-point-based operand." 154 */ 155 if (!apply_implicit_conversion(type_a, value_b, state) 156 && !apply_implicit_conversion(type_b, value_a, state)) { 157 return glsl_type::error_type; 158 } 159 160 /* "If the operands are integer types, they must both be signed or 161 * both be unsigned." 162 * 163 * From this rule and the preceeding conversion it can be inferred that 164 * both types must be GLSL_TYPE_FLOAT, or GLSL_TYPE_UINT, or GLSL_TYPE_INT. 165 * The is_numeric check above already filtered out the case where either 166 * type is not one of these, so now the base types need only be tested for 167 * equality. 168 */ 169 if (type_a->base_type != type_b->base_type) { 170 return glsl_type::error_type; 171 } 172 173 /* "All arithmetic binary operators result in the same fundamental type 174 * (signed integer, unsigned integer, or floating-point) as the 175 * operands they operate on, after operand type conversion. After 176 * conversion, the following cases are valid 177 * 178 * * The two operands are scalars. In this case the operation is 179 * applied, resulting in a scalar." 180 */ 181 if (type_a->is_scalar() && type_b->is_scalar()) 182 return type_a; 183 184 /* "* One operand is a scalar, and the other is a vector or matrix. 185 * In this case, the scalar operation is applied independently to each 186 * component of the vector or matrix, resulting in the same size 187 * vector or matrix." 188 */ 189 if (type_a->is_scalar()) { 190 if (!type_b->is_scalar()) 191 return type_b; 192 } else if (type_b->is_scalar()) { 193 return type_a; 194 } 195 196 /* All of the combinations of <scalar, scalar>, <vector, scalar>, 197 * <scalar, vector>, <scalar, matrix>, and <matrix, scalar> have been 198 * handled. 199 */ 200 assert(!type_a->is_scalar()); 201 assert(!type_b->is_scalar()); 202 203 /* "* The two operands are vectors of the same size. In this case, the 204 * operation is done component-wise resulting in the same size 205 * vector." 206 */ 207 if (type_a->is_vector() && type_b->is_vector()) { 208 return (type_a == type_b) ? type_a : glsl_type::error_type; 209 } 210 211 /* All of the combinations of <scalar, scalar>, <vector, scalar>, 212 * <scalar, vector>, <scalar, matrix>, <matrix, scalar>, and 213 * <vector, vector> have been handled. At least one of the operands must 214 * be matrix. Further, since there are no integer matrix types, the base 215 * type of both operands must be float. 216 */ 217 assert(type_a->is_matrix() || type_b->is_matrix()); 218 assert(type_a->base_type == GLSL_TYPE_FLOAT); 219 assert(type_b->base_type == GLSL_TYPE_FLOAT); 220 221 /* "* The operator is add (+), subtract (-), or divide (/), and the 222 * operands are matrices with the same number of rows and the same 223 * number of columns. In this case, the operation is done component- 224 * wise resulting in the same size matrix." 225 * * The operator is multiply (*), where both operands are matrices or 226 * one operand is a vector and the other a matrix. A right vector 227 * operand is treated as a column vector and a left vector operand as a 228 * row vector. In all these cases, it is required that the number of 229 * columns of the left operand is equal to the number of rows of the 230 * right operand. Then, the multiply (*) operation does a linear 231 * algebraic multiply, yielding an object that has the same number of 232 * rows as the left operand and the same number of columns as the right 233 * operand. Section 5.10 "Vector and Matrix Operations" explains in 234 * more detail how vectors and matrices are operated on." 235 */ 236 if (! multiply) { 237 return (type_a == type_b) ? type_a : glsl_type::error_type; 238 } else { 239 if (type_a->is_matrix() && type_b->is_matrix()) { 240 /* Matrix multiply. The columns of A must match the rows of B. Given 241 * the other previously tested constraints, this means the vector type 242 * of a row from A must be the same as the vector type of a column from 243 * B. 244 */ 245 if (type_a->row_type() == type_b->column_type()) { 246 /* The resulting matrix has the number of columns of matrix B and 247 * the number of rows of matrix A. We get the row count of A by 248 * looking at the size of a vector that makes up a column. The 249 * transpose (size of a row) is done for B. 250 */ 251 return 252 glsl_type::get_instance(type_a->base_type, 253 type_a->column_type()->vector_elements, 254 type_b->row_type()->vector_elements); 255 } 256 } else if (type_a->is_matrix()) { 257 /* A is a matrix and B is a column vector. Columns of A must match 258 * rows of B. Given the other previously tested constraints, this 259 * means the vector type of a row from A must be the same as the 260 * vector the type of B. 261 */ 262 if (type_a->row_type() == type_b) 263 return type_b; 264 } else { 265 assert(type_b->is_matrix()); 266 267 /* A is a row vector and B is a matrix. Columns of A must match rows 268 * of B. Given the other previously tested constraints, this means 269 * the type of A must be the same as the vector type of a column from 270 * B. 271 */ 272 if (type_a == type_b->column_type()) 273 return type_a; 274 } 275 } 276 277 278 /* "All other cases are illegal." 279 */ 280 return glsl_type::error_type; 281} 282 283 284static const struct glsl_type * 285unary_arithmetic_result_type(const struct glsl_type *type) 286{ 287 /* From GLSL 1.50 spec, page 57: 288 * 289 * "The arithmetic unary operators negate (-), post- and pre-increment 290 * and decrement (-- and ++) operate on integer or floating-point 291 * values (including vectors and matrices). All unary operators work 292 * component-wise on their operands. These result with the same type 293 * they operated on." 294 */ 295 if (!type->is_numeric()) 296 return glsl_type::error_type; 297 298 return type; 299} 300 301 302static const struct glsl_type * 303modulus_result_type(const struct glsl_type *type_a, 304 const struct glsl_type *type_b) 305{ 306 /* From GLSL 1.50 spec, page 56: 307 * "The operator modulus (%) operates on signed or unsigned integers or 308 * integer vectors. The operand types must both be signed or both be 309 * unsigned." 310 */ 311 if (!type_a->is_integer() || !type_b->is_integer() 312 || (type_a->base_type != type_b->base_type)) { 313 return glsl_type::error_type; 314 } 315 316 /* "The operands cannot be vectors of differing size. If one operand is 317 * a scalar and the other vector, then the scalar is applied component- 318 * wise to the vector, resulting in the same type as the vector. If both 319 * are vectors of the same size, the result is computed component-wise." 320 */ 321 if (type_a->is_vector()) { 322 if (!type_b->is_vector() 323 || (type_a->vector_elements == type_b->vector_elements)) 324 return type_a; 325 } else 326 return type_b; 327 328 /* "The operator modulus (%) is not defined for any other data types 329 * (non-integer types)." 330 */ 331 return glsl_type::error_type; 332} 333 334 335static const struct glsl_type * 336relational_result_type(ir_rvalue * &value_a, ir_rvalue * &value_b, 337 struct _mesa_glsl_parse_state *state) 338{ 339 const glsl_type *const type_a = value_a->type; 340 const glsl_type *const type_b = value_b->type; 341 342 /* From GLSL 1.50 spec, page 56: 343 * "The relational operators greater than (>), less than (<), greater 344 * than or equal (>=), and less than or equal (<=) operate only on 345 * scalar integer and scalar floating-point expressions." 346 */ 347 if (!type_a->is_numeric() 348 || !type_b->is_numeric() 349 || !type_a->is_scalar() 350 || !type_b->is_scalar()) 351 return glsl_type::error_type; 352 353 /* "Either the operands' types must match, or the conversions from 354 * Section 4.1.10 "Implicit Conversions" will be applied to the integer 355 * operand, after which the types must match." 356 */ 357 if (!apply_implicit_conversion(type_a, value_b, state) 358 && !apply_implicit_conversion(type_b, value_a, state)) { 359 return glsl_type::error_type; 360 } 361 362 if (type_a->base_type != type_b->base_type) 363 return glsl_type::error_type; 364 365 /* "The result is scalar Boolean." 366 */ 367 return glsl_type::bool_type; 368} 369 370 371/** 372 * Validates that a value can be assigned to a location with a specified type 373 * 374 * Validates that \c rhs can be assigned to some location. If the types are 375 * not an exact match but an automatic conversion is possible, \c rhs will be 376 * converted. 377 * 378 * \return 379 * \c NULL if \c rhs cannot be assigned to a location with type \c lhs_type. 380 * Otherwise the actual RHS to be assigned will be returned. This may be 381 * \c rhs, or it may be \c rhs after some type conversion. 382 * 383 * \note 384 * In addition to being used for assignments, this function is used to 385 * type-check return values. 386 */ 387ir_rvalue * 388validate_assignment(const glsl_type *lhs_type, ir_rvalue *rhs) 389{ 390 const glsl_type *const rhs_type = rhs->type; 391 392 /* If there is already some error in the RHS, just return it. Anything 393 * else will lead to an avalanche of error message back to the user. 394 */ 395 if (rhs_type->is_error()) 396 return rhs; 397 398 /* FINISHME: For GLSL 1.10, check that the types are not arrays. */ 399 400 /* If the types are identical, the assignment can trivially proceed. 401 */ 402 if (rhs_type == lhs_type) 403 return rhs; 404 405 /* FINISHME: Check for and apply automatic conversions. */ 406 return NULL; 407} 408 409ir_rvalue * 410do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state, 411 ir_rvalue *lhs, ir_rvalue *rhs, 412 YYLTYPE lhs_loc) 413{ 414 bool error_emitted = (lhs->type->is_error() || rhs->type->is_error()); 415 416 if (!error_emitted) { 417 /* FINISHME: This does not handle 'foo.bar.a.b.c[5].d = 5' */ 418 if (!lhs->is_lvalue()) { 419 _mesa_glsl_error(& lhs_loc, state, "non-lvalue in assignment"); 420 error_emitted = true; 421 } 422 } 423 424 ir_rvalue *new_rhs = validate_assignment(lhs->type, rhs); 425 if (new_rhs == NULL) { 426 _mesa_glsl_error(& lhs_loc, state, "type mismatch"); 427 } else { 428 rhs = new_rhs; 429 } 430 431 ir_instruction *tmp = new ir_assignment(lhs, rhs, NULL); 432 instructions->push_tail(tmp); 433 434 return rhs; 435} 436 437 438/** 439 * Generate a new temporary and add its declaration to the instruction stream 440 */ 441static ir_variable * 442generate_temporary(const glsl_type *type, exec_list *instructions, 443 struct _mesa_glsl_parse_state *state) 444{ 445 char *name = (char *) malloc(sizeof(char) * 13); 446 447 snprintf(name, 13, "tmp_%08X", state->temp_index); 448 state->temp_index++; 449 450 ir_variable *const var = new ir_variable(type, name); 451 instructions->push_tail(var); 452 453 return var; 454} 455 456 457static ir_rvalue * 458get_lvalue_copy(exec_list *instructions, struct _mesa_glsl_parse_state *state, 459 ir_rvalue *lvalue, YYLTYPE loc) 460{ 461 ir_variable *var; 462 ir_rvalue *var_deref; 463 464 /* FINISHME: Give unique names to the temporaries. */ 465 var = new ir_variable(lvalue->type, "_internal_tmp"); 466 var->mode = ir_var_auto; 467 468 var_deref = new ir_dereference(var); 469 do_assignment(instructions, state, var_deref, lvalue, loc); 470 471 /* Once we've created this temporary, mark it read only so it's no 472 * longer considered an lvalue. 473 */ 474 var->read_only = true; 475 476 return var_deref; 477} 478 479 480ir_rvalue * 481ast_node::hir(exec_list *instructions, 482 struct _mesa_glsl_parse_state *state) 483{ 484 (void) instructions; 485 (void) state; 486 487 return NULL; 488} 489 490 491ir_rvalue * 492ast_expression::hir(exec_list *instructions, 493 struct _mesa_glsl_parse_state *state) 494{ 495 static const int operations[AST_NUM_OPERATORS] = { 496 -1, /* ast_assign doesn't convert to ir_expression. */ 497 -1, /* ast_plus doesn't convert to ir_expression. */ 498 ir_unop_neg, 499 ir_binop_add, 500 ir_binop_sub, 501 ir_binop_mul, 502 ir_binop_div, 503 ir_binop_mod, 504 ir_binop_lshift, 505 ir_binop_rshift, 506 ir_binop_less, 507 ir_binop_greater, 508 ir_binop_lequal, 509 ir_binop_gequal, 510 ir_binop_equal, 511 ir_binop_nequal, 512 ir_binop_bit_and, 513 ir_binop_bit_xor, 514 ir_binop_bit_or, 515 ir_unop_bit_not, 516 ir_binop_logic_and, 517 ir_binop_logic_xor, 518 ir_binop_logic_or, 519 ir_unop_logic_not, 520 521 /* Note: The following block of expression types actually convert 522 * to multiple IR instructions. 523 */ 524 ir_binop_mul, /* ast_mul_assign */ 525 ir_binop_div, /* ast_div_assign */ 526 ir_binop_mod, /* ast_mod_assign */ 527 ir_binop_add, /* ast_add_assign */ 528 ir_binop_sub, /* ast_sub_assign */ 529 ir_binop_lshift, /* ast_ls_assign */ 530 ir_binop_rshift, /* ast_rs_assign */ 531 ir_binop_bit_and, /* ast_and_assign */ 532 ir_binop_bit_xor, /* ast_xor_assign */ 533 ir_binop_bit_or, /* ast_or_assign */ 534 535 -1, /* ast_conditional doesn't convert to ir_expression. */ 536 ir_binop_add, /* ast_pre_inc. */ 537 ir_binop_sub, /* ast_pre_dec. */ 538 ir_binop_add, /* ast_post_inc. */ 539 ir_binop_sub, /* ast_post_dec. */ 540 -1, /* ast_field_selection doesn't conv to ir_expression. */ 541 -1, /* ast_array_index doesn't convert to ir_expression. */ 542 -1, /* ast_function_call doesn't conv to ir_expression. */ 543 -1, /* ast_identifier doesn't convert to ir_expression. */ 544 -1, /* ast_int_constant doesn't convert to ir_expression. */ 545 -1, /* ast_uint_constant doesn't conv to ir_expression. */ 546 -1, /* ast_float_constant doesn't conv to ir_expression. */ 547 -1, /* ast_bool_constant doesn't conv to ir_expression. */ 548 -1, /* ast_sequence doesn't convert to ir_expression. */ 549 }; 550 ir_rvalue *result = NULL; 551 ir_rvalue *op[2]; 552 struct simple_node op_list; 553 const struct glsl_type *type = glsl_type::error_type; 554 bool error_emitted = false; 555 YYLTYPE loc; 556 557 loc = this->get_location(); 558 make_empty_list(& op_list); 559 560 switch (this->oper) { 561 case ast_assign: { 562 op[0] = this->subexpressions[0]->hir(instructions, state); 563 op[1] = this->subexpressions[1]->hir(instructions, state); 564 565 result = do_assignment(instructions, state, op[0], op[1], 566 this->subexpressions[0]->get_location()); 567 error_emitted = result->type->is_error(); 568 type = result->type; 569 break; 570 } 571 572 case ast_plus: 573 op[0] = this->subexpressions[0]->hir(instructions, state); 574 575 error_emitted = op[0]->type->is_error(); 576 if (type->is_error()) 577 op[0]->type = type; 578 579 result = op[0]; 580 break; 581 582 case ast_neg: 583 op[0] = this->subexpressions[0]->hir(instructions, state); 584 585 type = unary_arithmetic_result_type(op[0]->type); 586 587 error_emitted = op[0]->type->is_error(); 588 589 result = new ir_expression(operations[this->oper], type, 590 op[0], NULL); 591 break; 592 593 case ast_add: 594 case ast_sub: 595 case ast_mul: 596 case ast_div: 597 op[0] = this->subexpressions[0]->hir(instructions, state); 598 op[1] = this->subexpressions[1]->hir(instructions, state); 599 600 type = arithmetic_result_type(op[0], op[1], 601 (this->oper == ast_mul), 602 state); 603 604 result = new ir_expression(operations[this->oper], type, 605 op[0], op[1]); 606 break; 607 608 case ast_mod: 609 op[0] = this->subexpressions[0]->hir(instructions, state); 610 op[1] = this->subexpressions[1]->hir(instructions, state); 611 612 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 613 614 type = modulus_result_type(op[0]->type, op[1]->type); 615 616 assert(operations[this->oper] == ir_binop_mod); 617 618 result = new ir_expression(operations[this->oper], type, 619 op[0], op[1]); 620 break; 621 622 case ast_lshift: 623 case ast_rshift: 624 /* FINISHME: Implement bit-shift operators. */ 625 break; 626 627 case ast_less: 628 case ast_greater: 629 case ast_lequal: 630 case ast_gequal: 631 op[0] = this->subexpressions[0]->hir(instructions, state); 632 op[1] = this->subexpressions[1]->hir(instructions, state); 633 634 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 635 636 type = relational_result_type(op[0], op[1], state); 637 638 /* The relational operators must either generate an error or result 639 * in a scalar boolean. See page 57 of the GLSL 1.50 spec. 640 */ 641 assert(type->is_error() 642 || ((type->base_type == GLSL_TYPE_BOOL) 643 && type->is_scalar())); 644 645 result = new ir_expression(operations[this->oper], type, 646 op[0], op[1]); 647 break; 648 649 case ast_nequal: 650 case ast_equal: 651 op[0] = this->subexpressions[0]->hir(instructions, state); 652 op[1] = this->subexpressions[1]->hir(instructions, state); 653 654 /* From page 58 (page 64 of the PDF) of the GLSL 1.50 spec: 655 * 656 * "The equality operators equal (==), and not equal (!=) 657 * operate on all types. They result in a scalar Boolean. If 658 * the operand types do not match, then there must be a 659 * conversion from Section 4.1.10 "Implicit Conversions" 660 * applied to one operand that can make them match, in which 661 * case this conversion is done." 662 */ 663 if ((!apply_implicit_conversion(op[0]->type, op[1], state) 664 && !apply_implicit_conversion(op[1]->type, op[0], state)) 665 || (op[0]->type != op[1]->type)) { 666 _mesa_glsl_error(& loc, state, "operands of `%s' must have the same " 667 "type", (this->oper == ast_equal) ? "==" : "!="); 668 error_emitted = true; 669 } else if ((state->language_version <= 110) 670 && (op[0]->type->is_array() || op[1]->type->is_array())) { 671 _mesa_glsl_error(& loc, state, "array comparisons forbidden in " 672 "GLSL 1.10"); 673 error_emitted = true; 674 } 675 676 result = new ir_expression(operations[this->oper], glsl_type::bool_type, 677 op[0], op[1]); 678 type = glsl_type::bool_type; 679 680 assert(result->type == glsl_type::bool_type); 681 break; 682 683 case ast_bit_and: 684 case ast_bit_xor: 685 case ast_bit_or: 686 case ast_bit_not: 687 /* FINISHME: Implement bit-wise operators. */ 688 break; 689 690 case ast_logic_and: 691 case ast_logic_xor: 692 case ast_logic_or: 693 case ast_logic_not: 694 op[0] = this->subexpressions[0]->hir(instructions, state); 695 op[1] = this->subexpressions[1]->hir(instructions, state); 696 697 if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) { 698 YYLTYPE loc = this->subexpressions[0]->get_location(); 699 700 _mesa_glsl_error(& loc, state, "LHS of `%s' must be scalar boolean", 701 operator_string(this->oper)); 702 } 703 704 if (!op[1]->type->is_boolean() || !op[1]->type->is_scalar()) { 705 YYLTYPE loc = this->subexpressions[1]->get_location(); 706 707 _mesa_glsl_error(& loc, state, "RHS of `%s' must be scalar boolean", 708 operator_string(this->oper)); 709 } 710 711 result = new ir_expression(operations[this->oper], glsl_type::bool_type, 712 op[0], op[1]); 713 break; 714 715 case ast_mul_assign: 716 case ast_div_assign: 717 case ast_add_assign: 718 case ast_sub_assign: { 719 op[0] = this->subexpressions[0]->hir(instructions, state); 720 op[1] = this->subexpressions[1]->hir(instructions, state); 721 722 type = arithmetic_result_type(op[0], op[1], 723 (this->oper == ast_mul_assign), 724 state); 725 726 ir_rvalue *temp_rhs = new ir_expression(operations[this->oper], type, 727 op[0], op[1]); 728 729 result = do_assignment(instructions, state, op[0], temp_rhs, 730 this->subexpressions[0]->get_location()); 731 type = result->type; 732 error_emitted = (op[0]->type->is_error()); 733 734 /* GLSL 1.10 does not allow array assignment. However, we don't have to 735 * explicitly test for this because none of the binary expression 736 * operators allow array operands either. 737 */ 738 739 break; 740 } 741 742 case ast_mod_assign: { 743 op[0] = this->subexpressions[0]->hir(instructions, state); 744 op[1] = this->subexpressions[1]->hir(instructions, state); 745 746 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 747 748 type = modulus_result_type(op[0]->type, op[1]->type); 749 750 assert(operations[this->oper] == ir_binop_mod); 751 752 struct ir_rvalue *temp_rhs; 753 temp_rhs = new ir_expression(operations[this->oper], type, 754 op[0], op[1]); 755 756 result = do_assignment(instructions, state, op[0], temp_rhs, 757 this->subexpressions[0]->get_location()); 758 type = result->type; 759 error_emitted = op[0]->type->is_error(); 760 break; 761 } 762 763 case ast_ls_assign: 764 case ast_rs_assign: 765 break; 766 767 case ast_and_assign: 768 case ast_xor_assign: 769 case ast_or_assign: 770 break; 771 772 case ast_conditional: { 773 op[0] = this->subexpressions[0]->hir(instructions, state); 774 775 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec: 776 * 777 * "The ternary selection operator (?:). It operates on three 778 * expressions (exp1 ? exp2 : exp3). This operator evaluates the 779 * first expression, which must result in a scalar Boolean." 780 */ 781 if (!op[0]->type->is_boolean() || !op[0]->type->is_scalar()) { 782 YYLTYPE loc = this->subexpressions[0]->get_location(); 783 784 _mesa_glsl_error(& loc, state, "?: condition must be scalar boolean"); 785 error_emitted = true; 786 } 787 788 /* The :? operator is implemented by generating an anonymous temporary 789 * followed by an if-statement. The last instruction in each branch of 790 * the if-statement assigns a value to the anonymous temporary. This 791 * temporary is the r-value of the expression. 792 */ 793 ir_variable *const tmp = generate_temporary(glsl_type::error_type, 794 instructions, state); 795 796 ir_if *const stmt = new ir_if(op[0]); 797 instructions->push_tail(stmt); 798 799 op[1] = this->subexpressions[1]->hir(& stmt->then_instructions, state); 800 ir_dereference *const then_deref = new ir_dereference(tmp); 801 ir_assignment *const then_assign = 802 new ir_assignment(then_deref, op[1], NULL); 803 stmt->then_instructions.push_tail(then_assign); 804 805 op[2] = this->subexpressions[2]->hir(& stmt->else_instructions, state); 806 ir_dereference *const else_deref = new ir_dereference(tmp); 807 ir_assignment *const else_assign = 808 new ir_assignment(else_deref, op[2], NULL); 809 stmt->else_instructions.push_tail(else_assign); 810 811 /* From page 59 (page 65 of the PDF) of the GLSL 1.50 spec: 812 * 813 * "The second and third expressions can be any type, as 814 * long their types match, or there is a conversion in 815 * Section 4.1.10 "Implicit Conversions" that can be applied 816 * to one of the expressions to make their types match. This 817 * resulting matching type is the type of the entire 818 * expression." 819 */ 820 if ((!apply_implicit_conversion(op[1]->type, op[2], state) 821 && !apply_implicit_conversion(op[2]->type, op[1], state)) 822 || (op[1]->type != op[2]->type)) { 823 YYLTYPE loc = this->subexpressions[1]->get_location(); 824 825 _mesa_glsl_error(& loc, state, "Second and third operands of ?: " 826 "operator must have matching types."); 827 error_emitted = true; 828 } else { 829 tmp->type = op[1]->type; 830 } 831 832 result = new ir_dereference(tmp); 833 type = tmp->type; 834 break; 835 } 836 837 case ast_pre_inc: 838 case ast_pre_dec: { 839 op[0] = this->subexpressions[0]->hir(instructions, state); 840 if (op[0]->type->base_type == GLSL_TYPE_FLOAT) 841 op[1] = new ir_constant(1.0f); 842 else 843 op[1] = new ir_constant(1); 844 845 type = arithmetic_result_type(op[0], op[1], false, state); 846 847 struct ir_rvalue *temp_rhs; 848 temp_rhs = new ir_expression(operations[this->oper], type, 849 op[0], op[1]); 850 851 result = do_assignment(instructions, state, op[0], temp_rhs, 852 this->subexpressions[0]->get_location()); 853 type = result->type; 854 error_emitted = op[0]->type->is_error(); 855 break; 856 } 857 858 case ast_post_inc: 859 case ast_post_dec: { 860 op[0] = this->subexpressions[0]->hir(instructions, state); 861 if (op[0]->type->base_type == GLSL_TYPE_FLOAT) 862 op[1] = new ir_constant(1.0f); 863 else 864 op[1] = new ir_constant(1); 865 866 error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); 867 868 type = arithmetic_result_type(op[0], op[1], false, state); 869 870 struct ir_rvalue *temp_rhs; 871 temp_rhs = new ir_expression(operations[this->oper], type, 872 op[0], op[1]); 873 874 /* Get a temporary of a copy of the lvalue before it's modified. 875 * This may get thrown away later. 876 */ 877 result = get_lvalue_copy(instructions, state, op[0], 878 this->subexpressions[0]->get_location()); 879 880 (void)do_assignment(instructions, state, op[0], temp_rhs, 881 this->subexpressions[0]->get_location()); 882 883 type = result->type; 884 error_emitted = op[0]->type->is_error(); 885 break; 886 } 887 888 case ast_field_selection: 889 result = _mesa_ast_field_selection_to_hir(this, instructions, state); 890 type = result->type; 891 break; 892 893 case ast_array_index: 894 break; 895 896 case ast_function_call: 897 /* Should *NEVER* get here. ast_function_call should always be handled 898 * by ast_function_expression::hir. 899 */ 900 assert(0); 901 break; 902 903 case ast_identifier: { 904 /* ast_identifier can appear several places in a full abstract syntax 905 * tree. This particular use must be at location specified in the grammar 906 * as 'variable_identifier'. 907 */ 908 ir_variable *var = 909 state->symbols->get_variable(this->primary_expression.identifier); 910 911 result = new ir_dereference(var); 912 913 if (var != NULL) { 914 type = result->type; 915 } else { 916 _mesa_glsl_error(& loc, state, "`%s' undeclared", 917 this->primary_expression.identifier); 918 919 error_emitted = true; 920 } 921 break; 922 } 923 924 case ast_int_constant: 925 type = glsl_type::int_type; 926 result = new ir_constant(type, & this->primary_expression); 927 break; 928 929 case ast_uint_constant: 930 type = glsl_type::uint_type; 931 result = new ir_constant(type, & this->primary_expression); 932 break; 933 934 case ast_float_constant: 935 type = glsl_type::float_type; 936 result = new ir_constant(type, & this->primary_expression); 937 break; 938 939 case ast_bool_constant: 940 type = glsl_type::bool_type; 941 result = new ir_constant(type, & this->primary_expression); 942 break; 943 944 case ast_sequence: { 945 struct simple_node *ptr; 946 947 /* It should not be possible to generate a sequence in the AST without 948 * any expressions in it. 949 */ 950 assert(!is_empty_list(&this->expressions)); 951 952 /* The r-value of a sequence is the last expression in the sequence. If 953 * the other expressions in the sequence do not have side-effects (and 954 * therefore add instructions to the instruction list), they get dropped 955 * on the floor. 956 */ 957 foreach (ptr, &this->expressions) 958 result = ((ast_node *)ptr)->hir(instructions, state); 959 960 type = result->type; 961 962 /* Any errors should have already been emitted in the loop above. 963 */ 964 error_emitted = true; 965 break; 966 } 967 } 968 969 if (type->is_error() && !error_emitted) 970 _mesa_glsl_error(& loc, state, "type mismatch"); 971 972 return result; 973} 974 975 976ir_rvalue * 977ast_expression_statement::hir(exec_list *instructions, 978 struct _mesa_glsl_parse_state *state) 979{ 980 /* It is possible to have expression statements that don't have an 981 * expression. This is the solitary semicolon: 982 * 983 * for (i = 0; i < 5; i++) 984 * ; 985 * 986 * In this case the expression will be NULL. Test for NULL and don't do 987 * anything in that case. 988 */ 989 if (expression != NULL) 990 expression->hir(instructions, state); 991 992 /* Statements do not have r-values. 993 */ 994 return NULL; 995} 996 997 998ir_rvalue * 999ast_compound_statement::hir(exec_list *instructions, 1000 struct _mesa_glsl_parse_state *state) 1001{ 1002 struct simple_node *ptr; 1003 1004 1005 if (new_scope) 1006 state->symbols->push_scope(); 1007 1008 foreach (ptr, &statements) 1009 ((ast_node *)ptr)->hir(instructions, state); 1010 1011 if (new_scope) 1012 state->symbols->pop_scope(); 1013 1014 /* Compound statements do not have r-values. 1015 */ 1016 return NULL; 1017} 1018 1019 1020static const glsl_type * 1021process_array_type(const glsl_type *base, ast_node *array_size, 1022 struct _mesa_glsl_parse_state *state) 1023{ 1024 unsigned length = 0; 1025 1026 /* FINISHME: Reject delcarations of multidimensional arrays. */ 1027 1028 if (array_size != NULL) { 1029 exec_list dummy_instructions; 1030 ir_rvalue *const ir = array_size->hir(& dummy_instructions, state); 1031 YYLTYPE loc = array_size->get_location(); 1032 1033 /* FINISHME: Verify that the grammar forbids side-effects in array 1034 * FINISHME: sizes. i.e., 'vec4 [x = 12] data' 1035 */ 1036 assert(dummy_instructions.is_empty()); 1037 1038 if (ir != NULL) { 1039 if (!ir->type->is_integer()) { 1040 _mesa_glsl_error(& loc, state, "array size must be integer type"); 1041 } else if (!ir->type->is_scalar()) { 1042 _mesa_glsl_error(& loc, state, "array size must be scalar type"); 1043 } else { 1044 ir_constant *const size = ir->constant_expression_value(); 1045 1046 if (size == NULL) { 1047 _mesa_glsl_error(& loc, state, "array size must be a " 1048 "constant valued expression"); 1049 } else if (size->value.i[0] <= 0) { 1050 _mesa_glsl_error(& loc, state, "array size must be > 0"); 1051 } else { 1052 assert(size->type == ir->type); 1053 length = size->value.u[0]; 1054 } 1055 } 1056 } 1057 } 1058 1059 return glsl_type::get_array_instance(base, length); 1060} 1061 1062 1063const glsl_type * 1064ast_type_specifier::glsl_type(const char **name, 1065 struct _mesa_glsl_parse_state *state) const 1066{ 1067 const struct glsl_type *type; 1068 1069 if (this->type_specifier == ast_struct) { 1070 /* FINISHME: Handle annonymous structures. */ 1071 type = NULL; 1072 } else { 1073 type = state->symbols->get_type(this->type_name); 1074 *name = this->type_name; 1075 1076 if (this->is_array) { 1077 type = process_array_type(type, this->array_size, state); 1078 } 1079 } 1080 1081 return type; 1082} 1083 1084 1085static void 1086apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual, 1087 struct ir_variable *var, 1088 struct _mesa_glsl_parse_state *state, 1089 YYLTYPE *loc) 1090{ 1091 if (qual->invariant) 1092 var->invariant = 1; 1093 1094 /* FINISHME: Mark 'in' variables at global scope as read-only. */ 1095 if (qual->constant || qual->attribute || qual->uniform 1096 || (qual->varying && (state->target == fragment_shader))) 1097 var->read_only = 1; 1098 1099 if (qual->centroid) 1100 var->centroid = 1; 1101 1102 if (qual->attribute && state->target == fragment_shader) { 1103 var->type = glsl_type::error_type; 1104 _mesa_glsl_error(loc, state, 1105 "`attribute' variables may not be declared in the " 1106 "fragment shader"); 1107 } 1108 1109 if (qual->in && qual->out) 1110 var->mode = ir_var_inout; 1111 else if (qual->attribute || qual->in 1112 || (qual->varying && (state->target == fragment_shader))) 1113 var->mode = ir_var_in; 1114 else if (qual->out || (qual->varying && (state->target == vertex_shader))) 1115 var->mode = ir_var_out; 1116 else if (qual->uniform) 1117 var->mode = ir_var_uniform; 1118 else 1119 var->mode = ir_var_auto; 1120 1121 if (qual->flat) 1122 var->interpolation = ir_var_flat; 1123 else if (qual->noperspective) 1124 var->interpolation = ir_var_noperspective; 1125 else 1126 var->interpolation = ir_var_smooth; 1127} 1128 1129 1130ir_rvalue * 1131ast_declarator_list::hir(exec_list *instructions, 1132 struct _mesa_glsl_parse_state *state) 1133{ 1134 struct simple_node *ptr; 1135 const struct glsl_type *decl_type; 1136 const char *type_name = NULL; 1137 1138 1139 /* FINISHME: Handle vertex shader "invariant" declarations that do not 1140 * FINISHME: include a type. These re-declare built-in variables to be 1141 * FINISHME: invariant. 1142 */ 1143 1144 decl_type = this->type->specifier->glsl_type(& type_name, state); 1145 1146 foreach (ptr, &this->declarations) { 1147 struct ast_declaration *const decl = (struct ast_declaration * )ptr; 1148 const struct glsl_type *var_type; 1149 struct ir_variable *var; 1150 YYLTYPE loc = this->get_location(); 1151 1152 /* FINISHME: Emit a warning if a variable declaration shadows a 1153 * FINISHME: declaration at a higher scope. 1154 */ 1155 1156 if ((decl_type == NULL) || decl_type->is_void()) { 1157 if (type_name != NULL) { 1158 _mesa_glsl_error(& loc, state, 1159 "invalid type `%s' in declaration of `%s'", 1160 type_name, decl->identifier); 1161 } else { 1162 _mesa_glsl_error(& loc, state, 1163 "invalid type in declaration of `%s'", 1164 decl->identifier); 1165 } 1166 continue; 1167 } 1168 1169 if (decl->is_array) { 1170 var_type = process_array_type(decl_type, decl->array_size, state); 1171 } else { 1172 var_type = decl_type; 1173 } 1174 1175 var = new ir_variable(var_type, decl->identifier); 1176 1177 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, 1178 & loc); 1179 1180 /* Attempt to add the variable to the symbol table. If this fails, it 1181 * means the variable has already been declared at this scope. 1182 */ 1183 if (state->symbols->name_declared_this_scope(decl->identifier)) { 1184 YYLTYPE loc = this->get_location(); 1185 1186 _mesa_glsl_error(& loc, state, "`%s' redeclared", 1187 decl->identifier); 1188 continue; 1189 } 1190 1191 /* From page 15 (page 21 of the PDF) of the GLSL 1.10 spec, 1192 * 1193 * "Identifiers starting with "gl_" are reserved for use by 1194 * OpenGL, and may not be declared in a shader as either a 1195 * variable or a function." 1196 */ 1197 if (strncmp(decl->identifier, "gl_", 3) == 0) { 1198 /* FINISHME: This should only trigger if we're not redefining 1199 * FINISHME: a builtin (to add a qualifier, for example). 1200 */ 1201 _mesa_glsl_error(& loc, state, 1202 "identifier `%s' uses reserved `gl_' prefix", 1203 decl->identifier); 1204 } 1205 1206 instructions->push_tail(var); 1207 1208 if (state->current_function != NULL) { 1209 const char *mode = NULL; 1210 const char *extra = ""; 1211 1212 /* There is no need to check for 'inout' here because the parser will 1213 * only allow that in function parameter lists. 1214 */ 1215 if (this->type->qualifier.attribute) { 1216 mode = "attribute"; 1217 } else if (this->type->qualifier.uniform) { 1218 mode = "uniform"; 1219 } else if (this->type->qualifier.varying) { 1220 mode = "varying"; 1221 } else if (this->type->qualifier.in) { 1222 mode = "in"; 1223 extra = " or in function parameter list"; 1224 } else if (this->type->qualifier.out) { 1225 mode = "out"; 1226 extra = " or in function parameter list"; 1227 } 1228 1229 if (mode) { 1230 _mesa_glsl_error(& loc, state, 1231 "%s variable `%s' must be declared at " 1232 "global scope%s", 1233 mode, var->name, extra); 1234 } 1235 } else if (var->mode == ir_var_in) { 1236 if (state->target == vertex_shader) { 1237 bool error_emitted = false; 1238 1239 /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: 1240 * 1241 * "Vertex shader inputs can only be float, floating-point 1242 * vectors, matrices, signed and unsigned integers and integer 1243 * vectors. Vertex shader inputs can also form arrays of these 1244 * types, but not structures." 1245 * 1246 * From page 31 (page 27 of the PDF) of the GLSL 1.30 spec: 1247 * 1248 * "Vertex shader inputs can only be float, floating-point 1249 * vectors, matrices, signed and unsigned integers and integer 1250 * vectors. They cannot be arrays or structures." 1251 * 1252 * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec: 1253 * 1254 * "The attribute qualifier can be used only with float, 1255 * floating-point vectors, and matrices. Attribute variables 1256 * cannot be declared as arrays or structures." 1257 */ 1258 const glsl_type *check_type = var->type->is_array() 1259 ? var->type->fields.array : var->type; 1260 1261 switch (check_type->base_type) { 1262 case GLSL_TYPE_FLOAT: 1263 break; 1264 case GLSL_TYPE_UINT: 1265 case GLSL_TYPE_INT: 1266 if (state->language_version > 120) 1267 break; 1268 /* FALLTHROUGH */ 1269 default: 1270 _mesa_glsl_error(& loc, state, 1271 "vertex shader input / attribute cannot have " 1272 "type %s`%s'", 1273 var->type->is_array() ? "array of " : "", 1274 check_type->name); 1275 error_emitted = true; 1276 } 1277 1278 if (!error_emitted && (state->language_version <= 130) 1279 && var->type->is_array()) { 1280 _mesa_glsl_error(& loc, state, 1281 "vertex shader input / attribute cannot have " 1282 "array type"); 1283 error_emitted = true; 1284 } 1285 } 1286 } 1287 1288 if (decl->initializer != NULL) { 1289 YYLTYPE initializer_loc = decl->initializer->get_location(); 1290 1291 /* From page 24 (page 30 of the PDF) of the GLSL 1.10 spec: 1292 * 1293 * "All uniform variables are read-only and are initialized either 1294 * directly by an application via API commands, or indirectly by 1295 * OpenGL." 1296 */ 1297 if ((state->language_version <= 110) 1298 && (var->mode == ir_var_uniform)) { 1299 _mesa_glsl_error(& initializer_loc, state, 1300 "cannot initialize uniforms in GLSL 1.10"); 1301 } 1302 1303 if (var->type->is_sampler()) { 1304 _mesa_glsl_error(& initializer_loc, state, 1305 "cannot initialize samplers"); 1306 } 1307 1308 if ((var->mode == ir_var_in) && (state->current_function == NULL)) { 1309 _mesa_glsl_error(& initializer_loc, state, 1310 "cannot initialize %s shader input / %s", 1311 (state->target == vertex_shader) 1312 ? "vertex" : "fragment", 1313 (state->target == vertex_shader) 1314 ? "attribute" : "varying"); 1315 } 1316 1317 ir_dereference *const lhs = new ir_dereference(var); 1318 ir_rvalue *const rhs = decl->initializer->hir(instructions, state); 1319 1320 /* FINISHME: If the declaration is either 'const' or 'uniform', the 1321 * FINISHME: initializer (rhs) must be a constant expression. 1322 */ 1323 1324 if (!rhs->type->is_error()) { 1325 (void) do_assignment(instructions, state, lhs, rhs, 1326 this->get_location()); 1327 } 1328 } 1329 1330 /* From page 23 (page 29 of the PDF) of the GLSL 1.10 spec: 1331 * 1332 * "It is an error to write to a const variable outside of 1333 * its declaration, so they must be initialized when 1334 * declared." 1335 */ 1336 if (this->type->qualifier.constant && decl->initializer == NULL) { 1337 _mesa_glsl_error(& loc, state, 1338 "const declaration of `%s' must be initialized"); 1339 } 1340 1341 /* Add the vairable to the symbol table after processing the initializer. 1342 * This differs from most C-like languages, but it follows the GLSL 1343 * specification. From page 28 (page 34 of the PDF) of the GLSL 1.50 1344 * spec: 1345 * 1346 * "Within a declaration, the scope of a name starts immediately 1347 * after the initializer if present or immediately after the name 1348 * being declared if not." 1349 */ 1350 const bool added_variable = 1351 state->symbols->add_variable(decl->identifier, var); 1352 assert(added_variable); 1353 } 1354 1355 /* Variable declarations do not have r-values. 1356 */ 1357 return NULL; 1358} 1359 1360 1361ir_rvalue * 1362ast_parameter_declarator::hir(exec_list *instructions, 1363 struct _mesa_glsl_parse_state *state) 1364{ 1365 const struct glsl_type *type; 1366 const char *name = NULL; 1367 YYLTYPE loc = this->get_location(); 1368 1369 type = this->type->specifier->glsl_type(& name, state); 1370 1371 if (type == NULL) { 1372 if (name != NULL) { 1373 _mesa_glsl_error(& loc, state, 1374 "invalid type `%s' in declaration of `%s'", 1375 name, this->identifier); 1376 } else { 1377 _mesa_glsl_error(& loc, state, 1378 "invalid type in declaration of `%s'", 1379 this->identifier); 1380 } 1381 1382 type = glsl_type::error_type; 1383 } 1384 1385 ir_variable *var = new ir_variable(type, this->identifier); 1386 1387 /* FINISHME: Handle array declarations. Note that this requires 1388 * FINISHME: complete handling of constant expressions. 1389 */ 1390 1391 /* Apply any specified qualifiers to the parameter declaration. Note that 1392 * for function parameters the default mode is 'in'. 1393 */ 1394 apply_type_qualifier_to_variable(& this->type->qualifier, var, state, & loc); 1395 if (var->mode == ir_var_auto) 1396 var->mode = ir_var_in; 1397 1398 instructions->push_tail(var); 1399 1400 /* Parameter declarations do not have r-values. 1401 */ 1402 return NULL; 1403} 1404 1405 1406static void 1407ast_function_parameters_to_hir(struct simple_node *ast_parameters, 1408 exec_list *ir_parameters, 1409 struct _mesa_glsl_parse_state *state) 1410{ 1411 struct simple_node *ptr; 1412 1413 foreach (ptr, ast_parameters) { 1414 ((ast_node *)ptr)->hir(ir_parameters, state); 1415 } 1416} 1417 1418 1419static bool 1420parameter_lists_match(exec_list *list_a, exec_list *list_b) 1421{ 1422 exec_list_iterator iter_a = list_a->iterator(); 1423 exec_list_iterator iter_b = list_b->iterator(); 1424 1425 while (iter_a.has_next()) { 1426 /* If all of the parameters from the other parameter list have been 1427 * exhausted, the lists have different length and, by definition, 1428 * do not match. 1429 */ 1430 if (!iter_b.has_next()) 1431 return false; 1432 1433 /* If the types of the parameters do not match, the parameters lists 1434 * are different. 1435 */ 1436 /* FINISHME */ 1437 1438 1439 iter_a.next(); 1440 iter_b.next(); 1441 } 1442 1443 return true; 1444} 1445 1446 1447ir_rvalue * 1448ast_function_definition::hir(exec_list *instructions, 1449 struct _mesa_glsl_parse_state *state) 1450{ 1451 ir_label *label; 1452 ir_function_signature *signature = NULL; 1453 ir_function *f = NULL; 1454 exec_list parameters; 1455 1456 1457 /* Convert the list of function parameters to HIR now so that they can be 1458 * used below to compare this function's signature with previously seen 1459 * signatures for functions with the same name. 1460 */ 1461 ast_function_parameters_to_hir(& this->prototype->parameters, & parameters, 1462 state); 1463 1464 const char *return_type_name; 1465 const glsl_type *return_type = 1466 this->prototype->return_type->specifier->glsl_type(& return_type_name, 1467 state); 1468 1469 assert(return_type != NULL); 1470 1471 /* Verify that this function's signature either doesn't match a previously 1472 * seen signature for a function with the same name, or, if a match is found, 1473 * that the previously seen signature does not have an associated definition. 1474 */ 1475 const char *const name = this->prototype->identifier; 1476 f = state->symbols->get_function(name); 1477 if (f != NULL) { 1478 foreach_iter(exec_list_iterator, iter, *f) { 1479 signature = (struct ir_function_signature *) iter.get(); 1480 1481 /* Compare the parameter list of the function being defined to the 1482 * existing function. If the parameter lists match, then the return 1483 * type must also match and the existing function must not have a 1484 * definition. 1485 */ 1486 if (parameter_lists_match(& parameters, & signature->parameters)) { 1487 /* FINISHME: Compare return types. */ 1488 1489 if (signature->definition != NULL) { 1490 YYLTYPE loc = this->get_location(); 1491 1492 _mesa_glsl_error(& loc, state, "function `%s' redefined", name); 1493 signature = NULL; 1494 break; 1495 } 1496 } 1497 1498 signature = NULL; 1499 } 1500 1501 } else if (state->symbols->name_declared_this_scope(name)) { 1502 /* This function name shadows a non-function use of the same name. 1503 */ 1504 YYLTYPE loc = this->get_location(); 1505 1506 _mesa_glsl_error(& loc, state, "function name `%s' conflicts with " 1507 "non-function", name); 1508 signature = NULL; 1509 } else { 1510 f = new ir_function(name); 1511 state->symbols->add_function(f->name, f); 1512 } 1513 1514 /* Verify the return type of main() */ 1515 if (strcmp(name, "main") == 0) { 1516 if (! return_type->is_void()) { 1517 YYLTYPE loc = this->get_location(); 1518 1519 _mesa_glsl_error(& loc, state, "main() must return void"); 1520 } 1521 1522 if (!parameters.is_empty()) { 1523 YYLTYPE loc = this->get_location(); 1524 1525 _mesa_glsl_error(& loc, state, "main() must not take any parameters"); 1526 } 1527 } 1528 1529 /* Finish storing the information about this new function in its signature. 1530 */ 1531 if (signature == NULL) { 1532 signature = new ir_function_signature(return_type); 1533 f->add_signature(signature); 1534 } else { 1535 /* Destroy all of the previous parameter information. The previous 1536 * parameter information comes from the function prototype, and it can 1537 * either include invalid parameter names or may not have names at all. 1538 */ 1539 foreach_iter(exec_list_iterator, iter, signature->parameters) { 1540 assert(((ir_instruction *) iter.get())->as_variable() != NULL); 1541 1542 iter.remove(); 1543 delete iter.get(); 1544 } 1545 } 1546 1547 1548 assert(state->current_function == NULL); 1549 state->current_function = signature; 1550 1551 ast_function_parameters_to_hir(& this->prototype->parameters, 1552 & signature->parameters, 1553 state); 1554 1555 label = new ir_label(name); 1556 if (signature->definition == NULL) { 1557 signature->definition = label; 1558 } 1559 instructions->push_tail(label); 1560 1561 /* Add the function parameters to the symbol table. During this step the 1562 * parameter declarations are also moved from the temporary "parameters" list 1563 * to the instruction list. There are other more efficient ways to do this, 1564 * but they involve ugly linked-list gymnastics. 1565 */ 1566 state->symbols->push_scope(); 1567 foreach_iter(exec_list_iterator, iter, parameters) { 1568 ir_variable *const var = ((ir_instruction *) iter.get())->as_variable(); 1569 1570 assert(var != NULL); 1571 1572 iter.remove(); 1573 instructions->push_tail(var); 1574 1575 /* The only way a parameter would "exist" is if two parameters have 1576 * the same name. 1577 */ 1578 if (state->symbols->name_declared_this_scope(var->name)) { 1579 YYLTYPE loc = this->get_location(); 1580 1581 _mesa_glsl_error(& loc, state, "parameter `%s' redeclared", var->name); 1582 } else { 1583 state->symbols->add_variable(var->name, var); 1584 } 1585 } 1586 1587 /* Convert the body of the function to HIR, and append the resulting 1588 * instructions to the list that currently consists of the function label 1589 * and the function parameters. 1590 */ 1591 this->body->hir(instructions, state); 1592 1593 state->symbols->pop_scope(); 1594 1595 assert(state->current_function == signature); 1596 state->current_function = NULL; 1597 1598 /* Function definitions do not have r-values. 1599 */ 1600 return NULL; 1601} 1602 1603 1604ir_rvalue * 1605ast_jump_statement::hir(exec_list *instructions, 1606 struct _mesa_glsl_parse_state *state) 1607{ 1608 1609 if (mode == ast_return) { 1610 ir_return *inst; 1611 assert(state->current_function); 1612 1613 if (opt_return_value) { 1614 if (state->current_function->return_type->base_type == 1615 GLSL_TYPE_VOID) { 1616 YYLTYPE loc = this->get_location(); 1617 1618 _mesa_glsl_error(& loc, state, 1619 "`return` with a value, in function `%s' " 1620 "returning void", 1621 state->current_function->definition->label); 1622 } 1623 1624 ir_expression *const ret = (ir_expression *) 1625 opt_return_value->hir(instructions, state); 1626 assert(ret != NULL); 1627 1628 /* FINISHME: Make sure the type of the return value matches the return 1629 * FINISHME: type of the enclosing function. 1630 */ 1631 1632 inst = new ir_return(ret); 1633 } else { 1634 if (state->current_function->return_type->base_type != 1635 GLSL_TYPE_VOID) { 1636 YYLTYPE loc = this->get_location(); 1637 1638 _mesa_glsl_error(& loc, state, 1639 "`return' with no value, in function %s returning " 1640 "non-void", 1641 state->current_function->definition->label); 1642 } 1643 inst = new ir_return; 1644 } 1645 1646 instructions->push_tail(inst); 1647 } 1648 1649 if (mode == ast_discard) { 1650 /* FINISHME: discard support */ 1651 if (state->target != fragment_shader) { 1652 YYLTYPE loc = this->get_location(); 1653 1654 _mesa_glsl_error(& loc, state, 1655 "`discard' may only appear in a fragment shader"); 1656 } 1657 } 1658 1659 /* Jump instructions do not have r-values. 1660 */ 1661 return NULL; 1662} 1663 1664 1665ir_rvalue * 1666ast_selection_statement::hir(exec_list *instructions, 1667 struct _mesa_glsl_parse_state *state) 1668{ 1669 ir_rvalue *const condition = this->condition->hir(instructions, state); 1670 1671 /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec: 1672 * 1673 * "Any expression whose type evaluates to a Boolean can be used as the 1674 * conditional expression bool-expression. Vector types are not accepted 1675 * as the expression to if." 1676 * 1677 * The checks are separated so that higher quality diagnostics can be 1678 * generated for cases where both rules are violated. 1679 */ 1680 if (!condition->type->is_boolean() || !condition->type->is_scalar()) { 1681 YYLTYPE loc = this->condition->get_location(); 1682 1683 _mesa_glsl_error(& loc, state, "if-statement condition must be scalar " 1684 "boolean"); 1685 } 1686 1687 ir_if *const stmt = new ir_if(condition); 1688 1689 if (then_statement != NULL) { 1690 ast_node *node = (ast_node *) then_statement; 1691 do { 1692 node->hir(& stmt->then_instructions, state); 1693 node = (ast_node *) node->next; 1694 } while (node != then_statement); 1695 } 1696 1697 if (else_statement != NULL) { 1698 ast_node *node = (ast_node *) else_statement; 1699 do { 1700 node->hir(& stmt->else_instructions, state); 1701 node = (ast_node *) node->next; 1702 } while (node != else_statement); 1703 } 1704 1705 instructions->push_tail(stmt); 1706 1707 /* if-statements do not have r-values. 1708 */ 1709 return NULL; 1710} 1711