glsl_type: Remove vector and matrix constructor generators

All scalar, vector, and matrix constructors are generated in-line
during AST-to-HIR translation.  There is no longer any need to
generate function versions of the constructors.

3 files changed, 0 insertions, 370 deletions

diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
index c5df0b0fd0..54a8e9e00a 100644
--- a/src/glsl/ast_to_hir.cpp
+++ b/src/glsl/ast_to_hir.cpp
@@ -60,7 +60,6 @@ void
 _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
 {
    _mesa_glsl_initialize_variables(instructions, state);
-   _mesa_glsl_initialize_constructors(instructions, state);
    _mesa_glsl_initialize_functions(instructions, state);
 
    state->current_function = NULL;
diff --git a/src/glsl/glsl_types.cpp b/src/glsl/glsl_types.cpp
index 9a53fbdbcb..ff157080ff 100644
--- a/src/glsl/glsl_types.cpp
+++ b/src/glsl/glsl_types.cpp
@@ -210,371 +210,6 @@ glsl_type::generate_constructor(glsl_symbol_table *symtab) const
 }
 
 
-/**
- * Generate the function intro for a constructor
- *
- * \param type         Data type to be constructed
- * \param count        Number of parameters to this concrete constructor.  Most
- *                     types have at least two constructors.  One will take a
- *                     single scalar parameter and the other will take "N"
- *                     scalar parameters.
- * \param parameters   Storage for the list of parameters.  These are
- *                     typically stored in an \c ir_function_signature.
- * \param declarations Pointers to the variable declarations for the function
- *                     parameters.  These are used later to avoid having to use
- *                     the symbol table.
- */
-static ir_function_signature *
-generate_constructor_intro(void *ctx,
-			   const glsl_type *type, unsigned parameter_count,
-			   ir_variable **declarations)
-{
-   /* Names of parameters used in vector and matrix constructors
-    */
-   static const char *const names[] = {
-      "a", "b", "c", "d", "e", "f", "g", "h",
-      "i", "j", "k", "l", "m", "n", "o", "p",
-   };
-
-   assert(parameter_count <= Elements(names));
-
-   const glsl_type *const parameter_type = type->get_base_type();
-
-   ir_function_signature *const signature = new(ctx) ir_function_signature(type);
-
-   for (unsigned i = 0; i < parameter_count; i++) {
-      ir_variable *var = new(ctx) ir_variable(parameter_type, names[i]);
-
-      var->mode = ir_var_in;
-      signature->parameters.push_tail(var);
-
-      declarations[i] = var;
-   }
-
-   ir_variable *retval = new(ctx) ir_variable(type, "__retval");
-   signature->body.push_tail(retval);
-
-   declarations[16] = retval;
-   return signature;
-}
-
-
-/**
- * Generate the body of a vector constructor that takes a single scalar
- */
-static void
-generate_vec_body_from_scalar(void *ctx,
-			      exec_list *instructions,
-			      ir_variable **declarations)
-{
-   ir_instruction *inst;
-
-   /* Generate a single assignment of the parameter to __retval.x and return
-    * __retval.xxxx for however many vector components there are.
-    */
-   ir_dereference *const lhs_ref =
-      new(ctx) ir_dereference_variable(declarations[16]);
-   ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[0]);
-
-   ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, 0, 0, 0, 0, 1);
-
-   inst = new(ctx) ir_assignment(lhs, rhs, NULL);
-   instructions->push_tail(inst);
-
-   ir_dereference *const retref = new(ctx) ir_dereference_variable(declarations[16]);
-
-   ir_swizzle *retval = new(ctx) ir_swizzle(retref, 0, 0, 0, 0,
-					    declarations[16]->type->vector_elements);
-
-   inst = new(ctx) ir_return(retval);
-   instructions->push_tail(inst);
-}
-
-
-/**
- * Generate the body of a vector constructor that takes multiple scalars
- */
-static void
-generate_vec_body_from_N_scalars(void *ctx,
-				 exec_list *instructions,
-				 ir_variable **declarations)
-{
-   ir_instruction *inst;
-   const glsl_type *const vec_type = declarations[16]->type;
-
-   /* Generate an assignment of each parameter to a single component of
-    * __retval.x and return __retval.
-    */
-   for (unsigned i = 0; i < vec_type->vector_elements; i++) {
-      ir_dereference *const lhs_ref =
-	 new(ctx) ir_dereference_variable(declarations[16]);
-      ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[i]);
-
-      ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, i, 0, 0, 0, 1);
-
-      inst = new(ctx) ir_assignment(lhs, rhs, NULL);
-      instructions->push_tail(inst);
-   }
-
-   ir_dereference *retval = new(ctx) ir_dereference_variable(declarations[16]);
-
-   inst = new(ctx) ir_return(retval);
-   instructions->push_tail(inst);
-}
-
-
-/**
- * Generate the body of a matrix constructor that takes a single scalar
- */
-static void
-generate_mat_body_from_scalar(void *ctx,
-			      exec_list *instructions,
-			      ir_variable **declarations)
-{
-   ir_instruction *inst;
-
-   /* Generate an assignment of the parameter to the X component of a
-    * temporary vector.  Set the remaining fields of the vector to 0.  The
-    * size of the vector is equal to the number of rows of the matrix.
-    *
-    * Set each column of the matrix to a successive "rotation" of the
-    * temporary vector.  This fills the matrix with 0s, but writes the single
-    * scalar along the matrix's diagonal.
-    *
-    * For a mat4x3, this is equivalent to:
-    *
-    *   vec3 tmp;
-    *   mat4x3 __retval;
-    *   tmp.x = a;
-    *   tmp.y = 0.0;
-    *   tmp.z = 0.0;
-    *   __retval[0] = tmp.xyy;
-    *   __retval[1] = tmp.yxy;
-    *   __retval[2] = tmp.yyx;
-    *   __retval[3] = tmp.yyy;
-    */
-   const glsl_type *const column_type = declarations[16]->type->column_type();
-   const glsl_type *const row_type = declarations[16]->type->row_type();
-
-   ir_variable *const column = new(ctx) ir_variable(column_type, "v");
-
-   instructions->push_tail(column);
-
-   ir_dereference *const lhs_ref = new(ctx) ir_dereference_variable(column);
-   ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[0]);
-
-   ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, 0, 0, 0, 0, 1);
-
-   inst = new(ctx) ir_assignment(lhs, rhs, NULL);
-   instructions->push_tail(inst);
-
-   for (unsigned i = 1; i < column_type->vector_elements; i++) {
-      ir_dereference *const lhs_ref = new(ctx) ir_dereference_variable(column);
-      ir_constant *const zero = new(ctx) ir_constant(0.0f);
-
-      ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, i, 0, 0, 0, 1);
-
-      inst = new(ctx) ir_assignment(lhs, zero, NULL);
-      instructions->push_tail(inst);
-   }
-
-
-   for (unsigned i = 0; i < row_type->vector_elements; i++) {
-      static const unsigned swiz[] = { 1, 1, 1, 0, 1, 1, 1 };
-      ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(column);
-
-      /* This will be .xyyy when i=0, .yxyy when i=1, etc.
-       */
-      ir_swizzle *rhs = new(ctx) ir_swizzle(rhs_ref, swiz[3 - i], swiz[4 - i],
-					    swiz[5 - i], swiz[6 - i],
-					    column_type->vector_elements);
-
-      ir_constant *const idx = new(ctx) ir_constant(int(i));
-      ir_dereference *const lhs =
-	 new(ctx) ir_dereference_array(declarations[16], idx);
-
-      inst = new(ctx) ir_assignment(lhs, rhs, NULL);
-      instructions->push_tail(inst);
-   }
-
-   ir_dereference *const retval = new(ctx) ir_dereference_variable(declarations[16]);
-   inst = new(ctx) ir_return(retval);
-   instructions->push_tail(inst);
-}
-
-
-/**
- * Generate the body of a vector constructor that takes multiple scalars
- */
-static void
-generate_mat_body_from_N_scalars(void *ctx,
-				 exec_list *instructions,
-				 ir_variable **declarations)
-{
-   ir_instruction *inst;
-   const glsl_type *const row_type = declarations[16]->type->row_type();
-   const glsl_type *const column_type = declarations[16]->type->column_type();
-
-   /* Generate an assignment of each parameter to a single component of
-    * of a particular column of __retval and return __retval.
-    */
-   for (unsigned i = 0; i < column_type->vector_elements; i++) {
-      for (unsigned j = 0; j < row_type->vector_elements; j++) {
-	 ir_constant *row_index = new(ctx) ir_constant(int(i));
-	 ir_dereference *const row_access =
-	    new(ctx) ir_dereference_array(declarations[16], row_index);
-
-	 ir_swizzle *component_access = new(ctx) ir_swizzle(row_access,
-							    j, 0, 0, 0, 1);
-
-	 const unsigned param = (i * row_type->vector_elements) + j;
-	 ir_dereference *const rhs =
-	    new(ctx) ir_dereference_variable(declarations[param]);
-
-	 inst = new(ctx) ir_assignment(component_access, rhs, NULL);
-	 instructions->push_tail(inst);
-      }
-   }
-
-   ir_dereference *retval = new(ctx) ir_dereference_variable(declarations[16]);
-
-   inst = new(ctx) ir_return(retval);
-   instructions->push_tail(inst);
-}
-
-
-/**
- * Generate the constructors for a set of GLSL types
- *
- * Constructor implementations are added to \c instructions, and the symbols
- * are added to \c symtab.
- */
-static void
-generate_constructor(glsl_symbol_table *symtab, const struct glsl_type *types,
-		     unsigned num_types, exec_list *instructions)
-{
-   void *ctx = symtab;
-   ir_variable *declarations[17];
-
-   for (unsigned i = 0; i < num_types; i++) {
-      /* Only numeric and boolean vectors and matrices get constructors here.
-       * Structures need to be handled elsewhere.  It is expected that scalar
-       * constructors are never actually called, so they are not generated.
-       */
-      if (!types[i].is_numeric() && !types[i].is_boolean())
-	 continue;
-
-      if (types[i].is_scalar())
-	 continue;
-
-      /* Generate the function block, add it to the symbol table, and emit it.
-       */
-      ir_function *const f = new(ctx) ir_function(types[i].name);
-
-      bool added = symtab->add_function(types[i].name, f);
-      assert(added);
-
-      instructions->push_tail(f);
-
-      /* Each type has several basic constructors.  The total number of forms
-       * depends on the derived type.
-       *
-       * Vectors:  1 scalar, N scalars
-       * Matrices: 1 scalar, NxM scalars
-       *
-       * Several possible types of constructors are not included in this list.
-       *
-       * Scalar constructors are not included.  The expectation is that the
-       * IR generator won't actually generate these as constructor calls.  The
-       * expectation is that it will just generate the necessary type
-       * conversion.
-       *
-       * Matrix contructors from matrices are also not included.  The
-       * expectation is that the IR generator will generate a call to the
-       * appropriate from-scalars constructor.
-       */
-      ir_function_signature *const sig =
-         generate_constructor_intro(ctx, &types[i], 1, declarations);
-      f->add_signature(sig);
-
-      if (types[i].is_vector()) {
-	 generate_vec_body_from_scalar(ctx, &sig->body, declarations);
-
-	 ir_function_signature *const vec_sig =
-	    generate_constructor_intro(ctx,
-				       &types[i], types[i].vector_elements,
-				       declarations);
-	 f->add_signature(vec_sig);
-
-	 generate_vec_body_from_N_scalars(ctx, &vec_sig->body, declarations);
-      } else {
-	 assert(types[i].is_matrix());
-
-	 generate_mat_body_from_scalar(ctx, &sig->body, declarations);
-
-	 ir_function_signature *const mat_sig =
-	    generate_constructor_intro(ctx,
-				       &types[i],
-				       (types[i].vector_elements
-					* types[i].matrix_columns),
-				       declarations);
-	 f->add_signature(mat_sig);
-
-	 generate_mat_body_from_N_scalars(ctx, &mat_sig->body, declarations);
-      }
-   }
-}
-
-
-void
-generate_110_constructors(glsl_symbol_table *symtab, exec_list *instructions)
-{
-   generate_constructor(symtab, builtin_core_types,
-			Elements(builtin_core_types), instructions);
-}
-
-
-void
-generate_120_constructors(glsl_symbol_table *symtab, exec_list *instructions)
-{
-   generate_110_constructors(symtab, instructions);
-
-   generate_constructor(symtab, builtin_120_types,
-			Elements(builtin_120_types), instructions);
-}
-
-
-void
-generate_130_constructors(glsl_symbol_table *symtab, exec_list *instructions)
-{
-   generate_120_constructors(symtab, instructions);
-
-   generate_constructor(symtab, builtin_130_types,
-			Elements(builtin_130_types), instructions);
-}
-
-
-void
-_mesa_glsl_initialize_constructors(exec_list *instructions,
-				   struct _mesa_glsl_parse_state *state)
-{
-   switch (state->language_version) {
-   case 110:
-      generate_110_constructors(state->symbols, instructions);
-      break;
-   case 120:
-      generate_120_constructors(state->symbols, instructions);
-      break;
-   case 130:
-      generate_130_constructors(state->symbols, instructions);
-      break;
-   default:
-      /* error */
-      break;
-   }
-}
-
-
 glsl_type::glsl_type(void *ctx, const glsl_type *array, unsigned length) :
    base_type(GLSL_TYPE_ARRAY),
    sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
diff --git a/src/glsl/glsl_types.h b/src/glsl/glsl_types.h
index 93cf60be8d..b753742b91 100644
--- a/src/glsl/glsl_types.h
+++ b/src/glsl/glsl_types.h
@@ -440,10 +440,6 @@ extern "C" {
 extern void
 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state);
 
-extern void
-_mesa_glsl_initialize_constructors(struct exec_list *instructions,
-				   struct _mesa_glsl_parse_state *state);
-
 #ifdef __cplusplus
 }
 #endif