src/glsl/ast_function.cpp

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