ast_function.cpp revision 6e4852a3a5f3cbe52c53d91d343a37861f207563
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#include "glsl_symbol_table.h" 25#include "ast.h" 26#include "glsl_types.h" 27#include "ir.h" 28#include "main/core.h" /* for MIN2 */ 29 30static ir_rvalue * 31convert_component(ir_rvalue *src, const glsl_type *desired_type); 32 33bool 34apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, 35 struct _mesa_glsl_parse_state *state); 36 37static unsigned 38process_parameters(exec_list *instructions, exec_list *actual_parameters, 39 exec_list *parameters, 40 struct _mesa_glsl_parse_state *state) 41{ 42 unsigned count = 0; 43 44 foreach_list (n, parameters) { 45 ast_node *const ast = exec_node_data(ast_node, n, link); 46 ir_rvalue *result = ast->hir(instructions, state); 47 48 ir_constant *const constant = result->constant_expression_value(); 49 if (constant != NULL) 50 result = constant; 51 52 actual_parameters->push_tail(result); 53 count++; 54 } 55 56 return count; 57} 58 59 60/** 61 * Generate a source prototype for a function signature 62 * 63 * \param return_type Return type of the function. May be \c NULL. 64 * \param name Name of the function. 65 * \param parameters List of \c ir_instruction nodes representing the 66 * parameter list for the function. This may be either a 67 * formal (\c ir_variable) or actual (\c ir_rvalue) 68 * parameter list. Only the type is used. 69 * 70 * \return 71 * A ralloced string representing the prototype of the function. 72 */ 73char * 74prototype_string(const glsl_type *return_type, const char *name, 75 exec_list *parameters) 76{ 77 char *str = NULL; 78 79 if (return_type != NULL) 80 str = ralloc_asprintf(NULL, "%s ", return_type->name); 81 82 ralloc_asprintf_append(&str, "%s(", name); 83 84 const char *comma = ""; 85 foreach_list(node, parameters) { 86 const ir_variable *const param = (ir_variable *) node; 87 88 ralloc_asprintf_append(&str, "%s%s", comma, param->type->name); 89 comma = ", "; 90 } 91 92 ralloc_strcat(&str, ")"); 93 return str; 94} 95 96/** 97 * Verify that 'out' and 'inout' actual parameters are lvalues. Also, verify 98 * that 'const_in' formal parameters (an extension in our IR) correspond to 99 * ir_constant actual parameters. 100 */ 101static bool 102verify_parameter_modes(_mesa_glsl_parse_state *state, 103 ir_function_signature *sig, 104 exec_list &actual_ir_parameters, 105 exec_list &actual_ast_parameters) 106{ 107 exec_node *actual_ir_node = actual_ir_parameters.head; 108 exec_node *actual_ast_node = actual_ast_parameters.head; 109 110 foreach_list(formal_node, &sig->parameters) { 111 /* The lists must be the same length. */ 112 assert(!actual_ir_node->is_tail_sentinel()); 113 assert(!actual_ast_node->is_tail_sentinel()); 114 115 const ir_variable *const formal = (ir_variable *) formal_node; 116 const ir_rvalue *const actual = (ir_rvalue *) actual_ir_node; 117 const ast_expression *const actual_ast = 118 exec_node_data(ast_expression, actual_ast_node, link); 119 120 /* FIXME: 'loc' is incorrect (as of 2011-01-21). It is always 121 * FIXME: 0:0(0). 122 */ 123 YYLTYPE loc = actual_ast->get_location(); 124 125 /* Verify that 'const_in' parameters are ir_constants. */ 126 if (formal->mode == ir_var_const_in && 127 actual->ir_type != ir_type_constant) { 128 _mesa_glsl_error(&loc, state, 129 "parameter `in %s' must be a constant expression", 130 formal->name); 131 return false; 132 } 133 134 /* Verify that 'out' and 'inout' actual parameters are lvalues. */ 135 if (formal->mode == ir_var_out || formal->mode == ir_var_inout) { 136 const char *mode = NULL; 137 switch (formal->mode) { 138 case ir_var_out: mode = "out"; break; 139 case ir_var_inout: mode = "inout"; break; 140 default: assert(false); break; 141 } 142 143 /* This AST-based check catches errors like f(i++). The IR-based 144 * is_lvalue() is insufficient because the actual parameter at the 145 * IR-level is just a temporary value, which is an l-value. 146 */ 147 if (actual_ast->non_lvalue_description != NULL) { 148 _mesa_glsl_error(&loc, state, 149 "function parameter '%s %s' references a %s", 150 mode, formal->name, 151 actual_ast->non_lvalue_description); 152 return false; 153 } 154 155 ir_variable *var = actual->variable_referenced(); 156 if (var) 157 var->assigned = true; 158 159 if (var && var->read_only) { 160 _mesa_glsl_error(&loc, state, 161 "function parameter '%s %s' references the " 162 "read-only variable '%s'", 163 mode, formal->name, 164 actual->variable_referenced()->name); 165 return false; 166 } else if (!actual->is_lvalue()) { 167 _mesa_glsl_error(&loc, state, 168 "function parameter '%s %s' is not an lvalue", 169 mode, formal->name); 170 return false; 171 } 172 } 173 174 actual_ir_node = actual_ir_node->next; 175 actual_ast_node = actual_ast_node->next; 176 } 177 return true; 178} 179 180/** 181 * If a function call is generated, \c call_ir will point to it on exit. 182 * Otherwise \c call_ir will be set to \c NULL. 183 */ 184static ir_rvalue * 185generate_call(exec_list *instructions, ir_function_signature *sig, 186 YYLTYPE *loc, exec_list *actual_parameters, 187 ir_call **call_ir, 188 struct _mesa_glsl_parse_state *state) 189{ 190 void *ctx = state; 191 exec_list post_call_conversions; 192 193 *call_ir = NULL; 194 195 /* Perform implicit conversion of arguments. For out parameters, we need 196 * to place them in a temporary variable and do the conversion after the 197 * call takes place. Since we haven't emitted the call yet, we'll place 198 * the post-call conversions in a temporary exec_list, and emit them later. 199 */ 200 exec_list_iterator actual_iter = actual_parameters->iterator(); 201 exec_list_iterator formal_iter = sig->parameters.iterator(); 202 203 while (actual_iter.has_next()) { 204 ir_rvalue *actual = (ir_rvalue *) actual_iter.get(); 205 ir_variable *formal = (ir_variable *) formal_iter.get(); 206 207 assert(actual != NULL); 208 assert(formal != NULL); 209 210 if (formal->type->is_numeric() || formal->type->is_boolean()) { 211 switch (formal->mode) { 212 case ir_var_const_in: 213 case ir_var_in: { 214 ir_rvalue *converted 215 = convert_component(actual, formal->type); 216 actual->replace_with(converted); 217 break; 218 } 219 case ir_var_out: 220 if (actual->type != formal->type) { 221 /* To convert an out parameter, we need to create a 222 * temporary variable to hold the value before conversion, 223 * and then perform the conversion after the function call 224 * returns. 225 * 226 * This has the effect of transforming code like this: 227 * 228 * void f(out int x); 229 * float value; 230 * f(value); 231 * 232 * Into IR that's equivalent to this: 233 * 234 * void f(out int x); 235 * float value; 236 * int out_parameter_conversion; 237 * f(out_parameter_conversion); 238 * value = float(out_parameter_conversion); 239 */ 240 ir_variable *tmp = 241 new(ctx) ir_variable(formal->type, 242 "out_parameter_conversion", 243 ir_var_temporary); 244 instructions->push_tail(tmp); 245 ir_dereference_variable *deref_tmp_1 246 = new(ctx) ir_dereference_variable(tmp); 247 ir_dereference_variable *deref_tmp_2 248 = new(ctx) ir_dereference_variable(tmp); 249 ir_rvalue *converted_tmp 250 = convert_component(deref_tmp_1, actual->type); 251 ir_assignment *assignment 252 = new(ctx) ir_assignment(actual, converted_tmp); 253 post_call_conversions.push_tail(assignment); 254 actual->replace_with(deref_tmp_2); 255 } 256 break; 257 case ir_var_inout: 258 /* Inout parameters should never require conversion, since that 259 * would require an implicit conversion to exist both to and 260 * from the formal parameter type, and there are no 261 * bidirectional implicit conversions. 262 */ 263 assert (actual->type == formal->type); 264 break; 265 default: 266 assert (!"Illegal formal parameter mode"); 267 break; 268 } 269 } 270 271 actual_iter.next(); 272 formal_iter.next(); 273 } 274 275 /* If the function call is a constant expression, don't generate any 276 * instructions; just generate an ir_constant. 277 * 278 * Function calls were first allowed to be constant expressions in GLSL 1.20. 279 */ 280 if (state->language_version >= 120) { 281 ir_constant *value = sig->constant_expression_value(actual_parameters, NULL); 282 if (value != NULL) { 283 return value; 284 } 285 } 286 287 ir_dereference_variable *deref = NULL; 288 if (!sig->return_type->is_void()) { 289 /* Create a new temporary to hold the return value. */ 290 ir_variable *var; 291 292 var = new(ctx) ir_variable(sig->return_type, 293 ralloc_asprintf(ctx, "%s_retval", 294 sig->function_name()), 295 ir_var_temporary); 296 instructions->push_tail(var); 297 298 deref = new(ctx) ir_dereference_variable(var); 299 } 300 ir_call *call = new(ctx) ir_call(sig, deref, actual_parameters); 301 instructions->push_tail(call); 302 303 /* Also emit any necessary out-parameter conversions. */ 304 instructions->append_list(&post_call_conversions); 305 306 return deref ? deref->clone(ctx, NULL) : NULL; 307} 308 309/** 310 * Given a function name and parameter list, find the matching signature. 311 */ 312static ir_function_signature * 313match_function_by_name(const char *name, 314 exec_list *actual_parameters, 315 struct _mesa_glsl_parse_state *state) 316{ 317 void *ctx = state; 318 ir_function *f = state->symbols->get_function(name); 319 ir_function_signature *local_sig = NULL; 320 ir_function_signature *sig = NULL; 321 322 /* Is the function hidden by a record type constructor? */ 323 if (state->symbols->get_type(name)) 324 goto done; /* no match */ 325 326 /* Is the function hidden by a variable (impossible in 1.10)? */ 327 if (state->language_version != 110 && state->symbols->get_variable(name)) 328 goto done; /* no match */ 329 330 if (f != NULL) { 331 /* Look for a match in the local shader. If exact, we're done. */ 332 bool is_exact = false; 333 sig = local_sig = f->matching_signature(actual_parameters, &is_exact); 334 if (is_exact) 335 goto done; 336 337 if (!state->es_shader && f->has_user_signature()) { 338 /* In desktop GL, the presence of a user-defined signature hides any 339 * built-in signatures, so we must ignore them. In contrast, in ES2 340 * user-defined signatures add new overloads, so we must proceed. 341 */ 342 goto done; 343 } 344 } 345 346 /* Local shader has no exact candidates; check the built-ins. */ 347 _mesa_glsl_initialize_functions(state); 348 for (unsigned i = 0; i < state->num_builtins_to_link; i++) { 349 ir_function *builtin = 350 state->builtins_to_link[i]->symbols->get_function(name); 351 if (builtin == NULL) 352 continue; 353 354 bool is_exact = false; 355 ir_function_signature *builtin_sig = 356 builtin->matching_signature(actual_parameters, &is_exact); 357 358 if (builtin_sig == NULL) 359 continue; 360 361 /* If the built-in signature is exact, we can stop. */ 362 if (is_exact) { 363 sig = builtin_sig; 364 goto done; 365 } 366 367 if (sig == NULL) { 368 /* We found an inexact match, which is better than nothing. However, 369 * we should keep searching for an exact match. 370 */ 371 sig = builtin_sig; 372 } 373 } 374 375done: 376 if (sig != NULL) { 377 /* If the match is from a linked built-in shader, import the prototype. */ 378 if (sig != local_sig) { 379 if (f == NULL) { 380 f = new(ctx) ir_function(name); 381 state->symbols->add_global_function(f); 382 emit_function(state, f); 383 } 384 f->add_signature(sig->clone_prototype(f, NULL)); 385 } 386 } 387 return sig; 388} 389 390/** 391 * Raise a "no matching function" error, listing all possible overloads the 392 * compiler considered so developers can figure out what went wrong. 393 */ 394static void 395no_matching_function_error(const char *name, 396 YYLTYPE *loc, 397 exec_list *actual_parameters, 398 _mesa_glsl_parse_state *state) 399{ 400 char *str = prototype_string(NULL, name, actual_parameters); 401 _mesa_glsl_error(loc, state, "no matching function for call to `%s'", str); 402 ralloc_free(str); 403 404 const char *prefix = "candidates are: "; 405 406 for (int i = -1; i < (int) state->num_builtins_to_link; i++) { 407 glsl_symbol_table *syms = i >= 0 ? state->builtins_to_link[i]->symbols 408 : state->symbols; 409 ir_function *f = syms->get_function(name); 410 if (f == NULL) 411 continue; 412 413 foreach_list (node, &f->signatures) { 414 ir_function_signature *sig = (ir_function_signature *) node; 415 416 str = prototype_string(sig->return_type, f->name, &sig->parameters); 417 _mesa_glsl_error(loc, state, "%s%s", prefix, str); 418 ralloc_free(str); 419 420 prefix = " "; 421 } 422 } 423} 424 425/** 426 * Perform automatic type conversion of constructor parameters 427 * 428 * This implements the rules in the "Conversion and Scalar Constructors" 429 * section (GLSL 1.10 section 5.4.1), not the "Implicit Conversions" rules. 430 */ 431static ir_rvalue * 432convert_component(ir_rvalue *src, const glsl_type *desired_type) 433{ 434 void *ctx = ralloc_parent(src); 435 const unsigned a = desired_type->base_type; 436 const unsigned b = src->type->base_type; 437 ir_expression *result = NULL; 438 439 if (src->type->is_error()) 440 return src; 441 442 assert(a <= GLSL_TYPE_BOOL); 443 assert(b <= GLSL_TYPE_BOOL); 444 445 if (a == b) 446 return src; 447 448 switch (a) { 449 case GLSL_TYPE_UINT: 450 switch (b) { 451 case GLSL_TYPE_INT: 452 result = new(ctx) ir_expression(ir_unop_i2u, src); 453 break; 454 case GLSL_TYPE_FLOAT: 455 result = new(ctx) ir_expression(ir_unop_i2u, 456 new(ctx) ir_expression(ir_unop_f2i, src)); 457 break; 458 case GLSL_TYPE_BOOL: 459 result = new(ctx) ir_expression(ir_unop_i2u, 460 new(ctx) ir_expression(ir_unop_b2i, src)); 461 break; 462 } 463 break; 464 case GLSL_TYPE_INT: 465 switch (b) { 466 case GLSL_TYPE_UINT: 467 result = new(ctx) ir_expression(ir_unop_u2i, src); 468 break; 469 case GLSL_TYPE_FLOAT: 470 result = new(ctx) ir_expression(ir_unop_f2i, src); 471 break; 472 case GLSL_TYPE_BOOL: 473 result = new(ctx) ir_expression(ir_unop_b2i, src); 474 break; 475 } 476 break; 477 case GLSL_TYPE_FLOAT: 478 switch (b) { 479 case GLSL_TYPE_UINT: 480 result = new(ctx) ir_expression(ir_unop_u2f, desired_type, src, NULL); 481 break; 482 case GLSL_TYPE_INT: 483 result = new(ctx) ir_expression(ir_unop_i2f, desired_type, src, NULL); 484 break; 485 case GLSL_TYPE_BOOL: 486 result = new(ctx) ir_expression(ir_unop_b2f, desired_type, src, NULL); 487 break; 488 } 489 break; 490 case GLSL_TYPE_BOOL: 491 switch (b) { 492 case GLSL_TYPE_UINT: 493 result = new(ctx) ir_expression(ir_unop_i2b, 494 new(ctx) ir_expression(ir_unop_u2i, src)); 495 break; 496 case GLSL_TYPE_INT: 497 result = new(ctx) ir_expression(ir_unop_i2b, desired_type, src, NULL); 498 break; 499 case GLSL_TYPE_FLOAT: 500 result = new(ctx) ir_expression(ir_unop_f2b, desired_type, src, NULL); 501 break; 502 } 503 break; 504 } 505 506 assert(result != NULL); 507 assert(result->type == desired_type); 508 509 /* Try constant folding; it may fold in the conversion we just added. */ 510 ir_constant *const constant = result->constant_expression_value(); 511 return (constant != NULL) ? (ir_rvalue *) constant : (ir_rvalue *) result; 512} 513 514/** 515 * Dereference a specific component from a scalar, vector, or matrix 516 */ 517static ir_rvalue * 518dereference_component(ir_rvalue *src, unsigned component) 519{ 520 void *ctx = ralloc_parent(src); 521 assert(component < src->type->components()); 522 523 /* If the source is a constant, just create a new constant instead of a 524 * dereference of the existing constant. 525 */ 526 ir_constant *constant = src->as_constant(); 527 if (constant) 528 return new(ctx) ir_constant(constant, component); 529 530 if (src->type->is_scalar()) { 531 return src; 532 } else if (src->type->is_vector()) { 533 return new(ctx) ir_swizzle(src, component, 0, 0, 0, 1); 534 } else { 535 assert(src->type->is_matrix()); 536 537 /* Dereference a row of the matrix, then call this function again to get 538 * a specific element from that row. 539 */ 540 const int c = component / src->type->column_type()->vector_elements; 541 const int r = component % src->type->column_type()->vector_elements; 542 ir_constant *const col_index = new(ctx) ir_constant(c); 543 ir_dereference *const col = new(ctx) ir_dereference_array(src, col_index); 544 545 col->type = src->type->column_type(); 546 547 return dereference_component(col, r); 548 } 549 550 assert(!"Should not get here."); 551 return NULL; 552} 553 554 555static ir_rvalue * 556process_array_constructor(exec_list *instructions, 557 const glsl_type *constructor_type, 558 YYLTYPE *loc, exec_list *parameters, 559 struct _mesa_glsl_parse_state *state) 560{ 561 void *ctx = state; 562 /* Array constructors come in two forms: sized and unsized. Sized array 563 * constructors look like 'vec4[2](a, b)', where 'a' and 'b' are vec4 564 * variables. In this case the number of parameters must exactly match the 565 * specified size of the array. 566 * 567 * Unsized array constructors look like 'vec4[](a, b)', where 'a' and 'b' 568 * are vec4 variables. In this case the size of the array being constructed 569 * is determined by the number of parameters. 570 * 571 * From page 52 (page 58 of the PDF) of the GLSL 1.50 spec: 572 * 573 * "There must be exactly the same number of arguments as the size of 574 * the array being constructed. If no size is present in the 575 * constructor, then the array is explicitly sized to the number of 576 * arguments provided. The arguments are assigned in order, starting at 577 * element 0, to the elements of the constructed array. Each argument 578 * must be the same type as the element type of the array, or be a type 579 * that can be converted to the element type of the array according to 580 * Section 4.1.10 "Implicit Conversions."" 581 */ 582 exec_list actual_parameters; 583 const unsigned parameter_count = 584 process_parameters(instructions, &actual_parameters, parameters, state); 585 586 if ((parameter_count == 0) 587 || ((constructor_type->length != 0) 588 && (constructor_type->length != parameter_count))) { 589 const unsigned min_param = (constructor_type->length == 0) 590 ? 1 : constructor_type->length; 591 592 _mesa_glsl_error(loc, state, "array constructor must have %s %u " 593 "parameter%s", 594 (constructor_type->length != 0) ? "at least" : "exactly", 595 min_param, (min_param <= 1) ? "" : "s"); 596 return ir_rvalue::error_value(ctx); 597 } 598 599 if (constructor_type->length == 0) { 600 constructor_type = 601 glsl_type::get_array_instance(constructor_type->element_type(), 602 parameter_count); 603 assert(constructor_type != NULL); 604 assert(constructor_type->length == parameter_count); 605 } 606 607 bool all_parameters_are_constant = true; 608 609 /* Type cast each parameter and, if possible, fold constants. */ 610 foreach_list_safe(n, &actual_parameters) { 611 ir_rvalue *ir = (ir_rvalue *) n; 612 ir_rvalue *result = ir; 613 614 /* Apply implicit conversions (not the scalar constructor rules!). See 615 * the spec quote above. */ 616 if (constructor_type->element_type()->is_float()) { 617 const glsl_type *desired_type = 618 glsl_type::get_instance(GLSL_TYPE_FLOAT, 619 ir->type->vector_elements, 620 ir->type->matrix_columns); 621 if (result->type->can_implicitly_convert_to(desired_type)) { 622 /* Even though convert_component() implements the constructor 623 * conversion rules (not the implicit conversion rules), its safe 624 * to use it here because we already checked that the implicit 625 * conversion is legal. 626 */ 627 result = convert_component(ir, desired_type); 628 } 629 } 630 631 if (result->type != constructor_type->element_type()) { 632 _mesa_glsl_error(loc, state, "type error in array constructor: " 633 "expected: %s, found %s", 634 constructor_type->element_type()->name, 635 result->type->name); 636 } 637 638 /* Attempt to convert the parameter to a constant valued expression. 639 * After doing so, track whether or not all the parameters to the 640 * constructor are trivially constant valued expressions. 641 */ 642 ir_rvalue *const constant = result->constant_expression_value(); 643 644 if (constant != NULL) 645 result = constant; 646 else 647 all_parameters_are_constant = false; 648 649 ir->replace_with(result); 650 } 651 652 if (all_parameters_are_constant) 653 return new(ctx) ir_constant(constructor_type, &actual_parameters); 654 655 ir_variable *var = new(ctx) ir_variable(constructor_type, "array_ctor", 656 ir_var_temporary); 657 instructions->push_tail(var); 658 659 int i = 0; 660 foreach_list(node, &actual_parameters) { 661 ir_rvalue *rhs = (ir_rvalue *) node; 662 ir_rvalue *lhs = new(ctx) ir_dereference_array(var, 663 new(ctx) ir_constant(i)); 664 665 ir_instruction *assignment = new(ctx) ir_assignment(lhs, rhs, NULL); 666 instructions->push_tail(assignment); 667 668 i++; 669 } 670 671 return new(ctx) ir_dereference_variable(var); 672} 673 674 675/** 676 * Try to convert a record constructor to a constant expression 677 */ 678static ir_constant * 679constant_record_constructor(const glsl_type *constructor_type, 680 exec_list *parameters, void *mem_ctx) 681{ 682 foreach_list(node, parameters) { 683 ir_constant *constant = ((ir_instruction *) node)->as_constant(); 684 if (constant == NULL) 685 return NULL; 686 node->replace_with(constant); 687 } 688 689 return new(mem_ctx) ir_constant(constructor_type, parameters); 690} 691 692 693/** 694 * Determine if a list consists of a single scalar r-value 695 */ 696bool 697single_scalar_parameter(exec_list *parameters) 698{ 699 const ir_rvalue *const p = (ir_rvalue *) parameters->head; 700 assert(((ir_rvalue *)p)->as_rvalue() != NULL); 701 702 return (p->type->is_scalar() && p->next->is_tail_sentinel()); 703} 704 705 706/** 707 * Generate inline code for a vector constructor 708 * 709 * The generated constructor code will consist of a temporary variable 710 * declaration of the same type as the constructor. A sequence of assignments 711 * from constructor parameters to the temporary will follow. 712 * 713 * \return 714 * An \c ir_dereference_variable of the temprorary generated in the constructor 715 * body. 716 */ 717ir_rvalue * 718emit_inline_vector_constructor(const glsl_type *type, 719 exec_list *instructions, 720 exec_list *parameters, 721 void *ctx) 722{ 723 assert(!parameters->is_empty()); 724 725 ir_variable *var = new(ctx) ir_variable(type, "vec_ctor", ir_var_temporary); 726 instructions->push_tail(var); 727 728 /* There are two kinds of vector constructors. 729 * 730 * - Construct a vector from a single scalar by replicating that scalar to 731 * all components of the vector. 732 * 733 * - Construct a vector from an arbirary combination of vectors and 734 * scalars. The components of the constructor parameters are assigned 735 * to the vector in order until the vector is full. 736 */ 737 const unsigned lhs_components = type->components(); 738 if (single_scalar_parameter(parameters)) { 739 ir_rvalue *first_param = (ir_rvalue *)parameters->head; 740 ir_rvalue *rhs = new(ctx) ir_swizzle(first_param, 0, 0, 0, 0, 741 lhs_components); 742 ir_dereference_variable *lhs = new(ctx) ir_dereference_variable(var); 743 const unsigned mask = (1U << lhs_components) - 1; 744 745 assert(rhs->type == lhs->type); 746 747 ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL, mask); 748 instructions->push_tail(inst); 749 } else { 750 unsigned base_component = 0; 751 unsigned base_lhs_component = 0; 752 ir_constant_data data; 753 unsigned constant_mask = 0, constant_components = 0; 754 755 memset(&data, 0, sizeof(data)); 756 757 foreach_list(node, parameters) { 758 ir_rvalue *param = (ir_rvalue *) node; 759 unsigned rhs_components = param->type->components(); 760 761 /* Do not try to assign more components to the vector than it has! 762 */ 763 if ((rhs_components + base_lhs_component) > lhs_components) { 764 rhs_components = lhs_components - base_lhs_component; 765 } 766 767 const ir_constant *const c = param->as_constant(); 768 if (c != NULL) { 769 for (unsigned i = 0; i < rhs_components; i++) { 770 switch (c->type->base_type) { 771 case GLSL_TYPE_UINT: 772 data.u[i + base_component] = c->get_uint_component(i); 773 break; 774 case GLSL_TYPE_INT: 775 data.i[i + base_component] = c->get_int_component(i); 776 break; 777 case GLSL_TYPE_FLOAT: 778 data.f[i + base_component] = c->get_float_component(i); 779 break; 780 case GLSL_TYPE_BOOL: 781 data.b[i + base_component] = c->get_bool_component(i); 782 break; 783 default: 784 assert(!"Should not get here."); 785 break; 786 } 787 } 788 789 /* Mask of fields to be written in the assignment. 790 */ 791 constant_mask |= ((1U << rhs_components) - 1) << base_lhs_component; 792 constant_components += rhs_components; 793 794 base_component += rhs_components; 795 } 796 /* Advance the component index by the number of components 797 * that were just assigned. 798 */ 799 base_lhs_component += rhs_components; 800 } 801 802 if (constant_mask != 0) { 803 ir_dereference *lhs = new(ctx) ir_dereference_variable(var); 804 const glsl_type *rhs_type = glsl_type::get_instance(var->type->base_type, 805 constant_components, 806 1); 807 ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data); 808 809 ir_instruction *inst = 810 new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask); 811 instructions->push_tail(inst); 812 } 813 814 base_component = 0; 815 foreach_list(node, parameters) { 816 ir_rvalue *param = (ir_rvalue *) node; 817 unsigned rhs_components = param->type->components(); 818 819 /* Do not try to assign more components to the vector than it has! 820 */ 821 if ((rhs_components + base_component) > lhs_components) { 822 rhs_components = lhs_components - base_component; 823 } 824 825 const ir_constant *const c = param->as_constant(); 826 if (c == NULL) { 827 /* Mask of fields to be written in the assignment. 828 */ 829 const unsigned write_mask = ((1U << rhs_components) - 1) 830 << base_component; 831 832 ir_dereference *lhs = new(ctx) ir_dereference_variable(var); 833 834 /* Generate a swizzle so that LHS and RHS sizes match. 835 */ 836 ir_rvalue *rhs = 837 new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components); 838 839 ir_instruction *inst = 840 new(ctx) ir_assignment(lhs, rhs, NULL, write_mask); 841 instructions->push_tail(inst); 842 } 843 844 /* Advance the component index by the number of components that were 845 * just assigned. 846 */ 847 base_component += rhs_components; 848 } 849 } 850 return new(ctx) ir_dereference_variable(var); 851} 852 853 854/** 855 * Generate assignment of a portion of a vector to a portion of a matrix column 856 * 857 * \param src_base First component of the source to be used in assignment 858 * \param column Column of destination to be assiged 859 * \param row_base First component of the destination column to be assigned 860 * \param count Number of components to be assigned 861 * 862 * \note 863 * \c src_base + \c count must be less than or equal to the number of components 864 * in the source vector. 865 */ 866ir_instruction * 867assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base, 868 ir_rvalue *src, unsigned src_base, unsigned count, 869 void *mem_ctx) 870{ 871 ir_constant *col_idx = new(mem_ctx) ir_constant(column); 872 ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var, col_idx); 873 874 assert(column_ref->type->components() >= (row_base + count)); 875 assert(src->type->components() >= (src_base + count)); 876 877 /* Generate a swizzle that extracts the number of components from the source 878 * that are to be assigned to the column of the matrix. 879 */ 880 if (count < src->type->vector_elements) { 881 src = new(mem_ctx) ir_swizzle(src, 882 src_base + 0, src_base + 1, 883 src_base + 2, src_base + 3, 884 count); 885 } 886 887 /* Mask of fields to be written in the assignment. 888 */ 889 const unsigned write_mask = ((1U << count) - 1) << row_base; 890 891 return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask); 892} 893 894 895/** 896 * Generate inline code for a matrix constructor 897 * 898 * The generated constructor code will consist of a temporary variable 899 * declaration of the same type as the constructor. A sequence of assignments 900 * from constructor parameters to the temporary will follow. 901 * 902 * \return 903 * An \c ir_dereference_variable of the temprorary generated in the constructor 904 * body. 905 */ 906ir_rvalue * 907emit_inline_matrix_constructor(const glsl_type *type, 908 exec_list *instructions, 909 exec_list *parameters, 910 void *ctx) 911{ 912 assert(!parameters->is_empty()); 913 914 ir_variable *var = new(ctx) ir_variable(type, "mat_ctor", ir_var_temporary); 915 instructions->push_tail(var); 916 917 /* There are three kinds of matrix constructors. 918 * 919 * - Construct a matrix from a single scalar by replicating that scalar to 920 * along the diagonal of the matrix and setting all other components to 921 * zero. 922 * 923 * - Construct a matrix from an arbirary combination of vectors and 924 * scalars. The components of the constructor parameters are assigned 925 * to the matrix in colum-major order until the matrix is full. 926 * 927 * - Construct a matrix from a single matrix. The source matrix is copied 928 * to the upper left portion of the constructed matrix, and the remaining 929 * elements take values from the identity matrix. 930 */ 931 ir_rvalue *const first_param = (ir_rvalue *) parameters->head; 932 if (single_scalar_parameter(parameters)) { 933 /* Assign the scalar to the X component of a vec4, and fill the remaining 934 * components with zero. 935 */ 936 ir_variable *rhs_var = 937 new(ctx) ir_variable(glsl_type::vec4_type, "mat_ctor_vec", 938 ir_var_temporary); 939 instructions->push_tail(rhs_var); 940 941 ir_constant_data zero; 942 zero.f[0] = 0.0; 943 zero.f[1] = 0.0; 944 zero.f[2] = 0.0; 945 zero.f[3] = 0.0; 946 947 ir_instruction *inst = 948 new(ctx) ir_assignment(new(ctx) ir_dereference_variable(rhs_var), 949 new(ctx) ir_constant(rhs_var->type, &zero), 950 NULL); 951 instructions->push_tail(inst); 952 953 ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var); 954 955 inst = new(ctx) ir_assignment(rhs_ref, first_param, NULL, 0x01); 956 instructions->push_tail(inst); 957 958 /* Assign the temporary vector to each column of the destination matrix 959 * with a swizzle that puts the X component on the diagonal of the 960 * matrix. In some cases this may mean that the X component does not 961 * get assigned into the column at all (i.e., when the matrix has more 962 * columns than rows). 963 */ 964 static const unsigned rhs_swiz[4][4] = { 965 { 0, 1, 1, 1 }, 966 { 1, 0, 1, 1 }, 967 { 1, 1, 0, 1 }, 968 { 1, 1, 1, 0 } 969 }; 970 971 const unsigned cols_to_init = MIN2(type->matrix_columns, 972 type->vector_elements); 973 for (unsigned i = 0; i < cols_to_init; i++) { 974 ir_constant *const col_idx = new(ctx) ir_constant(i); 975 ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx); 976 977 ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var); 978 ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, rhs_swiz[i], 979 type->vector_elements); 980 981 inst = new(ctx) ir_assignment(col_ref, rhs, NULL); 982 instructions->push_tail(inst); 983 } 984 985 for (unsigned i = cols_to_init; i < type->matrix_columns; i++) { 986 ir_constant *const col_idx = new(ctx) ir_constant(i); 987 ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx); 988 989 ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var); 990 ir_rvalue *const rhs = new(ctx) ir_swizzle(rhs_ref, 1, 1, 1, 1, 991 type->vector_elements); 992 993 inst = new(ctx) ir_assignment(col_ref, rhs, NULL); 994 instructions->push_tail(inst); 995 } 996 } else if (first_param->type->is_matrix()) { 997 /* From page 50 (56 of the PDF) of the GLSL 1.50 spec: 998 * 999 * "If a matrix is constructed from a matrix, then each component 1000 * (column i, row j) in the result that has a corresponding 1001 * component (column i, row j) in the argument will be initialized 1002 * from there. All other components will be initialized to the 1003 * identity matrix. If a matrix argument is given to a matrix 1004 * constructor, it is an error to have any other arguments." 1005 */ 1006 assert(first_param->next->is_tail_sentinel()); 1007 ir_rvalue *const src_matrix = first_param; 1008 1009 /* If the source matrix is smaller, pre-initialize the relavent parts of 1010 * the destination matrix to the identity matrix. 1011 */ 1012 if ((src_matrix->type->matrix_columns < var->type->matrix_columns) 1013 || (src_matrix->type->vector_elements < var->type->vector_elements)) { 1014 1015 /* If the source matrix has fewer rows, every column of the destination 1016 * must be initialized. Otherwise only the columns in the destination 1017 * that do not exist in the source must be initialized. 1018 */ 1019 unsigned col = 1020 (src_matrix->type->vector_elements < var->type->vector_elements) 1021 ? 0 : src_matrix->type->matrix_columns; 1022 1023 const glsl_type *const col_type = var->type->column_type(); 1024 for (/* empty */; col < var->type->matrix_columns; col++) { 1025 ir_constant_data ident; 1026 1027 ident.f[0] = 0.0; 1028 ident.f[1] = 0.0; 1029 ident.f[2] = 0.0; 1030 ident.f[3] = 0.0; 1031 1032 ident.f[col] = 1.0; 1033 1034 ir_rvalue *const rhs = new(ctx) ir_constant(col_type, &ident); 1035 1036 ir_rvalue *const lhs = 1037 new(ctx) ir_dereference_array(var, new(ctx) ir_constant(col)); 1038 1039 ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL); 1040 instructions->push_tail(inst); 1041 } 1042 } 1043 1044 /* Assign columns from the source matrix to the destination matrix. 1045 * 1046 * Since the parameter will be used in the RHS of multiple assignments, 1047 * generate a temporary and copy the paramter there. 1048 */ 1049 ir_variable *const rhs_var = 1050 new(ctx) ir_variable(first_param->type, "mat_ctor_mat", 1051 ir_var_temporary); 1052 instructions->push_tail(rhs_var); 1053 1054 ir_dereference *const rhs_var_ref = 1055 new(ctx) ir_dereference_variable(rhs_var); 1056 ir_instruction *const inst = 1057 new(ctx) ir_assignment(rhs_var_ref, first_param, NULL); 1058 instructions->push_tail(inst); 1059 1060 const unsigned last_row = MIN2(src_matrix->type->vector_elements, 1061 var->type->vector_elements); 1062 const unsigned last_col = MIN2(src_matrix->type->matrix_columns, 1063 var->type->matrix_columns); 1064 1065 unsigned swiz[4] = { 0, 0, 0, 0 }; 1066 for (unsigned i = 1; i < last_row; i++) 1067 swiz[i] = i; 1068 1069 const unsigned write_mask = (1U << last_row) - 1; 1070 1071 for (unsigned i = 0; i < last_col; i++) { 1072 ir_dereference *const lhs = 1073 new(ctx) ir_dereference_array(var, new(ctx) ir_constant(i)); 1074 ir_rvalue *const rhs_col = 1075 new(ctx) ir_dereference_array(rhs_var, new(ctx) ir_constant(i)); 1076 1077 /* If one matrix has columns that are smaller than the columns of the 1078 * other matrix, wrap the column access of the larger with a swizzle 1079 * so that the LHS and RHS of the assignment have the same size (and 1080 * therefore have the same type). 1081 * 1082 * It would be perfectly valid to unconditionally generate the 1083 * swizzles, this this will typically result in a more compact IR tree. 1084 */ 1085 ir_rvalue *rhs; 1086 if (lhs->type->vector_elements != rhs_col->type->vector_elements) { 1087 rhs = new(ctx) ir_swizzle(rhs_col, swiz, last_row); 1088 } else { 1089 rhs = rhs_col; 1090 } 1091 1092 ir_instruction *inst = 1093 new(ctx) ir_assignment(lhs, rhs, NULL, write_mask); 1094 instructions->push_tail(inst); 1095 } 1096 } else { 1097 const unsigned cols = type->matrix_columns; 1098 const unsigned rows = type->vector_elements; 1099 unsigned col_idx = 0; 1100 unsigned row_idx = 0; 1101 1102 foreach_list (node, parameters) { 1103 ir_rvalue *const rhs = (ir_rvalue *) node; 1104 const unsigned components_remaining_this_column = rows - row_idx; 1105 unsigned rhs_components = rhs->type->components(); 1106 unsigned rhs_base = 0; 1107 1108 /* Since the parameter might be used in the RHS of two assignments, 1109 * generate a temporary and copy the paramter there. 1110 */ 1111 ir_variable *rhs_var = 1112 new(ctx) ir_variable(rhs->type, "mat_ctor_vec", ir_var_temporary); 1113 instructions->push_tail(rhs_var); 1114 1115 ir_dereference *rhs_var_ref = 1116 new(ctx) ir_dereference_variable(rhs_var); 1117 ir_instruction *inst = new(ctx) ir_assignment(rhs_var_ref, rhs, NULL); 1118 instructions->push_tail(inst); 1119 1120 /* Assign the current parameter to as many components of the matrix 1121 * as it will fill. 1122 * 1123 * NOTE: A single vector parameter can span two matrix columns. A 1124 * single vec4, for example, can completely fill a mat2. 1125 */ 1126 if (rhs_components >= components_remaining_this_column) { 1127 const unsigned count = MIN2(rhs_components, 1128 components_remaining_this_column); 1129 1130 rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var); 1131 1132 ir_instruction *inst = assign_to_matrix_column(var, col_idx, 1133 row_idx, 1134 rhs_var_ref, 0, 1135 count, ctx); 1136 instructions->push_tail(inst); 1137 1138 rhs_base = count; 1139 1140 col_idx++; 1141 row_idx = 0; 1142 } 1143 1144 /* If there is data left in the parameter and components left to be 1145 * set in the destination, emit another assignment. It is possible 1146 * that the assignment could be of a vec4 to the last element of the 1147 * matrix. In this case col_idx==cols, but there is still data 1148 * left in the source parameter. Obviously, don't emit an assignment 1149 * to data outside the destination matrix. 1150 */ 1151 if ((col_idx < cols) && (rhs_base < rhs_components)) { 1152 const unsigned count = rhs_components - rhs_base; 1153 1154 rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var); 1155 1156 ir_instruction *inst = assign_to_matrix_column(var, col_idx, 1157 row_idx, 1158 rhs_var_ref, 1159 rhs_base, 1160 count, ctx); 1161 instructions->push_tail(inst); 1162 1163 row_idx += count; 1164 } 1165 } 1166 } 1167 1168 return new(ctx) ir_dereference_variable(var); 1169} 1170 1171 1172ir_rvalue * 1173emit_inline_record_constructor(const glsl_type *type, 1174 exec_list *instructions, 1175 exec_list *parameters, 1176 void *mem_ctx) 1177{ 1178 ir_variable *const var = 1179 new(mem_ctx) ir_variable(type, "record_ctor", ir_var_temporary); 1180 ir_dereference_variable *const d = new(mem_ctx) ir_dereference_variable(var); 1181 1182 instructions->push_tail(var); 1183 1184 exec_node *node = parameters->head; 1185 for (unsigned i = 0; i < type->length; i++) { 1186 assert(!node->is_tail_sentinel()); 1187 1188 ir_dereference *const lhs = 1189 new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL), 1190 type->fields.structure[i].name); 1191 1192 ir_rvalue *const rhs = ((ir_instruction *) node)->as_rvalue(); 1193 assert(rhs != NULL); 1194 1195 ir_instruction *const assign = new(mem_ctx) ir_assignment(lhs, rhs, NULL); 1196 1197 instructions->push_tail(assign); 1198 node = node->next; 1199 } 1200 1201 return d; 1202} 1203 1204 1205ir_rvalue * 1206ast_function_expression::hir(exec_list *instructions, 1207 struct _mesa_glsl_parse_state *state) 1208{ 1209 void *ctx = state; 1210 /* There are three sorts of function calls. 1211 * 1212 * 1. constructors - The first subexpression is an ast_type_specifier. 1213 * 2. methods - Only the .length() method of array types. 1214 * 3. functions - Calls to regular old functions. 1215 * 1216 * Method calls are actually detected when the ast_field_selection 1217 * expression is handled. 1218 */ 1219 if (is_constructor()) { 1220 const ast_type_specifier *type = (ast_type_specifier *) subexpressions[0]; 1221 YYLTYPE loc = type->get_location(); 1222 const char *name; 1223 1224 const glsl_type *const constructor_type = type->glsl_type(& name, state); 1225 1226 /* constructor_type can be NULL if a variable with the same name as the 1227 * structure has come into scope. 1228 */ 1229 if (constructor_type == NULL) { 1230 _mesa_glsl_error(& loc, state, "unknown type `%s' (structure name " 1231 "may be shadowed by a variable with the same name)", 1232 type->type_name); 1233 return ir_rvalue::error_value(ctx); 1234 } 1235 1236 1237 /* Constructors for samplers are illegal. 1238 */ 1239 if (constructor_type->is_sampler()) { 1240 _mesa_glsl_error(& loc, state, "cannot construct sampler type `%s'", 1241 constructor_type->name); 1242 return ir_rvalue::error_value(ctx); 1243 } 1244 1245 if (constructor_type->is_array()) { 1246 if (state->language_version <= 110) { 1247 _mesa_glsl_error(& loc, state, 1248 "array constructors forbidden in GLSL 1.10"); 1249 return ir_rvalue::error_value(ctx); 1250 } 1251 1252 return process_array_constructor(instructions, constructor_type, 1253 & loc, &this->expressions, state); 1254 } 1255 1256 1257 /* There are two kinds of constructor call. Constructors for built-in 1258 * language types, such as mat4 and vec2, are free form. The only 1259 * requirement is that the parameters must provide enough values of the 1260 * correct scalar type. Constructors for arrays and structures must 1261 * have the exact number of parameters with matching types in the 1262 * correct order. These constructors follow essentially the same type 1263 * matching rules as functions. 1264 */ 1265 if (constructor_type->is_record()) { 1266 exec_list actual_parameters; 1267 1268 process_parameters(instructions, &actual_parameters, 1269 &this->expressions, state); 1270 1271 exec_node *node = actual_parameters.head; 1272 for (unsigned i = 0; i < constructor_type->length; i++) { 1273 ir_rvalue *ir = (ir_rvalue *) node; 1274 1275 if (node->is_tail_sentinel()) { 1276 _mesa_glsl_error(&loc, state, 1277 "insufficient parameters to constructor " 1278 "for `%s'", 1279 constructor_type->name); 1280 return ir_rvalue::error_value(ctx); 1281 } 1282 1283 if (apply_implicit_conversion(constructor_type->fields.structure[i].type, 1284 ir, state)) { 1285 node->replace_with(ir); 1286 } else { 1287 _mesa_glsl_error(&loc, state, 1288 "parameter type mismatch in constructor " 1289 "for `%s.%s' (%s vs %s)", 1290 constructor_type->name, 1291 constructor_type->fields.structure[i].name, 1292 ir->type->name, 1293 constructor_type->fields.structure[i].type->name); 1294 return ir_rvalue::error_value(ctx);; 1295 } 1296 1297 node = node->next; 1298 } 1299 1300 if (!node->is_tail_sentinel()) { 1301 _mesa_glsl_error(&loc, state, "too many parameters in constructor " 1302 "for `%s'", constructor_type->name); 1303 return ir_rvalue::error_value(ctx); 1304 } 1305 1306 ir_rvalue *const constant = 1307 constant_record_constructor(constructor_type, &actual_parameters, 1308 state); 1309 1310 return (constant != NULL) 1311 ? constant 1312 : emit_inline_record_constructor(constructor_type, instructions, 1313 &actual_parameters, state); 1314 } 1315 1316 if (!constructor_type->is_numeric() && !constructor_type->is_boolean()) 1317 return ir_rvalue::error_value(ctx); 1318 1319 /* Total number of components of the type being constructed. */ 1320 const unsigned type_components = constructor_type->components(); 1321 1322 /* Number of components from parameters that have actually been 1323 * consumed. This is used to perform several kinds of error checking. 1324 */ 1325 unsigned components_used = 0; 1326 1327 unsigned matrix_parameters = 0; 1328 unsigned nonmatrix_parameters = 0; 1329 exec_list actual_parameters; 1330 1331 foreach_list (n, &this->expressions) { 1332 ast_node *ast = exec_node_data(ast_node, n, link); 1333 ir_rvalue *result = ast->hir(instructions, state)->as_rvalue(); 1334 1335 /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec: 1336 * 1337 * "It is an error to provide extra arguments beyond this 1338 * last used argument." 1339 */ 1340 if (components_used >= type_components) { 1341 _mesa_glsl_error(& loc, state, "too many parameters to `%s' " 1342 "constructor", 1343 constructor_type->name); 1344 return ir_rvalue::error_value(ctx); 1345 } 1346 1347 if (!result->type->is_numeric() && !result->type->is_boolean()) { 1348 _mesa_glsl_error(& loc, state, "cannot construct `%s' from a " 1349 "non-numeric data type", 1350 constructor_type->name); 1351 return ir_rvalue::error_value(ctx); 1352 } 1353 1354 /* Count the number of matrix and nonmatrix parameters. This 1355 * is used below to enforce some of the constructor rules. 1356 */ 1357 if (result->type->is_matrix()) 1358 matrix_parameters++; 1359 else 1360 nonmatrix_parameters++; 1361 1362 actual_parameters.push_tail(result); 1363 components_used += result->type->components(); 1364 } 1365 1366 /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec: 1367 * 1368 * "It is an error to construct matrices from other matrices. This 1369 * is reserved for future use." 1370 */ 1371 if (state->language_version == 110 && matrix_parameters > 0 1372 && constructor_type->is_matrix()) { 1373 _mesa_glsl_error(& loc, state, "cannot construct `%s' from a " 1374 "matrix in GLSL 1.10", 1375 constructor_type->name); 1376 return ir_rvalue::error_value(ctx); 1377 } 1378 1379 /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec: 1380 * 1381 * "If a matrix argument is given to a matrix constructor, it is 1382 * an error to have any other arguments." 1383 */ 1384 if ((matrix_parameters > 0) 1385 && ((matrix_parameters + nonmatrix_parameters) > 1) 1386 && constructor_type->is_matrix()) { 1387 _mesa_glsl_error(& loc, state, "for matrix `%s' constructor, " 1388 "matrix must be only parameter", 1389 constructor_type->name); 1390 return ir_rvalue::error_value(ctx); 1391 } 1392 1393 /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec: 1394 * 1395 * "In these cases, there must be enough components provided in the 1396 * arguments to provide an initializer for every component in the 1397 * constructed value." 1398 */ 1399 if (components_used < type_components && components_used != 1 1400 && matrix_parameters == 0) { 1401 _mesa_glsl_error(& loc, state, "too few components to construct " 1402 "`%s'", 1403 constructor_type->name); 1404 return ir_rvalue::error_value(ctx); 1405 } 1406 1407 /* Later, we cast each parameter to the same base type as the 1408 * constructor. Since there are no non-floating point matrices, we 1409 * need to break them up into a series of column vectors. 1410 */ 1411 if (constructor_type->base_type != GLSL_TYPE_FLOAT) { 1412 foreach_list_safe(n, &actual_parameters) { 1413 ir_rvalue *matrix = (ir_rvalue *) n; 1414 1415 if (!matrix->type->is_matrix()) 1416 continue; 1417 1418 /* Create a temporary containing the matrix. */ 1419 ir_variable *var = new(ctx) ir_variable(matrix->type, "matrix_tmp", 1420 ir_var_temporary); 1421 instructions->push_tail(var); 1422 instructions->push_tail(new(ctx) ir_assignment(new(ctx) 1423 ir_dereference_variable(var), matrix, NULL)); 1424 var->constant_value = matrix->constant_expression_value(); 1425 1426 /* Replace the matrix with dereferences of its columns. */ 1427 for (int i = 0; i < matrix->type->matrix_columns; i++) { 1428 matrix->insert_before(new (ctx) ir_dereference_array(var, 1429 new(ctx) ir_constant(i))); 1430 } 1431 matrix->remove(); 1432 } 1433 } 1434 1435 bool all_parameters_are_constant = true; 1436 1437 /* Type cast each parameter and, if possible, fold constants.*/ 1438 foreach_list_safe(n, &actual_parameters) { 1439 ir_rvalue *ir = (ir_rvalue *) n; 1440 1441 const glsl_type *desired_type = 1442 glsl_type::get_instance(constructor_type->base_type, 1443 ir->type->vector_elements, 1444 ir->type->matrix_columns); 1445 ir_rvalue *result = convert_component(ir, desired_type); 1446 1447 /* Attempt to convert the parameter to a constant valued expression. 1448 * After doing so, track whether or not all the parameters to the 1449 * constructor are trivially constant valued expressions. 1450 */ 1451 ir_rvalue *const constant = result->constant_expression_value(); 1452 1453 if (constant != NULL) 1454 result = constant; 1455 else 1456 all_parameters_are_constant = false; 1457 1458 if (result != ir) { 1459 ir->replace_with(result); 1460 } 1461 } 1462 1463 /* If all of the parameters are trivially constant, create a 1464 * constant representing the complete collection of parameters. 1465 */ 1466 if (all_parameters_are_constant) { 1467 return new(ctx) ir_constant(constructor_type, &actual_parameters); 1468 } else if (constructor_type->is_scalar()) { 1469 return dereference_component((ir_rvalue *) actual_parameters.head, 1470 0); 1471 } else if (constructor_type->is_vector()) { 1472 return emit_inline_vector_constructor(constructor_type, 1473 instructions, 1474 &actual_parameters, 1475 ctx); 1476 } else { 1477 assert(constructor_type->is_matrix()); 1478 return emit_inline_matrix_constructor(constructor_type, 1479 instructions, 1480 &actual_parameters, 1481 ctx); 1482 } 1483 } else { 1484 const ast_expression *id = subexpressions[0]; 1485 const char *func_name = id->primary_expression.identifier; 1486 YYLTYPE loc = id->get_location(); 1487 exec_list actual_parameters; 1488 1489 process_parameters(instructions, &actual_parameters, &this->expressions, 1490 state); 1491 1492 ir_function_signature *sig = 1493 match_function_by_name(func_name, &actual_parameters, state); 1494 1495 ir_call *call = NULL; 1496 ir_rvalue *value = NULL; 1497 if (sig == NULL) { 1498 no_matching_function_error(func_name, &loc, &actual_parameters, state); 1499 value = ir_rvalue::error_value(ctx); 1500 } else if (!verify_parameter_modes(state, sig, actual_parameters, this->expressions)) { 1501 /* an error has already been emitted */ 1502 value = ir_rvalue::error_value(ctx); 1503 } else { 1504 value = generate_call(instructions, sig, &loc, &actual_parameters, 1505 &call, state); 1506 } 1507 1508 return value; 1509 } 1510 1511 return ir_rvalue::error_value(ctx); 1512} 1513