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);
+}
+
+
+static void
+generate_EXT_texture_array_types(glsl_symbol_table *symtab, bool warn)
+{
+ add_types_to_symbol_table(symtab, builtin_EXT_texture_array_types,
+ Elements(builtin_EXT_texture_array_types),
+ warn);
}
/* error */
break;
}
+
+ if (state->ARB_texture_rectangle_enable) {
+ generate_ARB_texture_rectangle_types(state->symbols,
+ state->ARB_texture_rectangle_warn);
+ }
+
+ if (state->EXT_texture_array_enable && state->language_version < 130) {
+ // These are already included in 130; don't create twice.
+ generate_EXT_texture_array_types(state->symbols,
+ state->EXT_texture_array_warn);
+ }
}
ir_function *
-glsl_type::generate_constructor_prototype(glsl_symbol_table *symtab) const
+glsl_type::generate_constructor(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);
assert(added);
ir_function_signature *const sig = new ir_function_signature(this);
- f->signatures.push_tail(sig);
+ f->add_signature(sig);
+ ir_variable **declarations =
+ (ir_variable **) malloc(sizeof(ir_variable *) * this->length);
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);
+ ir_variable *var = (this->base_type == GLSL_TYPE_ARRAY)
+ ? new ir_variable(fields.array, param_name)
+ : new ir_variable(fields.structure[i].type, param_name);
var->mode = ir_var_in;
+ declarations[i] = var;
sig->parameters.push_tail(var);
}
+ /* Generate the body of the constructor. The body assigns each of the
+ * parameters to a portion of a local variable called __retval that has
+ * the same type as the constructor. After initializing __retval,
+ * __retval is returned.
+ */
+ ir_variable *retval = new ir_variable(this, "__retval");
+ sig->body.push_tail(retval);
+
+ for (unsigned i = 0; i < length; i++) {
+ ir_dereference *const lhs = (this->base_type == GLSL_TYPE_ARRAY)
+ ? (ir_dereference *) new ir_dereference_array(retval, new ir_constant(i))
+ : (ir_dereference *) new ir_dereference_record(retval, fields.structure[i].name);
+
+ ir_dereference *const rhs = new ir_dereference_variable(declarations[i]);
+ ir_instruction *const assign = new ir_assignment(lhs, rhs, NULL);
+
+ sig->body.push_tail(assign);
+ }
+
+ free(declarations);
+
+ ir_dereference *const retref = new ir_dereference_variable(retval);
+ ir_instruction *const inst = new ir_return(retref);
+ sig->body.push_tail(inst);
+
return f;
}
* 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 *
+static ir_function_signature *
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
const glsl_type *const parameter_type = type->get_base_type();
- ir_label *const label = new ir_label(type->name);
- instructions->push_tail(label);
+ ir_function_signature *const signature = new ir_function_signature(type);
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;
+ return signature;
}
/* 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_dereference *const lhs_ref =
+ new ir_dereference_variable(declarations[16]);
+ ir_dereference *const rhs = new ir_dereference_variable(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_dereference *const retref = new ir_dereference_variable(declarations[16]);
ir_swizzle *retval = new ir_swizzle(retref, 0, 0, 0, 0,
declarations[16]->type->vector_elements);
* __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_dereference *const lhs_ref =
+ new ir_dereference_variable(declarations[16]);
+ ir_dereference *const rhs = new ir_dereference_variable(declarations[i]);
- ir_swizzle *lhs = new ir_swizzle(lhs_ref, 1, 0, 0, 0, 1);
+ ir_swizzle *lhs = new ir_swizzle(lhs_ref, i, 0, 0, 0, 1);
inst = new ir_assignment(lhs, rhs, NULL);
instructions->push_tail(inst);
}
- ir_dereference *retval = new ir_dereference(declarations[16]);
+ ir_dereference *retval = new ir_dereference_variable(declarations[16]);
inst = new ir_return(retval);
instructions->push_tail(inst);
instructions->push_tail(column);
- ir_dereference *const lhs_ref = new ir_dereference(column);
- ir_dereference *const rhs = new ir_dereference(declarations[0]);
+ ir_dereference *const lhs_ref = new ir_dereference_variable(column);
+ ir_dereference *const rhs = new ir_dereference_variable(declarations[0]);
ir_swizzle *lhs = new ir_swizzle(lhs_ref, 0, 0, 0, 0, 1);
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_dereference *const lhs_ref = new ir_dereference_variable(column);
ir_swizzle *lhs = new ir_swizzle(lhs_ref, i, 0, 0, 0, 1);
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);
+ ir_dereference *const rhs_ref = new ir_dereference_variable(column);
/* This will be .xyyy when i=0, .yxyy when i=1, etc.
*/
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);
+ ir_dereference *const lhs =
+ new ir_dereference_array(declarations[16], idx);
inst = new ir_assignment(lhs, rhs, NULL);
instructions->push_tail(inst);
}
- ir_dereference *const retval = new ir_dereference(declarations[16]);
+ ir_dereference *const retval = new ir_dereference_variable(declarations[16]);
inst = new ir_return(retval);
instructions->push_tail(inst);
}
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);
+ new ir_dereference_array(declarations[16], row_index);
- ir_swizzle *component_access = new ir_swizzle(component_access_ref,
+ ir_swizzle *component_access = new ir_swizzle(row_access,
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 *const rhs =
+ new ir_dereference_variable(declarations[param]);
inst = new ir_assignment(component_access, rhs, NULL);
instructions->push_tail(inst);
}
}
- ir_dereference *retval = new ir_dereference(declarations[16]);
+ ir_dereference *retval = new ir_dereference_variable(declarations[16]);
inst = new ir_return(retval);
instructions->push_tail(inst);
if (types[i].is_scalar())
continue;
- /* Generate the function name and add it to the symbol table.
+ /* Generate the function block, add it to the symbol table, and emit it.
*/
ir_function *const f = new 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.
* 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);
-
- sig->definition =
- generate_constructor_intro(& types[i], 1, & sig->parameters,
- instructions, declarations);
+ ir_function_signature *const sig =
+ generate_constructor_intro(&types[i], 1, declarations);
+ f->add_signature(sig);
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);
-
- vec_sig->definition =
- generate_constructor_intro(& types[i], types[i].vector_elements,
- & vec_sig->parameters, instructions,
+ generate_constructor_intro(&types[i], types[i].vector_elements,
declarations);
- generate_vec_body_from_N_scalars(instructions, declarations);
+ f->add_signature(vec_sig);
+
+ generate_vec_body_from_N_scalars(&vec_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);
-
- mat_sig->definition =
- generate_constructor_intro(& types[i],
+ 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);
+ f->add_signature(mat_sig);
+
+ generate_mat_body_from_N_scalars(&mat_sig->body, declarations);
}
}
}
return t;
}
+
+
+const glsl_type *
+glsl_type::field_type(const char *name) const
+{
+ if (this->base_type != GLSL_TYPE_STRUCT)
+ return error_type;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ if (strcmp(name, this->fields.structure[i].name) == 0)
+ return this->fields.structure[i].type;
+ }
+
+ return error_type;
+}
+
+
+int
+glsl_type::field_index(const char *name) const
+{
+ if (this->base_type != GLSL_TYPE_STRUCT)
+ return -1;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ if (strcmp(name, this->fields.structure[i].name) == 0)
+ return i;
+ }
+
+ return -1;
+}