X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fast_function.cpp;h=6ecf779c935abaf7a8ef7741f7ae5387f30b6a59;hb=36a59b29ef07b78378dcb3934131d262d42612cb;hp=1122521e0dc31227d9019ee85f54e177ea364b10;hpb=0048c7aef82b17c6bd160f49125a91a70cbf2b55;p=mesa.git

diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp
index 1122521e0dc..6ecf779c935 100644
--- a/src/glsl/ast_function.cpp
+++ b/src/glsl/ast_function.cpp
@@ -25,15 +25,15 @@
 #include "ast.h"
 #include "glsl_types.h"
 #include "ir.h"
-
-inline unsigned min(unsigned a, unsigned b)
-{
-   return (a < b) ? a : b;
-}
+#include "main/core.h" /* for MIN2 */
 
 static ir_rvalue *
 convert_component(ir_rvalue *src, const glsl_type *desired_type);
 
+bool
+apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from,
+                          struct _mesa_glsl_parse_state *state);
+
 static unsigned
 process_parameters(exec_list *instructions, exec_list *actual_parameters,
 		   exec_list *parameters,
@@ -57,17 +57,76 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters,
 }
 
 
+/**
+ * Generate a source prototype for a function signature
+ *
+ * \param return_type Return type of the function.  May be \c NULL.
+ * \param name        Name of the function.
+ * \param parameters  Parameter list for the function.  This may be either a
+ *                    formal or actual parameter list.  Only the type is used.
+ *
+ * \return
+ * A talloced string representing the prototype of the function.
+ */
+char *
+prototype_string(const glsl_type *return_type, const char *name,
+		 exec_list *parameters)
+{
+   char *str = NULL;
+
+   if (return_type != NULL)
+      str = talloc_asprintf(str, "%s ", return_type->name);
+
+   str = talloc_asprintf_append(str, "%s(", name);
+
+   const char *comma = "";
+   foreach_list(node, parameters) {
+      const ir_instruction *const param = (ir_instruction *) node;
+
+      str = talloc_asprintf_append(str, "%s%s", comma, param->type->name);
+      comma = ", ";
+   }
+
+   str = talloc_strdup_append(str, ")");
+   return str;
+}
+
+
 static ir_rvalue *
-process_call(exec_list *instructions, ir_function *f,
-	     YYLTYPE *loc, exec_list *actual_parameters,
-	     struct _mesa_glsl_parse_state *state)
+match_function_by_name(exec_list *instructions, const char *name,
+		       YYLTYPE *loc, exec_list *actual_parameters,
+		       struct _mesa_glsl_parse_state *state)
 {
    void *ctx = state;
+   ir_function *f = state->symbols->get_function(name);
+   ir_function_signature *sig;
+
+   sig = f ? f->matching_signature(actual_parameters) : NULL;
 
-   ir_function_signature *sig = f->matching_signature(actual_parameters);
+   /* FINISHME: This doesn't handle the case where shader X contains a
+    * FINISHME: matching signature but shader X + N contains an _exact_
+    * FINISHME: matching signature.
+    */
+   if (sig == NULL && (f == NULL || state->es_shader || !f->has_user_signature()) && state->symbols->get_type(name) == NULL && (state->language_version == 110 || state->symbols->get_variable(name) == NULL)) {
+      /* The current shader doesn't contain a matching function or signature.
+       * Before giving up, look for the prototype in the built-in functions.
+       */
+      for (unsigned i = 0; i < state->num_builtins_to_link; i++) {
+	 ir_function *builtin;
+	 builtin = state->builtins_to_link[i]->symbols->get_function(name);
+	 sig = builtin ? builtin->matching_signature(actual_parameters) : NULL;
+	 if (sig != NULL) {
+	    if (f == NULL) {
+	       f = new(ctx) ir_function(name);
+	       state->symbols->add_global_function(f);
+	       emit_function(state, instructions, f);
+	    }
 
-   /* The instructions param will be used when the FINISHMEs below are done */
-   (void) instructions;
+	    f->add_signature(sig->clone_prototype(f, NULL));
+	    break;
+	 }
+      }
+   }
 
    if (sig != NULL) {
       /* Verify that 'out' and 'inout' actual parameters are lvalues.  This
@@ -122,6 +181,8 @@ process_call(exec_list *instructions, ir_function *f,
 	 deref = new(ctx) ir_dereference_variable(var);
 	 ir_assignment *assign = new(ctx) ir_assignment(deref, call, NULL);
 	 instructions->push_tail(assign);
+	 if (state->language_version >= 120)
+	    var->constant_value = call->constant_expression_value();
 
 	 deref = new(ctx) ir_dereference_variable(var);
 	 return deref;
@@ -130,35 +191,35 @@ process_call(exec_list *instructions, ir_function *f,
 	 return NULL;
       }
    } else {
-      /* FINISHME: Log a better error message here.  G++ will show the types
-       * FINISHME: of the actual parameters and the set of candidate
-       * FINISHME: functions.  A different error should also be logged when
-       * FINISHME: multiple functions match.
-       */
+      char *str = prototype_string(NULL, name, actual_parameters);
+
       _mesa_glsl_error(loc, state, "no matching function for call to `%s'",
-		       f->name);
-      return ir_call::get_error_instruction(ctx);
-   }
-}
+		       str);
+      talloc_free(str);
 
+      const char *prefix = "candidates are: ";
 
-static ir_rvalue *
-match_function_by_name(exec_list *instructions, const char *name,
-		       YYLTYPE *loc, exec_list *actual_parameters,
-		       struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
-   ir_function *f = state->symbols->get_function(name);
+      for (int i = -1; i < state->num_builtins_to_link; i++) {
+	 glsl_symbol_table *syms = i >= 0 ? state->builtins_to_link[i]->symbols
+					  : state->symbols;
+	 f = syms->get_function(name);
+	 if (f == NULL)
+	    continue;
+
+	 foreach_list (node, &f->signatures) {
+	    ir_function_signature *sig = (ir_function_signature *) node;
+
+	    str = prototype_string(sig->return_type, f->name, &sig->parameters);
+	    _mesa_glsl_error(loc, state, "%s%s\n", prefix, str);
+	    talloc_free(str);
+
+	    prefix = "                ";
+	 }
+
+      }
 
-   if (f == NULL) {
-      _mesa_glsl_error(loc, state, "function `%s' undeclared", name);
       return ir_call::get_error_instruction(ctx);
    }
-
-   /* Once we've determined that the function being called might exist, try
-    * to find an overload of the function that matches the parameters.
-    */
-   return process_call(instructions, f, loc, actual_parameters, state);
 }
 
 
@@ -321,161 +382,81 @@ process_array_constructor(exec_list *instructions,
       assert(constructor_type->length == parameter_count);
    }
 
-   ir_function *f = state->symbols->get_function(constructor_type->name);
-
-   /* If the constructor for this type of array does not exist, generate the
-    * prototype and add it to the symbol table.
-    */
-   if (f == NULL) {
-      f = constructor_type->generate_constructor(state->symbols);
-   }
-
-   ir_rvalue *const r =
-      process_call(instructions, f, loc, &actual_parameters, state);
-
-   assert(r != NULL);
-   assert(r->type->is_error() || (r->type == constructor_type));
-
-   return r;
-}
-
-
-/**
- * Try to convert a record constructor to a constant expression
- */
-static ir_constant *
-constant_record_constructor(const glsl_type *constructor_type,
-			    YYLTYPE *loc, exec_list *parameters,
-			    struct _mesa_glsl_parse_state *state)
-{
-   void *ctx = state;
    bool all_parameters_are_constant = true;
 
-   exec_node *node = parameters->head;
-   for (unsigned i = 0; i < constructor_type->length; i++) {
-      ir_instruction *ir = (ir_instruction *) node;
+   /* Type cast each parameter and, if possible, fold constants. */
+   foreach_list_safe(n, &actual_parameters) {
+      ir_rvalue *ir = (ir_rvalue *) n;
+      ir_rvalue *result = ir;
 
-      if (node->is_tail_sentinal()) {
-	 _mesa_glsl_error(loc, state,
-			  "insufficient parameters to constructor for `%s'",
-			  constructor_type->name);
-	 return NULL;
+      /* Apply implicit conversions (not the scalar constructor rules!) */
+      if (constructor_type->element_type()->is_float()) {
+	 const glsl_type *desired_type =
+	    glsl_type::get_instance(GLSL_TYPE_FLOAT,
+				    ir->type->vector_elements,
+				    ir->type->matrix_columns);
+	 result = convert_component(ir, desired_type);
       }
 
-      if (ir->type != constructor_type->fields.structure[i].type) {
-	 _mesa_glsl_error(loc, state,
-			  "parameter type mismatch in constructor for `%s' "
-			  " (%s vs %s)",
-			  constructor_type->name,
-			  ir->type->name,
-			  constructor_type->fields.structure[i].type->name);
-	 return NULL;
+      if (result->type != constructor_type->element_type()) {
+	 _mesa_glsl_error(loc, state, "type error in array constructor: "
+			  "expected: %s, found %s",
+			  constructor_type->element_type()->name,
+			  result->type->name);
       }
 
-      if (ir->as_constant() == NULL)
-	 all_parameters_are_constant = false;
-
-      node = node->next;
-   }
-
-   if (!all_parameters_are_constant)
-      return NULL;
-
-   return new(ctx) ir_constant(constructor_type, parameters);
-}
-
+      /* Attempt to convert the parameter to a constant valued expression.
+       * After doing so, track whether or not all the parameters to the
+       * constructor are trivially constant valued expressions.
+       */
+      ir_rvalue *const constant = result->constant_expression_value();
 
-/**
- * Generate data for a constant matrix constructor w/a single scalar parameter
- *
- * Matrix constructors in GLSL can be passed a single scalar of the
- * approriate type.  In these cases, the resulting matrix is the identity
- * matrix multipled by the specified scalar.  This function generates data for
- * that matrix.
- *
- * \param type         Type of the desired matrix.
- * \param initializer  Scalar value used to initialize the matrix diagonal.
- * \param data         Location to store the resulting matrix.
- */
-void
-generate_constructor_matrix(const glsl_type *type, ir_constant *initializer,
-			    ir_constant_data *data)
-{
-   switch (type->base_type) {
-   case GLSL_TYPE_UINT:
-   case GLSL_TYPE_INT:
-      for (unsigned i = 0; i < type->components(); i++)
-	 data->u[i] = 0;
+      if (constant != NULL)
+         result = constant;
+      else
+         all_parameters_are_constant = false;
 
-      for (unsigned i = 0; i < type->matrix_columns; i++) {
-	 /* The array offset of the ith row and column of the matrix.
-	  */
-	 const unsigned idx = (i * type->vector_elements) + i;
+      ir->replace_with(result);
+   }
 
-	 data->u[idx] = initializer->value.u[0];
-      }
-      break;
+   if (all_parameters_are_constant)
+      return new(ctx) ir_constant(constructor_type, &actual_parameters);
 
-   case GLSL_TYPE_FLOAT:
-      for (unsigned i = 0; i < type->components(); i++)
-	 data->f[i] = 0;
+   ir_variable *var = new(ctx) ir_variable(constructor_type, "array_ctor",
+					   ir_var_temporary);
+   instructions->push_tail(var);
 
-      for (unsigned i = 0; i < type->matrix_columns; i++) {
-	 /* The array offset of the ith row and column of the matrix.
-	  */
-	 const unsigned idx = (i * type->vector_elements) + i;
+   int i = 0;
+   foreach_list(node, &actual_parameters) {
+      ir_rvalue *rhs = (ir_rvalue *) node;
+      ir_rvalue *lhs = new(ctx) ir_dereference_array(var,
+						     new(ctx) ir_constant(i));
 
-	 data->f[idx] = initializer->value.f[0];
-      }
+      ir_instruction *assignment = new(ctx) ir_assignment(lhs, rhs, NULL);
+      instructions->push_tail(assignment);
 
-      break;
-
-   default:
-      assert(!"Should not get here.");
-      break;
+      i++;
    }
+
+   return new(ctx) ir_dereference_variable(var);
 }
 
 
 /**
- * Generate data for a constant vector constructor w/a single scalar parameter
- *
- * Vector constructors in GLSL can be passed a single scalar of the
- * approriate type.  In these cases, the resulting vector contains the specified
- * value in all components.  This function generates data for that vector.
- *
- * \param type         Type of the desired vector.
- * \param initializer  Scalar value used to initialize the vector.
- * \param data         Location to store the resulting vector data.
+ * Try to convert a record constructor to a constant expression
  */
-void
-generate_constructor_vector(const glsl_type *type, ir_constant *initializer,
-			    ir_constant_data *data)
+static ir_constant *
+constant_record_constructor(const glsl_type *constructor_type,
+			    exec_list *parameters, void *mem_ctx)
 {
-   switch (type->base_type) {
-   case GLSL_TYPE_UINT:
-   case GLSL_TYPE_INT:
-      for (unsigned i = 0; i < type->components(); i++)
-	 data->u[i] = initializer->value.u[0];
-
-      break;
-
-   case GLSL_TYPE_FLOAT:
-      for (unsigned i = 0; i < type->components(); i++)
-	 data->f[i] = initializer->value.f[0];
-
-      break;
-
-   case GLSL_TYPE_BOOL:
-      for (unsigned i = 0; i < type->components(); i++)
-	 data->b[i] = initializer->value.b[0];
-
-      break;
-
-   default:
-      assert(!"Should not get here.");
-      break;
+   foreach_list(node, parameters) {
+      ir_constant *constant = ((ir_instruction *) node)->as_constant();
+      if (constant == NULL)
+	 return NULL;
+      node->replace_with(constant);
    }
+
+   return new(mem_ctx) ir_constant(constructor_type, parameters);
 }
 
 
@@ -488,7 +469,7 @@ single_scalar_parameter(exec_list *parameters)
    const ir_rvalue *const p = (ir_rvalue *) parameters->head;
    assert(((ir_rvalue *)p)->as_rvalue() != NULL);
 
-   return (p->type->is_scalar() && p->next->is_tail_sentinal());
+   return (p->type->is_scalar() && p->next->is_tail_sentinel());
 }
 
 
@@ -511,9 +492,7 @@ emit_inline_vector_constructor(const glsl_type *type,
 {
    assert(!parameters->is_empty());
 
-   ir_variable *var = new(ctx) ir_variable(type,
-					   talloc_strdup(ctx, "vec_ctor"),
-					   ir_var_temporary);
+   ir_variable *var = new(ctx) ir_variable(type, "vec_ctor", ir_var_temporary);
    instructions->push_tail(var);
 
    /* There are two kinds of vector constructors.
@@ -531,37 +510,106 @@ emit_inline_vector_constructor(const glsl_type *type,
       ir_rvalue *rhs = new(ctx) ir_swizzle(first_param, 0, 0, 0, 0,
 					   lhs_components);
       ir_dereference_variable *lhs = new(ctx) ir_dereference_variable(var);
+      const unsigned mask = (1U << lhs_components) - 1;
 
       assert(rhs->type == lhs->type);
 
-      ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL);
+      ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL, mask);
       instructions->push_tail(inst);
    } else {
       unsigned base_component = 0;
+      unsigned base_lhs_component = 0;
+      ir_constant_data data;
+      unsigned constant_mask = 0, constant_components = 0;
+
+      memset(&data, 0, sizeof(data));
+
       foreach_list(node, parameters) {
-	 ir_rvalue *rhs = (ir_rvalue *) node;
-	 unsigned rhs_components = rhs->type->components();
+	 ir_rvalue *param = (ir_rvalue *) node;
+	 unsigned rhs_components = param->type->components();
 
 	 /* Do not try to assign more components to the vector than it has!
 	  */
-	 if ((rhs_components + base_component) > lhs_components) {
-	    rhs_components = lhs_components - base_component;
+	 if ((rhs_components + base_lhs_component) > lhs_components) {
+	    rhs_components = lhs_components - base_lhs_component;
+	 }
+
+	 const ir_constant *const c = param->as_constant();
+	 if (c != NULL) {
+	    for (unsigned i = 0; i < rhs_components; i++) {
+	       switch (c->type->base_type) {
+	       case GLSL_TYPE_UINT:
+		  data.u[i + base_component] = c->get_uint_component(i);
+		  break;
+	       case GLSL_TYPE_INT:
+		  data.i[i + base_component] = c->get_int_component(i);
+		  break;
+	       case GLSL_TYPE_FLOAT:
+		  data.f[i + base_component] = c->get_float_component(i);
+		  break;
+	       case GLSL_TYPE_BOOL:
+		  data.b[i + base_component] = c->get_bool_component(i);
+		  break;
+	       default:
+		  assert(!"Should not get here.");
+		  break;
+	       }
+	    }
+
+	    /* Mask of fields to be written in the assignment.
+	     */
+	    constant_mask |= ((1U << rhs_components) - 1) << base_lhs_component;
+	    constant_components += rhs_components;
+
+	    base_component += rhs_components;
 	 }
+	 /* Advance the component index by the number of components
+	  * that were just assigned.
+	  */
+	 base_lhs_component += rhs_components;
+      }
+
+      if (constant_mask != 0) {
+	 ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
+	 const glsl_type *rhs_type = glsl_type::get_instance(var->type->base_type,
+							     constant_components,
+							     1);
+	 ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data);
+
+	 ir_instruction *inst =
+	    new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask);
+	 instructions->push_tail(inst);
+      }
 
-	 /* Emit an assignment of the constructor parameter to the next set of
-	  * components in the temporary variable.
+      base_component = 0;
+      foreach_list(node, parameters) {
+	 ir_rvalue *param = (ir_rvalue *) node;
+	 unsigned rhs_components = param->type->components();
+
+	 /* Do not try to assign more components to the vector than it has!
 	  */
-	 unsigned mask[4] = { 0, 0, 0, 0 };
-	 for (unsigned i = 0; i < rhs_components; i++) {
-	    mask[i] = i + base_component;
+	 if ((rhs_components + base_component) > lhs_components) {
+	    rhs_components = lhs_components - base_component;
 	 }
 
+	 const ir_constant *const c = param->as_constant();
+	 if (c == NULL) {
+	    /* Mask of fields to be written in the assignment.
+	     */
+	    const unsigned write_mask = ((1U << rhs_components) - 1)
+	       << base_component;
 
-	 ir_rvalue *lhs_ref = new(ctx) ir_dereference_variable(var);
-	 ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, mask, rhs_components);
+	    ir_dereference *lhs = new(ctx) ir_dereference_variable(var);
 
-	 ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL);
-	 instructions->push_tail(inst);
+	    /* Generate a swizzle so that LHS and RHS sizes match.
+	     */
+	    ir_rvalue *rhs =
+	       new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components);
+
+	    ir_instruction *inst =
+	       new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
+	    instructions->push_tail(inst);
+	 }
 
 	 /* Advance the component index by the number of components that were
 	  * just assigned.
@@ -588,20 +636,29 @@ emit_inline_vector_constructor(const glsl_type *type,
 ir_instruction *
 assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base,
 			ir_rvalue *src, unsigned src_base, unsigned count,
-			TALLOC_CTX *ctx)
+			void *mem_ctx)
 {
-   const unsigned mask[8] = { 0, 1, 2, 3, 0, 0, 0, 0 };
-
-   ir_constant *col_idx = new(ctx) ir_constant(column);
-   ir_rvalue *column_ref = new(ctx) ir_dereference_array(var, col_idx);
+   ir_constant *col_idx = new(mem_ctx) ir_constant(column);
+   ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var, col_idx);
 
    assert(column_ref->type->components() >= (row_base + count));
-   ir_rvalue *lhs = new(ctx) ir_swizzle(column_ref, &mask[row_base], count);
-
    assert(src->type->components() >= (src_base + count));
-   ir_rvalue *rhs = new(ctx) ir_swizzle(src, &mask[src_base], count);
 
-   return new(ctx) ir_assignment(lhs, rhs, NULL);
+   /* Generate a swizzle that extracts the number of components from the source
+    * that are to be assigned to the column of the matrix.
+    */
+   if (count < src->type->vector_elements) {
+      src = new(mem_ctx) ir_swizzle(src,
+				    src_base + 0, src_base + 1,
+				    src_base + 2, src_base + 3,
+				    count);
+   }
+
+   /* Mask of fields to be written in the assignment.
+    */
+   const unsigned write_mask = ((1U << count) - 1) << row_base;
+
+   return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask);
 }
 
 
@@ -624,9 +681,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
 {
    assert(!parameters->is_empty());
 
-   ir_variable *var = new(ctx) ir_variable(type,
-					   talloc_strdup(ctx, "mat_ctor"),
-					   ir_var_temporary);
+   ir_variable *var = new(ctx) ir_variable(type, "mat_ctor", ir_var_temporary);
    instructions->push_tail(var);
 
    /* There are three kinds of matrix constructors.
@@ -649,8 +704,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
        * components with zero.
        */
       ir_variable *rhs_var =
-	 new(ctx) ir_variable(glsl_type::vec4_type,
-			      talloc_strdup(ctx, "mat_ctor_vec"),
+	 new(ctx) ir_variable(glsl_type::vec4_type, "mat_ctor_vec",
 			      ir_var_temporary);
       instructions->push_tail(rhs_var);
 
@@ -666,10 +720,9 @@ emit_inline_matrix_constructor(const glsl_type *type,
 				NULL);
       instructions->push_tail(inst);
 
-      ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
-      ir_rvalue *const x_of_rhs = new(ctx) ir_swizzle(rhs_ref, 0, 0, 0, 0, 1);
+      ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var);
 
-      inst = new(ctx) ir_assignment(x_of_rhs, first_param, NULL);
+      inst = new(ctx) ir_assignment(rhs_ref, first_param, NULL, 0x01);
       instructions->push_tail(inst);
 
       /* Assign the temporary vector to each column of the destination matrix
@@ -685,8 +738,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
 	 { 1, 1, 1, 0 }
       };
 
-      const unsigned cols_to_init = min(type->matrix_columns,
-					type->vector_elements);
+      const unsigned cols_to_init = MIN2(type->matrix_columns,
+					 type->vector_elements);
       for (unsigned i = 0; i < cols_to_init; i++) {
 	 ir_constant *const col_idx = new(ctx) ir_constant(i);
 	 ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx);
@@ -720,7 +773,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
        *     identity matrix. If a matrix argument is given to a matrix
        *     constructor, it is an error to have any other arguments."
        */
-      assert(first_param->next->is_tail_sentinal());
+      assert(first_param->next->is_tail_sentinel());
       ir_rvalue *const src_matrix = first_param;
 
       /* If the source matrix is smaller, pre-initialize the relavent parts of
@@ -764,8 +817,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
        * generate a temporary and copy the paramter there.
        */
       ir_variable *const rhs_var =
-	 new(ctx) ir_variable(first_param->type,
-			      talloc_strdup(ctx, "mat_ctor_mat"),
+	 new(ctx) ir_variable(first_param->type, "mat_ctor_mat",
 			      ir_var_temporary);
       instructions->push_tail(rhs_var);
 
@@ -775,12 +827,19 @@ emit_inline_matrix_constructor(const glsl_type *type,
 	 new(ctx) ir_assignment(rhs_var_ref, first_param, NULL);
       instructions->push_tail(inst);
 
+      const unsigned last_row = MIN2(src_matrix->type->vector_elements,
+				     var->type->vector_elements);
+      const unsigned last_col = MIN2(src_matrix->type->matrix_columns,
+				     var->type->matrix_columns);
+
+      unsigned swiz[4] = { 0, 0, 0, 0 };
+      for (unsigned i = 1; i < last_row; i++)
+	 swiz[i] = i;
+
+      const unsigned write_mask = (1U << last_row) - 1;
 
-      const unsigned swiz[4] = { 0, 1, 2, 3 };
-      const unsigned last_col = min(src_matrix->type->matrix_columns,
-				    var->type->matrix_columns);
       for (unsigned i = 0; i < last_col; i++) {
-	 ir_rvalue *const lhs_col =
+	 ir_dereference *const lhs =
 	    new(ctx) ir_dereference_array(var, new(ctx) ir_constant(i));
 	 ir_rvalue *const rhs_col =
 	    new(ctx) ir_dereference_array(rhs_var, new(ctx) ir_constant(i));
@@ -793,31 +852,20 @@ emit_inline_matrix_constructor(const glsl_type *type,
 	  * It would be perfectly valid to unconditionally generate the
 	  * swizzles, this this will typically result in a more compact IR tree.
 	  */
-	 ir_rvalue *lhs;
 	 ir_rvalue *rhs;
-	 if (lhs_col->type->vector_elements < rhs_col->type->vector_elements) {
-	    lhs = lhs_col;
-
-	    rhs = new(ctx) ir_swizzle(rhs_col, swiz,
-				      lhs_col->type->vector_elements);
-	 } else if (lhs_col->type->vector_elements
-		    > rhs_col->type->vector_elements) {
-	    lhs = new(ctx) ir_swizzle(lhs_col, swiz,
-				      rhs_col->type->vector_elements);
-	    rhs = rhs_col;
+	 if (lhs->type->vector_elements != rhs_col->type->vector_elements) {
+	    rhs = new(ctx) ir_swizzle(rhs_col, swiz, last_row);
 	 } else {
-	    lhs = lhs_col;
 	    rhs = rhs_col;
 	 }
 
-	 assert(lhs->type == rhs->type);
-
-	 ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL);
+	 ir_instruction *inst =
+	    new(ctx) ir_assignment(lhs, rhs, NULL, write_mask);
 	 instructions->push_tail(inst);
       }
    } else {
-      const unsigned rows = type->matrix_columns;
-      const unsigned cols = type->vector_elements;
+      const unsigned cols = type->matrix_columns;
+      const unsigned rows = type->vector_elements;
       unsigned col_idx = 0;
       unsigned row_idx = 0;
 
@@ -831,9 +879,7 @@ emit_inline_matrix_constructor(const glsl_type *type,
 	  * generate a temporary and copy the paramter there.
 	  */
 	 ir_variable *rhs_var =
-	    new(ctx) ir_variable(rhs->type,
-				 talloc_strdup(ctx, "mat_ctor_vec"),
-				 ir_var_temporary);
+	    new(ctx) ir_variable(rhs->type, "mat_ctor_vec", ir_var_temporary);
 	 instructions->push_tail(rhs_var);
 
 	 ir_dereference *rhs_var_ref =
@@ -848,8 +894,8 @@ emit_inline_matrix_constructor(const glsl_type *type,
 	  * single vec4, for example, can completely fill a mat2.
 	  */
 	 if (rhs_components >= components_remaining_this_column) {
-	    const unsigned count = min(rhs_components,
-				       components_remaining_this_column);
+	    const unsigned count = MIN2(rhs_components,
+					components_remaining_this_column);
 
 	    rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var);
 
@@ -893,6 +939,39 @@ emit_inline_matrix_constructor(const glsl_type *type,
 }
 
 
+ir_rvalue *
+emit_inline_record_constructor(const glsl_type *type,
+			       exec_list *instructions,
+			       exec_list *parameters,
+			       void *mem_ctx)
+{
+   ir_variable *const var =
+      new(mem_ctx) ir_variable(type, "record_ctor", ir_var_temporary);
+   ir_dereference_variable *const d = new(mem_ctx) ir_dereference_variable(var);
+
+   instructions->push_tail(var);
+
+   exec_node *node = parameters->head;
+   for (unsigned i = 0; i < type->length; i++) {
+      assert(!node->is_tail_sentinel());
+
+      ir_dereference *const lhs =
+	 new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL),
+					    type->fields.structure[i].name);
+
+      ir_rvalue *const rhs = ((ir_instruction *) node)->as_rvalue();
+      assert(rhs != NULL);
+
+      ir_instruction *const assign = new(mem_ctx) ir_assignment(lhs, rhs, NULL);
+
+      instructions->push_tail(assign);
+      node = node->next;
+   }
+
+   return d;
+}
+
+
 ir_rvalue *
 ast_function_expression::hir(exec_list *instructions,
 			     struct _mesa_glsl_parse_state *state)
@@ -934,6 +1013,7 @@ ast_function_expression::hir(exec_list *instructions,
 					  & loc, &this->expressions, state);
       }
 
+
       /* There are two kinds of constructor call.  Constructors for built-in
        * language types, such as mat4 and vec2, are free form.  The only
        * requirement is that the parameters must provide enough values of the
@@ -997,7 +1077,7 @@ ast_function_expression::hir(exec_list *instructions,
        *    "It is an error to construct matrices from other matrices. This
        *    is reserved for future use."
        */
-      if ((state->language_version <= 110) && (matrix_parameters > 0)
+      if (state->language_version == 110 && matrix_parameters > 0
 	  && constructor_type->is_matrix()) {
 	 _mesa_glsl_error(& loc, state, "cannot construct `%s' from a "
 			  "matrix in GLSL 1.10",
@@ -1025,7 +1105,8 @@ ast_function_expression::hir(exec_list *instructions,
        *    arguments to provide an initializer for every component in the
        *    constructed value."
        */
-      if ((components_used < type_components) && (components_used != 1)) {
+      if (components_used < type_components && components_used != 1
+	  && matrix_parameters == 0) {
 	 _mesa_glsl_error(& loc, state, "too few components to construct "
 			  "`%s'",
 			  constructor_type->name);
@@ -1092,32 +1173,7 @@ ast_function_expression::hir(exec_list *instructions,
        * constant representing the complete collection of parameters.
        */
       if (all_parameters_are_constant) {
-	 if (components_used >= type_components)
-	    return new(ctx) ir_constant(constructor_type,
-					& actual_parameters);
-
-	 /* The above case must handle all scalar constructors.
-	  */
-	 assert(constructor_type->is_vector()
-		|| constructor_type->is_matrix());
-
-	 /* Constructors with exactly one component are special for
-	  * vectors and matrices.  For vectors it causes all elements of
-	  * the vector to be filled with the value.  For matrices it
-	  * causes the matrix to be filled with 0 and the diagonal to be
-	  * filled with the value.
-	  */
-	 ir_constant_data data;
-	 ir_constant *const initializer =
-	    (ir_constant *) actual_parameters.head;
-	 if (constructor_type->is_matrix())
-	    generate_constructor_matrix(constructor_type, initializer,
-					&data);
-	 else
-	    generate_constructor_vector(constructor_type, initializer,
-					&data);
-
-	 return new(ctx) ir_constant(constructor_type, &data);
+	 return new(ctx) ir_constant(constructor_type, &actual_parameters);
       } else if (constructor_type->is_scalar()) {
 	 return dereference_component((ir_rvalue *) actual_parameters.head,
 				      0);
@@ -1145,11 +1201,48 @@ ast_function_expression::hir(exec_list *instructions,
 	 state->symbols->get_type(id->primary_expression.identifier);
 
       if ((type != NULL) && type->is_record()) {
-	 ir_constant *constant =
-	    constant_record_constructor(type, &loc, &actual_parameters, state);
+	 exec_node *node = actual_parameters.head;
+	 for (unsigned i = 0; i < type->length; i++) {
+	    ir_rvalue *ir = (ir_rvalue *) node;
+
+	    if (node->is_tail_sentinel()) {
+	       _mesa_glsl_error(&loc, state,
+				"insufficient parameters to constructor "
+				"for `%s'",
+				type->name);
+	       return ir_call::get_error_instruction(ctx);
+	    }
 
-	 if (constant != NULL)
-	    return constant;
+	    if (apply_implicit_conversion(type->fields.structure[i].type, ir,
+					  state)) {
+	       node->replace_with(ir);
+	    } else {
+	       _mesa_glsl_error(&loc, state,
+				"parameter type mismatch in constructor "
+				"for `%s.%s' (%s vs %s)",
+				type->name,
+				type->fields.structure[i].name,
+				ir->type->name,
+				type->fields.structure[i].type->name);
+	       return ir_call::get_error_instruction(ctx);;
+	    }
+
+	    node = node->next;
+	 }
+
+	 if (!node->is_tail_sentinel()) {
+	    _mesa_glsl_error(&loc, state, "too many parameters in constructor "
+			     "for `%s'", type->name);
+	    return ir_call::get_error_instruction(ctx);
+	 }
+
+	 ir_rvalue *const constant =
+	    constant_record_constructor(type, &actual_parameters, state);
+
+	 return (constant != NULL)
+	    ? constant
+	    : emit_inline_record_constructor(type, instructions,
+					     &actual_parameters, state);
       }
 
       return match_function_by_name(instructions,