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