* DEALINGS IN THE SOFTWARE.
*/
+#include <cstdio>
#include <stdlib.h>
#include "glsl_symbol_table.h"
#include "glsl_parser_extras.h"
#include "glsl_types.h"
#include "builtin_types.h"
+#include "hash_table.h"
+hash_table *glsl_type::array_types = NULL;
+
static void
add_types_to_symbol_table(glsl_symbol_table *symtab,
const struct glsl_type *types,
- unsigned num_types)
+ unsigned num_types, bool warn)
{
- unsigned i;
+ (void) warn;
- for (i = 0; i < num_types; i++) {
+ for (unsigned i = 0; i < num_types; i++) {
symtab->add_type(types[i].name, & types[i]);
}
}
generate_110_types(glsl_symbol_table *symtab)
{
add_types_to_symbol_table(symtab, builtin_core_types,
- Elements(builtin_core_types));
+ Elements(builtin_core_types),
+ false);
add_types_to_symbol_table(symtab, builtin_structure_types,
- Elements(builtin_structure_types));
+ Elements(builtin_structure_types),
+ false);
add_types_to_symbol_table(symtab, builtin_110_deprecated_structure_types,
- Elements(builtin_110_deprecated_structure_types));
- add_types_to_symbol_table(symtab, & void_type, 1);
+ Elements(builtin_110_deprecated_structure_types),
+ false);
+ add_types_to_symbol_table(symtab, & void_type, 1, false);
}
generate_110_types(symtab);
add_types_to_symbol_table(symtab, builtin_120_types,
- Elements(builtin_120_types));
+ Elements(builtin_120_types), false);
}
generate_120_types(symtab);
add_types_to_symbol_table(symtab, builtin_130_types,
- Elements(builtin_130_types));
+ Elements(builtin_130_types), false);
+}
+
+
+static void
+generate_ARB_texture_rectangle_types(glsl_symbol_table *symtab, bool warn)
+{
+ add_types_to_symbol_table(symtab, builtin_ARB_texture_rectangle_types,
+ Elements(builtin_ARB_texture_rectangle_types),
+ warn);
}
/* error */
break;
}
+
+ if (state->ARB_texture_rectangle_enable) {
+ generate_ARB_texture_rectangle_types(state->symbols,
+ state->ARB_texture_rectangle_warn);
+ }
}
{
switch (base_type) {
case GLSL_TYPE_UINT:
- return glsl_uint_type;
+ return uint_type;
case GLSL_TYPE_INT:
- return glsl_int_type;
+ return int_type;
case GLSL_TYPE_FLOAT:
- return glsl_float_type;
+ return float_type;
case GLSL_TYPE_BOOL:
- return glsl_bool_type;
+ return bool_type;
default:
- return glsl_error_type;
+ 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;
}
* parameters. These are used later to avoid having to use
* the symbol table.
*/
-static void
+static ir_label *
generate_constructor_intro(const glsl_type *type, unsigned parameter_count,
- exec_list *parameters, exec_list *instructions,
+ ir_function_signature *const signature,
+ exec_list *instructions,
ir_variable **declarations)
{
/* Names of parameters used in vector and matrix constructors
const glsl_type *const parameter_type = type->get_base_type();
- ir_label *const label = new ir_label(type->name);
+ 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;
- parameters->push_tail(var);
-
- var = new ir_variable(parameter_type, names[i]);
-
- var->mode = ir_var_in;
- instructions->push_tail(var);
+ signature->parameters.push_tail(var);
declarations[i] = var;
}
ir_variable *retval = new ir_variable(type, "__retval");
- instructions->push_tail(retval);
+ signature->body.push_tail(retval);
declarations[16] = retval;
+ return label;
}
/* 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 lhs_ref = new ir_dereference(declarations[16]);
ir_dereference *const rhs = new ir_dereference(declarations[0]);
- lhs->set_swizzle(0, 0, 0, 0, 1);
+ 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 retval = new ir_dereference(declarations[16]);
+ ir_dereference *const retref = new ir_dereference(declarations[16]);
- retval->set_swizzle(0, 0, 0, 0, declarations[16]->type->vector_elements);
+ ir_swizzle *retval = new ir_swizzle(retref, 0, 0, 0, 0,
+ declarations[16]->type->vector_elements);
- inst = new ir_return((ir_expression *) retval);
+ inst = new ir_return(retval);
instructions->push_tail(inst);
}
* __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 lhs_ref = 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;
+ 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((ir_expression *) retval);
+ inst = new ir_return(retval);
instructions->push_tail(inst);
}
instructions->push_tail(column);
- ir_dereference *const lhs = new ir_dereference(column);
+ ir_dereference *const lhs_ref = new ir_dereference(column);
ir_dereference *const rhs = new ir_dereference(declarations[0]);
- lhs->set_swizzle(0, 0, 0, 0, 1);
+ 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_float_type, &z);
+ 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 = new ir_dereference(column);
+ ir_dereference *const lhs_ref = new ir_dereference(column);
- lhs->set_swizzle(i, 0, 0, 0, 1);
+ 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 = new ir_dereference(column);
+ ir_dereference *const rhs_ref = 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_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_int_type, &i);
+ 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);
}
ir_dereference *const retval = new ir_dereference(declarations[16]);
- inst = new ir_return((ir_expression *) retval);
+ inst = new ir_return(retval);
instructions->push_tail(inst);
}
*/
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_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 =
+ ir_dereference *const component_access_ref =
new ir_dereference(row_access);
- component_access->selector.swizzle.x = j;
- component_access->selector.swizzle.num_components = 1;
+ 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]);
ir_dereference *retval = new ir_dereference(declarations[16]);
- inst = new ir_return((ir_expression *) retval);
+ inst = new ir_return(retval);
instructions->push_tail(inst);
}
* appropriate from-scalars constructor.
*/
ir_function_signature *const sig = new ir_function_signature(& types[i]);
- f->signatures.push_tail(sig);
+ f->add_signature(sig);
- generate_constructor_intro(& types[i], 1, & sig->parameters,
- instructions, declarations);
+ sig->definition =
+ generate_constructor_intro(& types[i], 1, sig,
+ instructions, declarations);
if (types[i].is_vector()) {
- generate_vec_body_from_scalar(instructions, declarations);
+ generate_vec_body_from_scalar(&sig->body, declarations);
ir_function_signature *const vec_sig =
new ir_function_signature(& types[i]);
- f->signatures.push_tail(vec_sig);
+ f->add_signature(vec_sig);
- generate_constructor_intro(& types[i], types[i].vector_elements,
- & vec_sig->parameters, instructions,
- declarations);
- generate_vec_body_from_N_scalars(instructions, declarations);
+ vec_sig->definition =
+ generate_constructor_intro(& types[i], types[i].vector_elements,
+ vec_sig, instructions,
+ declarations);
+ generate_vec_body_from_N_scalars(&sig->body, declarations);
} else {
assert(types[i].is_matrix());
- generate_mat_body_from_scalar(instructions, declarations);
+ generate_mat_body_from_scalar(&sig->body, 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);
+ f->add_signature(mat_sig);
+
+ mat_sig->definition =
+ generate_constructor_intro(& types[i],
+ (types[i].vector_elements
+ * types[i].matrix_columns),
+ mat_sig, instructions,
+ declarations);
generate_mat_body_from_N_scalars(instructions, declarations);
}
}
}
+glsl_type::glsl_type(const glsl_type *array, unsigned length) :
+ base_type(GLSL_TYPE_ARRAY),
+ sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
+ sampler_type(0),
+ vector_elements(0), matrix_columns(0),
+ name(NULL), length(length)
+{
+ this->fields.array = array;
+
+ /* Allow a maximum of 10 characters for the array size. This is enough
+ * for 32-bits of ~0. The extra 3 are for the '[', ']', and terminating
+ * NUL.
+ */
+ const unsigned name_length = strlen(array->name) + 10 + 3;
+ char *const n = (char *) malloc(name_length);
+
+ if (length == 0)
+ snprintf(n, name_length, "%s[]", array->name);
+ else
+ snprintf(n, name_length, "%s[%u]", array->name, length);
+
+ this->name = n;
+}
+
+
const glsl_type *
glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns)
{
- if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4))
- return glsl_error_type;
+ if (base_type == GLSL_TYPE_VOID)
+ return &void_type;
+ if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4))
+ return error_type;
/* Treat GLSL vectors as Nx1 matrices.
*/
if (columns == 1) {
switch (base_type) {
case GLSL_TYPE_UINT:
- return glsl_uint_type + (rows - 1);
+ return uint_type + (rows - 1);
case GLSL_TYPE_INT:
- return glsl_int_type + (rows - 1);
+ return int_type + (rows - 1);
case GLSL_TYPE_FLOAT:
- return glsl_float_type + (rows - 1);
+ return float_type + (rows - 1);
case GLSL_TYPE_BOOL:
- return glsl_bool_type + (rows - 1);
+ return bool_type + (rows - 1);
default:
- return glsl_error_type;
+ return error_type;
}
} else {
if ((base_type != GLSL_TYPE_FLOAT) || (rows == 1))
- return glsl_error_type;
+ return error_type;
/* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
* combinations are valid:
case IDX(4,2): return mat4x2_type;
case IDX(4,3): return mat4x3_type;
case IDX(4,4): return mat4_type;
- default: return glsl_error_type;
+ default: return error_type;
}
}
assert(!"Should not get here.");
- return glsl_error_type;
+ return error_type;
+}
+
+
+int
+glsl_type::array_key_compare(const void *a, const void *b)
+{
+ const glsl_type *const key1 = (glsl_type *) a;
+ const glsl_type *const key2 = (glsl_type *) b;
+
+ /* Return zero is the types match (there is zero difference) or non-zero
+ * otherwise.
+ */
+ return ((key1->fields.array == key2->fields.array)
+ && (key1->length == key2->length)) ? 0 : 1;
+}
+
+
+unsigned
+glsl_type::array_key_hash(const void *a)
+{
+ const glsl_type *const key = (glsl_type *) a;
+
+ const struct {
+ const glsl_type *t;
+ unsigned l;
+ char nul;
+ } hash_key = {
+ key->fields.array,
+ key->length,
+ '\0'
+ };
+
+ return hash_table_string_hash(& hash_key);
+}
+
+
+const glsl_type *
+glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
+{
+ const glsl_type key(base, array_size);
+
+ if (array_types == NULL) {
+ array_types = hash_table_ctor(64, array_key_hash, array_key_compare);
+ }
+
+ const glsl_type *t = (glsl_type *) hash_table_find(array_types, & key);
+ if (t == NULL) {
+ t = new glsl_type(base, array_size);
+
+ hash_table_insert(array_types, (void *) t, t);
+ }
+
+ assert(t->base_type == GLSL_TYPE_ARRAY);
+ assert(t->length == array_size);
+ assert(t->fields.array == base);
+
+ return t;
}
projects / mesa.git / blobdiff