+ return bool_type;
+ default:
+ return error_type;
+ }
+}
+
+
+ir_function *
+glsl_type::generate_constructor_prototype(glsl_symbol_table *symtab) const
+{
+ /* FINISHME: Add support for non-array types. */
+ assert(base_type == GLSL_TYPE_ARRAY);
+
+ /* Generate the function name and add it to the symbol table.
+ */
+ ir_function *const f = new ir_function(name);
+
+ bool added = symtab->add_function(name, f);
+ assert(added);
+
+ ir_function_signature *const sig = new ir_function_signature(this);
+ f->add_signature(sig);
+
+ for (unsigned i = 0; i < length; i++) {
+ char *const param_name = (char *) malloc(10);
+
+ snprintf(param_name, 10, "p%08X", i);
+
+ ir_variable *var = new ir_variable(fields.array, param_name);
+
+ var->mode = ir_var_in;
+ sig->parameters.push_tail(var);
+ }
+
+ return f;
+}
+
+
+/**
+ * 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 instructions Storage for the preamble and body of the function.
+ * \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_label *
+generate_constructor_intro(const glsl_type *type, unsigned parameter_count,
+ ir_function_signature *const signature,
+ exec_list *instructions,
+ 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_label *const label = new ir_label(type->name, signature);
+ instructions->push_tail(label);
+
+ for (unsigned i = 0; i < parameter_count; i++) {
+ ir_variable *var = new ir_variable(parameter_type, names[i]);
+
+ var->mode = ir_var_in;
+ signature->parameters.push_tail(var);
+
+ declarations[i] = var;
+ }
+
+ ir_variable *retval = new ir_variable(type, "__retval");
+ signature->body.push_tail(retval);
+
+ declarations[16] = retval;
+ return label;
+}
+
+
+/**
+ * Generate the body of a vector constructor that takes a single scalar
+ */
+static void
+generate_vec_body_from_scalar(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 ir_dereference(declarations[16]);
+ ir_dereference *const rhs = new ir_dereference(declarations[0]);
+
+ ir_swizzle *lhs = new ir_swizzle(lhs_ref, 0, 0, 0, 0, 1);
+
+ inst = new ir_assignment(lhs, rhs, NULL);
+ instructions->push_tail(inst);
+
+ ir_dereference *const retref = new ir_dereference(declarations[16]);
+
+ ir_swizzle *retval = new ir_swizzle(retref, 0, 0, 0, 0,
+ declarations[16]->type->vector_elements);
+
+ inst = new 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(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 ir_dereference(declarations[16]);
+ ir_dereference *const rhs = new ir_dereference(declarations[i]);
+
+ ir_swizzle *lhs = new ir_swizzle(lhs_ref, 1, 0, 0, 0, 1);
+
+ inst = new ir_assignment(lhs, rhs, NULL);
+ instructions->push_tail(inst);
+ }
+
+ ir_dereference *retval = new ir_dereference(declarations[16]);
+
+ inst = new 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(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 ir_variable(column_type, "v");
+
+ instructions->push_tail(column);
+
+ ir_dereference *const lhs_ref = new ir_dereference(column);
+ ir_dereference *const rhs = new ir_dereference(declarations[0]);
+
+ ir_swizzle *lhs = new ir_swizzle(lhs_ref, 0, 0, 0, 0, 1);
+
+ inst = new ir_assignment(lhs, rhs, NULL);
+ instructions->push_tail(inst);
+
+ const float z = 0.0f;
+ ir_constant *const zero = new ir_constant(glsl_type::float_type, &z);
+
+ for (unsigned i = 1; i < column_type->vector_elements; i++) {
+ ir_dereference *const lhs_ref = new ir_dereference(column);
+
+ ir_swizzle *lhs = new ir_swizzle(lhs_ref, i, 0, 0, 0, 1);
+
+ inst = new 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 ir_dereference(column);
+
+ /* This will be .xyyy when i=0, .yxyy when i=1, etc.
+ */
+ ir_swizzle *rhs = new 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 ir_constant(glsl_type::int_type, &i);
+ ir_dereference *const lhs = new ir_dereference(declarations[16], idx);
+
+ inst = new ir_assignment(lhs, rhs, NULL);
+ instructions->push_tail(inst);
+ }
+
+ ir_dereference *const retval = new ir_dereference(declarations[16]);
+ inst = new 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(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 ir_constant(glsl_type::int_type, &i);
+ ir_dereference *const row_access =
+ new ir_dereference(declarations[16], row_index);
+
+ ir_dereference *const component_access_ref =
+ new ir_dereference(row_access);
+
+ ir_swizzle *component_access = new ir_swizzle(component_access_ref,
+ j, 0, 0, 0, 1);
+
+ const unsigned param = (i * row_type->vector_elements) + j;
+ ir_dereference *const rhs = new ir_dereference(declarations[param]);
+
+ inst = new ir_assignment(component_access, rhs, NULL);
+ instructions->push_tail(inst);