diff options
| -rw-r--r-- | ast_to_hir.cpp | 1 | ||||
| -rw-r--r-- | glsl_parser_extras.cpp | 1 | ||||
| -rw-r--r-- | glsl_types.cpp | 370 | ||||
| -rw-r--r-- | glsl_types.h | 4 | ||||
| -rw-r--r-- | ir.cpp | 10 | ||||
| -rw-r--r-- | ir.h | 4 | ||||
| -rw-r--r-- | ir_print_visitor.cpp | 140 | ||||
| -rw-r--r-- | ir_print_visitor.h | 4 |
8 files changed, 491 insertions, 43 deletions
diff --git a/ast_to_hir.cpp b/ast_to_hir.cpp index 3d17fc9c82..cdbf2c1e46 100644 --- a/ast_to_hir.cpp +++ b/ast_to_hir.cpp @@ -62,6 +62,7 @@ _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) struct simple_node *ptr; _mesa_glsl_initialize_variables(instructions, state); + _mesa_glsl_initialize_constructors(instructions, state); state->current_function = NULL; diff --git a/glsl_parser_extras.cpp b/glsl_parser_extras.cpp index a02865887f..d57a68efb7 100644 --- a/glsl_parser_extras.cpp +++ b/glsl_parser_extras.cpp @@ -652,6 +652,7 @@ main(int argc, char **argv) ir_print_visitor v; ((ir_instruction *)iter.get())->accept(& v); + printf("\n"); } } diff --git a/glsl_types.cpp b/glsl_types.cpp index b2631efef9..f7ef4a302b 100644 --- a/glsl_types.cpp +++ b/glsl_types.cpp @@ -111,6 +111,376 @@ const glsl_type *glsl_type::get_base_type() 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 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 void +generate_constructor_intro(const glsl_type *type, unsigned parameter_count, + exec_list *parameters, 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); + 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; + parameters->push_tail(var); + + var = new ir_variable(parameter_type, names[i]); + + var->mode = ir_var_in; + instructions->push_tail(var); + + declarations[i] = var; + } + + ir_variable *retval = new ir_variable(type, "__retval"); + instructions->push_tail(retval); + + declarations[16] = retval; +} + + +/** + * 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 = new ir_dereference(declarations[16]); + ir_dereference *const rhs = new ir_dereference(declarations[0]); + + lhs->set_swizzle(0, 0, 0, 0, 1); + + inst = new ir_assignment(lhs, rhs, NULL); + instructions->push_tail(inst); + + ir_dereference *const retval = new ir_dereference(declarations[16]); + + retval->set_swizzle(0, 0, 0, 0, declarations[16]->type->vector_elements); + + inst = new ir_return((ir_expression *) 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 = new ir_dereference(declarations[16]); + ir_dereference *const rhs = new ir_dereference(declarations[i]); + + lhs->selector.swizzle.x = i; + lhs->selector.swizzle.num_components = 1; + + inst = new ir_assignment(lhs, rhs, NULL); + instructions->push_tail(inst); + } + + ir_dereference *retval = new ir_dereference(declarations[16]); + + inst = new ir_return((ir_expression *) 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 = new ir_dereference(column); + ir_dereference *const rhs = new ir_dereference(declarations[0]); + + lhs->set_swizzle(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_float_type, &z); + + for (unsigned i = 1; i < column_type->vector_elements; i++) { + ir_dereference *const lhs = new ir_dereference(column); + + lhs->set_swizzle(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 = new ir_dereference(column); + + /* This will be .xyyy when i=0, .yxyy when i=1, etc. + */ + rhs->set_swizzle(swiz[3 - i], swiz[4 - i], swiz[5 - i], swiz[6 - i], + column_type->vector_elements); + + ir_constant *const idx = new ir_constant(glsl_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((ir_expression *) 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_int_type, &i); + ir_dereference *const row_access = + new ir_dereference(declarations[16], row_index); + + ir_dereference *const component_access = + new ir_dereference(row_access); + + component_access->selector.swizzle.x = j; + component_access->selector.swizzle.num_components = 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); + } + } + + ir_dereference *retval = new ir_dereference(declarations[16]); + + inst = new ir_return((ir_expression *) 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) +{ + 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 name and add it to the symbol table. + */ + ir_function *const f = new ir_function(types[i].name); + + bool added = symtab->add_function(types[i].name, f); + assert(added); + + + /* 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 = new ir_function_signature(& types[i]); + f->signatures.push_tail(sig); + + generate_constructor_intro(& types[i], 1, & sig->parameters, + instructions, declarations); + + if (types[i].is_vector()) { + generate_vec_body_from_scalar(instructions, declarations); + + ir_function_signature *const vec_sig = + new ir_function_signature(& types[i]); + f->signatures.push_tail(vec_sig); + + generate_constructor_intro(& types[i], types[i].vector_elements, + & vec_sig->parameters, instructions, + declarations); + generate_vec_body_from_N_scalars(instructions, declarations); + } else { + assert(types[i].is_matrix()); + + generate_mat_body_from_scalar(instructions, declarations); + + ir_function_signature *const mat_sig = + new ir_function_signature(& types[i]); + f->signatures.push_tail(mat_sig); + + generate_constructor_intro(& types[i], + (types[i].vector_elements + * types[i].matrix_columns), + & mat_sig->parameters, instructions, + declarations); + generate_mat_body_from_N_scalars(instructions, 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; + } +} + + const glsl_type * glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns) { diff --git a/glsl_types.h b/glsl_types.h index 96c9a1b2a4..a795af2cd3 100644 --- a/glsl_types.h +++ b/glsl_types.h @@ -288,6 +288,10 @@ 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 @@ -87,6 +87,16 @@ ir_dereference::ir_dereference(ir_instruction *var) } +ir_dereference::ir_dereference(ir_instruction *var, + ir_instruction *array_index) + : ir_instruction(ir_op_dereference), mode(ir_reference_array), + var(var) +{ + this->type = (var != NULL) ? var->type : glsl_error_type; + this->selector.array_index = array_index; +} + + void ir_dereference::set_swizzle(unsigned x, unsigned y, unsigned z, unsigned w, unsigned count) @@ -393,6 +393,8 @@ class ir_dereference : public ir_instruction { public: ir_dereference(struct ir_instruction *); + ir_dereference(ir_instruction *variable, ir_instruction *array_index); + virtual void accept(ir_visitor *v) { v->visit(this); @@ -419,7 +421,7 @@ public: ir_instruction *var; union { - ir_expression *array_index; + ir_instruction *array_index; const char *field; struct ir_swizzle_mask swizzle; } selector; diff --git a/ir_print_visitor.cpp b/ir_print_visitor.cpp index f9f3d3f17d..ca9f759252 100644 --- a/ir_print_visitor.cpp +++ b/ir_print_visitor.cpp @@ -28,16 +28,12 @@ static void print_type(const glsl_type *t) { if (t->base_type == GLSL_TYPE_ARRAY) { - printf("array\n"); - printf(" ("); + printf("array ("); print_type(t->fields.array); - printf(")\n"); - - printf(" (%u)\n", t->length); - printf(")"); + printf(") (%u))", t->length); } else if (t->base_type == GLSL_TYPE_STRUCT) { - printf("struct (%s %u\n", t->name ? t->name : "@", t->length); - printf(" (FINISHME: structure fields go here)\n"); + printf("struct (%s %u ", t->name ? t->name : "@", t->length); + printf("(FINISHME: structure fields go here) "); printf(")"); } else { printf("%s", t->name); @@ -47,28 +43,30 @@ print_type(const glsl_type *t) void ir_print_visitor::visit(ir_variable *ir) { - printf("(declare \n"); + if (deref_depth) { + printf("(%s)", ir->name); + } else { + printf("(declare "); - const char *const cent = (ir->centroid) ? "centroid " : ""; - const char *const inv = (ir->invariant) ? "invariant " : ""; - const char *const mode[] = { "", "uniform ", "in ", "out ", "inout " }; - const char *const interp[] = { "", "flat", "noperspective" }; + const char *const cent = (ir->centroid) ? "centroid " : ""; + const char *const inv = (ir->invariant) ? "invariant " : ""; + const char *const mode[] = { "", "uniform ", "in ", "out ", "inout " }; + const char *const interp[] = { "", "flat", "noperspective" }; - printf(" (%s%s%s%s)\n", - cent, inv, mode[ir->mode], interp[ir->interpolation]); + printf("(%s%s%s%s) ", + cent, inv, mode[ir->mode], interp[ir->interpolation]); - printf(" ("); - print_type(ir->type); - printf(")\n"); - - printf(" (%s)\n", ir->name); - printf(")\n"); + printf("("); + print_type(ir->type); + printf(") "); + printf("(%s)) ", ir->name); + } } void ir_print_visitor::visit(ir_label *ir) { - printf("(label %s)\n", ir->label); + printf("\n(label %s)", ir->label); } @@ -88,49 +86,107 @@ void ir_print_visitor::visit(ir_function *ir) void ir_print_visitor::visit(ir_expression *ir) { - printf("%s:%d:\n", __func__, __LINE__); - (void) ir; + printf("(expression "); + + printf("(FINISHME: operator) "); + + printf("("); + if (ir->operands[0]) + ir->operands[0]->accept(this); + printf(") "); + + printf("("); + if (ir->operands[1]) + ir->operands[1]->accept(this); + printf(")) "); } void ir_print_visitor::visit(ir_dereference *ir) { - printf("%s:%d:\n", __func__, __LINE__); - (void) ir; + deref_depth++; + + switch (ir->mode) { + case ir_dereference::ir_reference_variable: { + const unsigned swiz[4] = { + ir->selector.swizzle.x, + ir->selector.swizzle.y, + ir->selector.swizzle.z, + ir->selector.swizzle.w, + }; + + printf("(var_ref "); + ir->var->accept(this); + printf("("); + for (unsigned i = 0; i < ir->selector.swizzle.num_components; i++) { + printf("%c", "xyzw"[swiz[i]]); + } + printf(")) "); + break; + } + case ir_dereference::ir_reference_array: + printf("(array_ref "); + ir->var->accept(this); + ir->selector.array_index->accept(this); + printf(") "); + break; + case ir_dereference::ir_reference_record: + printf("(record_ref "); + ir->var->accept(this); + printf("(%s)) ", ir->selector.field); + break; + } + + deref_depth--; } void ir_print_visitor::visit(ir_assignment *ir) { - printf("(assign\n"); + printf("(assign ("); - printf(" ("); if (ir->condition) ir->condition->accept(this); else printf("true"); - printf(")\n"); - printf(" ("); + printf(") ("); + ir->lhs->accept(this); - printf(")\n"); - printf(" ("); + printf(") ("); + ir->rhs->accept(this); - printf(")\n"); + printf(") "); } void ir_print_visitor::visit(ir_constant *ir) { - (void) ir; - - printf("(constant\n"); - printf(" ("); - print_type(ir->type); - printf(")\n"); - printf(" (FINISHME: value goes here)\n"); - printf(")\n"); + const glsl_type *const base_type = ir->type->get_base_type(); + + printf("(constant ("); + print_type(base_type); + printf(") "); + + const unsigned num_values = 1 + * ((ir->type->vector_elements > 0) ? ir->type->vector_elements : 1) + * ((ir->type->matrix_columns > 0) ? ir->type->matrix_columns : 1); + + printf("(%d) (", num_values); + for (unsigned i = 0; i < num_values; i++) { + if (i != 0) + printf(", "); + + switch (base_type->base_type) { + case GLSL_TYPE_UINT: printf("%u", ir->value.u[i]); break; + case GLSL_TYPE_INT: printf("%d", ir->value.i[i]); break; + case GLSL_TYPE_FLOAT: printf("%f", ir->value.f[i]); break; + case GLSL_TYPE_BOOL: printf("%d", ir->value.b[i]); break; + default: assert(0); + } + } + printf(")) "); } @@ -155,5 +211,5 @@ ir_print_visitor::visit(ir_return *ir) value->accept(this); } - printf(")\n"); + printf(")"); } diff --git a/ir_print_visitor.h b/ir_print_visitor.h index 121b7e8bb6..a4309c4f2a 100644 --- a/ir_print_visitor.h +++ b/ir_print_visitor.h @@ -35,6 +35,7 @@ class ir_print_visitor : public ir_visitor { public: ir_print_visitor() + : deref_depth(0) { /* empty */ } @@ -63,6 +64,9 @@ public: virtual void visit(ir_call *); virtual void visit(ir_return *); /*@}*/ + +private: + int deref_depth; }; #endif /* IR_PRINT_VISITOR_H */ |