2 * Copyright © 2009 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
26 #include "main/core.h" /* for Elements */
27 #include "glsl_symbol_table.h"
28 #include "glsl_parser_extras.h"
29 #include "glsl_types.h"
30 #include "builtin_types.h"
32 #include "program/hash_table.h"
35 hash_table *glsl_type::array_types = NULL;
36 hash_table *glsl_type::record_types = NULL;
37 void *glsl_type::mem_ctx = NULL;
40 glsl_type::init_ralloc_type_ctx(void)
42 if (glsl_type::mem_ctx == NULL) {
43 glsl_type::mem_ctx = ralloc_autofree_context();
44 assert(glsl_type::mem_ctx != NULL);
48 glsl_type::glsl_type(GLenum gl_type,
49 glsl_base_type base_type, unsigned vector_elements,
50 unsigned matrix_columns, const char *name) :
53 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
55 vector_elements(vector_elements), matrix_columns(matrix_columns),
58 init_ralloc_type_ctx();
59 this->name = ralloc_strdup(this->mem_ctx, name);
60 /* Neither dimension is zero or both dimensions are zero.
62 assert((vector_elements == 0) == (matrix_columns == 0));
63 memset(& fields, 0, sizeof(fields));
66 glsl_type::glsl_type(GLenum gl_type,
67 enum glsl_sampler_dim dim, bool shadow, bool array,
68 unsigned type, const char *name) :
70 base_type(GLSL_TYPE_SAMPLER),
71 sampler_dimensionality(dim), sampler_shadow(shadow),
72 sampler_array(array), sampler_type(type),
73 vector_elements(0), matrix_columns(0),
76 init_ralloc_type_ctx();
77 this->name = ralloc_strdup(this->mem_ctx, name);
78 memset(& fields, 0, sizeof(fields));
81 glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
83 base_type(GLSL_TYPE_STRUCT),
84 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
86 vector_elements(0), matrix_columns(0),
91 init_ralloc_type_ctx();
92 this->name = ralloc_strdup(this->mem_ctx, name);
93 this->fields.structure = ralloc_array(this->mem_ctx,
94 glsl_struct_field, length);
95 for (i = 0; i < length; i++) {
96 this->fields.structure[i].type = fields[i].type;
97 this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
103 add_types_to_symbol_table(glsl_symbol_table *symtab,
104 const struct glsl_type *types,
105 unsigned num_types, bool warn)
109 for (unsigned i = 0; i < num_types; i++) {
110 symtab->add_type(types[i].name, & types[i]);
115 glsl_type::contains_sampler() const
117 if (this->is_array()) {
118 return this->fields.array->contains_sampler();
119 } else if (this->is_record()) {
120 for (unsigned int i = 0; i < this->length; i++) {
121 if (this->fields.structure[i].type->contains_sampler())
126 return this->is_sampler();
131 glsl_type::sampler_index() const
133 const glsl_type *const t = (this->is_array()) ? this->fields.array : this;
135 assert(t->is_sampler());
137 switch (t->sampler_dimensionality) {
138 case GLSL_SAMPLER_DIM_1D:
139 return (t->sampler_array) ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX;
140 case GLSL_SAMPLER_DIM_2D:
141 return (t->sampler_array) ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX;
142 case GLSL_SAMPLER_DIM_3D:
143 return TEXTURE_3D_INDEX;
144 case GLSL_SAMPLER_DIM_CUBE:
145 return TEXTURE_CUBE_INDEX;
146 case GLSL_SAMPLER_DIM_RECT:
147 return TEXTURE_RECT_INDEX;
148 case GLSL_SAMPLER_DIM_BUF:
149 return TEXTURE_BUFFER_INDEX;
150 case GLSL_SAMPLER_DIM_EXTERNAL:
151 return TEXTURE_EXTERNAL_INDEX;
153 assert(!"Should not get here.");
154 return TEXTURE_BUFFER_INDEX;
159 glsl_type::generate_100ES_types(glsl_symbol_table *symtab)
161 add_types_to_symbol_table(symtab, builtin_core_types,
162 Elements(builtin_core_types),
164 add_types_to_symbol_table(symtab, builtin_structure_types,
165 Elements(builtin_structure_types),
167 add_types_to_symbol_table(symtab, void_type, 1, false);
171 glsl_type::generate_110_types(glsl_symbol_table *symtab, bool add_deprecated)
173 generate_100ES_types(symtab);
175 add_types_to_symbol_table(symtab, builtin_110_types,
176 Elements(builtin_110_types),
178 add_types_to_symbol_table(symtab, &_sampler3D_type, 1, false);
179 if (add_deprecated) {
180 add_types_to_symbol_table(symtab, builtin_110_deprecated_structure_types,
181 Elements(builtin_110_deprecated_structure_types),
188 glsl_type::generate_120_types(glsl_symbol_table *symtab, bool add_deprecated)
190 generate_110_types(symtab, add_deprecated);
192 add_types_to_symbol_table(symtab, builtin_120_types,
193 Elements(builtin_120_types), false);
198 glsl_type::generate_130_types(glsl_symbol_table *symtab, bool add_deprecated)
200 generate_120_types(symtab, add_deprecated);
202 add_types_to_symbol_table(symtab, builtin_130_types,
203 Elements(builtin_130_types), false);
204 generate_EXT_texture_array_types(symtab, false);
209 glsl_type::generate_140_types(glsl_symbol_table *symtab)
211 generate_130_types(symtab, false);
213 add_types_to_symbol_table(symtab, builtin_140_types,
214 Elements(builtin_140_types), false);
216 add_types_to_symbol_table(symtab, builtin_EXT_texture_buffer_object_types,
217 Elements(builtin_EXT_texture_buffer_object_types),
223 glsl_type::generate_ARB_texture_rectangle_types(glsl_symbol_table *symtab,
226 add_types_to_symbol_table(symtab, builtin_ARB_texture_rectangle_types,
227 Elements(builtin_ARB_texture_rectangle_types),
233 glsl_type::generate_EXT_texture_array_types(glsl_symbol_table *symtab,
236 add_types_to_symbol_table(symtab, builtin_EXT_texture_array_types,
237 Elements(builtin_EXT_texture_array_types),
243 glsl_type::generate_OES_texture_3D_types(glsl_symbol_table *symtab, bool warn)
245 add_types_to_symbol_table(symtab, &_sampler3D_type, 1, warn);
250 glsl_type::generate_OES_EGL_image_external_types(glsl_symbol_table *symtab,
253 add_types_to_symbol_table(symtab, builtin_OES_EGL_image_external_types,
254 Elements(builtin_OES_EGL_image_external_types),
259 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state)
261 switch (state->language_version) {
263 assert(state->es_shader);
264 glsl_type::generate_100ES_types(state->symbols);
267 glsl_type::generate_110_types(state->symbols, true);
270 glsl_type::generate_120_types(state->symbols, true);
273 glsl_type::generate_130_types(state->symbols, true);
276 glsl_type::generate_140_types(state->symbols);
283 if (state->ARB_texture_rectangle_enable ||
284 state->language_version >= 140) {
285 glsl_type::generate_ARB_texture_rectangle_types(state->symbols,
286 state->ARB_texture_rectangle_warn);
288 if (state->OES_texture_3D_enable && state->language_version == 100) {
289 glsl_type::generate_OES_texture_3D_types(state->symbols,
290 state->OES_texture_3D_warn);
293 if (state->EXT_texture_array_enable && state->language_version < 130) {
294 // These are already included in 130; don't create twice.
295 glsl_type::generate_EXT_texture_array_types(state->symbols,
296 state->EXT_texture_array_warn);
299 /* We cannot check for language_version == 100 here because we need the
300 * types to support fixed-function program generation. But this is fine
301 * since the extension is never enabled for OpenGL contexts.
303 if (state->OES_EGL_image_external_enable) {
304 glsl_type::generate_OES_EGL_image_external_types(state->symbols,
305 state->OES_EGL_image_external_warn);
310 const glsl_type *glsl_type::get_base_type() const
317 case GLSL_TYPE_FLOAT:
327 const glsl_type *glsl_type::get_scalar_type() const
329 const glsl_type *type = this;
332 while (type->base_type == GLSL_TYPE_ARRAY)
333 type = type->fields.array;
335 /* Handle vectors and matrices */
336 switch (type->base_type) {
341 case GLSL_TYPE_FLOAT:
344 /* Handle everything else */
351 _mesa_glsl_release_types(void)
353 if (glsl_type::array_types != NULL) {
354 hash_table_dtor(glsl_type::array_types);
355 glsl_type::array_types = NULL;
358 if (glsl_type::record_types != NULL) {
359 hash_table_dtor(glsl_type::record_types);
360 glsl_type::record_types = NULL;
365 glsl_type::glsl_type(const glsl_type *array, unsigned length) :
366 base_type(GLSL_TYPE_ARRAY),
367 sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
369 vector_elements(0), matrix_columns(0),
370 name(NULL), length(length)
372 this->fields.array = array;
373 /* Inherit the gl type of the base. The GL type is used for
374 * uniform/statevar handling in Mesa and the arrayness of the type
375 * is represented by the size rather than the type.
377 this->gl_type = array->gl_type;
379 /* Allow a maximum of 10 characters for the array size. This is enough
380 * for 32-bits of ~0. The extra 3 are for the '[', ']', and terminating
383 const unsigned name_length = strlen(array->name) + 10 + 3;
384 char *const n = (char *) ralloc_size(this->mem_ctx, name_length);
387 snprintf(n, name_length, "%s[]", array->name);
389 snprintf(n, name_length, "%s[%u]", array->name, length);
396 glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns)
398 if (base_type == GLSL_TYPE_VOID)
401 if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4))
404 /* Treat GLSL vectors as Nx1 matrices.
409 return uint_type + (rows - 1);
411 return int_type + (rows - 1);
412 case GLSL_TYPE_FLOAT:
413 return float_type + (rows - 1);
415 return bool_type + (rows - 1);
420 if ((base_type != GLSL_TYPE_FLOAT) || (rows == 1))
423 /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
424 * combinations are valid:
432 #define IDX(c,r) (((c-1)*3) + (r-1))
434 switch (IDX(columns, rows)) {
435 case IDX(2,2): return mat2_type;
436 case IDX(2,3): return mat2x3_type;
437 case IDX(2,4): return mat2x4_type;
438 case IDX(3,2): return mat3x2_type;
439 case IDX(3,3): return mat3_type;
440 case IDX(3,4): return mat3x4_type;
441 case IDX(4,2): return mat4x2_type;
442 case IDX(4,3): return mat4x3_type;
443 case IDX(4,4): return mat4_type;
444 default: return error_type;
448 assert(!"Should not get here.");
454 glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
457 if (array_types == NULL) {
458 array_types = hash_table_ctor(64, hash_table_string_hash,
459 hash_table_string_compare);
462 /* Generate a name using the base type pointer in the key. This is
463 * done because the name of the base type may not be unique across
464 * shaders. For example, two shaders may have different record types
468 snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
470 const glsl_type *t = (glsl_type *) hash_table_find(array_types, key);
472 t = new glsl_type(base, array_size);
474 hash_table_insert(array_types, (void *) t, ralloc_strdup(mem_ctx, key));
477 assert(t->base_type == GLSL_TYPE_ARRAY);
478 assert(t->length == array_size);
479 assert(t->fields.array == base);
486 glsl_type::record_key_compare(const void *a, const void *b)
488 const glsl_type *const key1 = (glsl_type *) a;
489 const glsl_type *const key2 = (glsl_type *) b;
491 /* Return zero is the types match (there is zero difference) or non-zero
494 if (strcmp(key1->name, key2->name) != 0)
497 if (key1->length != key2->length)
500 for (unsigned i = 0; i < key1->length; i++) {
501 if (key1->fields.structure[i].type != key2->fields.structure[i].type)
503 if (strcmp(key1->fields.structure[i].name,
504 key2->fields.structure[i].name) != 0)
513 glsl_type::record_key_hash(const void *a)
515 const glsl_type *const key = (glsl_type *) a;
519 size = snprintf(hash_key, sizeof(hash_key), "%08x", key->length);
521 for (unsigned i = 0; i < key->length; i++) {
522 if (size >= sizeof(hash_key))
525 size += snprintf(& hash_key[size], sizeof(hash_key) - size,
526 "%p", (void *) key->fields.structure[i].type);
529 return hash_table_string_hash(& hash_key);
534 glsl_type::get_record_instance(const glsl_struct_field *fields,
538 const glsl_type key(fields, num_fields, name);
540 if (record_types == NULL) {
541 record_types = hash_table_ctor(64, record_key_hash, record_key_compare);
544 const glsl_type *t = (glsl_type *) hash_table_find(record_types, & key);
546 t = new glsl_type(fields, num_fields, name);
548 hash_table_insert(record_types, (void *) t, t);
551 assert(t->base_type == GLSL_TYPE_STRUCT);
552 assert(t->length == num_fields);
553 assert(strcmp(t->name, name) == 0);
560 glsl_type::field_type(const char *name) const
562 if (this->base_type != GLSL_TYPE_STRUCT)
565 for (unsigned i = 0; i < this->length; i++) {
566 if (strcmp(name, this->fields.structure[i].name) == 0)
567 return this->fields.structure[i].type;
575 glsl_type::field_index(const char *name) const
577 if (this->base_type != GLSL_TYPE_STRUCT)
580 for (unsigned i = 0; i < this->length; i++) {
581 if (strcmp(name, this->fields.structure[i].name) == 0)
590 glsl_type::component_slots() const
592 switch (this->base_type) {
595 case GLSL_TYPE_FLOAT:
597 return this->components();
599 case GLSL_TYPE_STRUCT: {
602 for (unsigned i = 0; i < this->length; i++)
603 size += this->fields.structure[i].type->component_slots();
608 case GLSL_TYPE_ARRAY:
609 return this->length * this->fields.array->component_slots();
617 glsl_type::can_implicitly_convert_to(const glsl_type *desired) const
622 /* There is no conversion among matrix types. */
623 if (this->matrix_columns > 1 || desired->matrix_columns > 1)
626 /* int and uint can be converted to float. */
627 return desired->is_float()
628 && this->is_integer()
629 && this->vector_elements == desired->vector_elements;
633 glsl_type::std140_base_alignment(bool row_major) const
635 /* (1) If the member is a scalar consuming <N> basic machine units, the
636 * base alignment is <N>.
638 * (2) If the member is a two- or four-component vector with components
639 * consuming <N> basic machine units, the base alignment is 2<N> or
640 * 4<N>, respectively.
642 * (3) If the member is a three-component vector with components consuming
643 * <N> basic machine units, the base alignment is 4<N>.
645 if (this->is_scalar() || this->is_vector()) {
646 switch (this->vector_elements) {
657 /* (4) If the member is an array of scalars or vectors, the base alignment
658 * and array stride are set to match the base alignment of a single
659 * array element, according to rules (1), (2), and (3), and rounded up
660 * to the base alignment of a vec4. The array may have padding at the
661 * end; the base offset of the member following the array is rounded up
662 * to the next multiple of the base alignment.
664 * (6) If the member is an array of <S> column-major matrices with <C>
665 * columns and <R> rows, the matrix is stored identically to a row of
666 * <S>*<C> column vectors with <R> components each, according to rule
669 * (8) If the member is an array of <S> row-major matrices with <C> columns
670 * and <R> rows, the matrix is stored identically to a row of <S>*<R>
671 * row vectors with <C> components each, according to rule (4).
673 * (10) If the member is an array of <S> structures, the <S> elements of
674 * the array are laid out in order, according to rule (9).
676 if (this->is_array()) {
677 if (this->fields.array->is_scalar() ||
678 this->fields.array->is_vector() ||
679 this->fields.array->is_matrix()) {
680 return MAX2(this->fields.array->std140_base_alignment(row_major), 16);
682 assert(this->fields.array->is_record());
683 return this->fields.array->std140_base_alignment(row_major);
687 /* (5) If the member is a column-major matrix with <C> columns and
688 * <R> rows, the matrix is stored identically to an array of
689 * <C> column vectors with <R> components each, according to
692 * (7) If the member is a row-major matrix with <C> columns and <R>
693 * rows, the matrix is stored identically to an array of <R>
694 * row vectors with <C> components each, according to rule (4).
696 if (this->is_matrix()) {
697 const struct glsl_type *vec_type;
699 vec_type = get_instance(GLSL_TYPE_FLOAT, this->vector_elements, 1);
701 vec_type = get_instance(GLSL_TYPE_FLOAT, this->matrix_columns, 1);
704 return vec_type->std140_base_alignment(false);
707 /* (9) If the member is a structure, the base alignment of the
708 * structure is <N>, where <N> is the largest base alignment
709 * value of any of its members, and rounded up to the base
710 * alignment of a vec4. The individual members of this
711 * sub-structure are then assigned offsets by applying this set
712 * of rules recursively, where the base offset of the first
713 * member of the sub-structure is equal to the aligned offset
714 * of the structure. The structure may have padding at the end;
715 * the base offset of the member following the sub-structure is
716 * rounded up to the next multiple of the base alignment of the
719 if (this->is_record()) {
720 unsigned base_alignment = 16;
721 for (unsigned i = 0; i < this->length; i++) {
722 const struct glsl_type *field_type = this->fields.structure[i].type;
723 base_alignment = MAX2(base_alignment,
724 field_type->std140_base_alignment(row_major));
726 return base_alignment;
729 assert(!"not reached");
734 align(unsigned val, unsigned align)
736 return (val + align - 1) / align * align;
740 glsl_type::std140_size(bool row_major) const
742 /* (1) If the member is a scalar consuming <N> basic machine units, the
743 * base alignment is <N>.
745 * (2) If the member is a two- or four-component vector with components
746 * consuming <N> basic machine units, the base alignment is 2<N> or
747 * 4<N>, respectively.
749 * (3) If the member is a three-component vector with components consuming
750 * <N> basic machine units, the base alignment is 4<N>.
752 if (this->is_scalar() || this->is_vector()) {
753 return this->vector_elements * 4;
756 /* (5) If the member is a column-major matrix with <C> columns and
757 * <R> rows, the matrix is stored identically to an array of
758 * <C> column vectors with <R> components each, according to
761 * (6) If the member is an array of <S> column-major matrices with <C>
762 * columns and <R> rows, the matrix is stored identically to a row of
763 * <S>*<C> column vectors with <R> components each, according to rule
766 * (7) If the member is a row-major matrix with <C> columns and <R>
767 * rows, the matrix is stored identically to an array of <R>
768 * row vectors with <C> components each, according to rule (4).
770 * (8) If the member is an array of <S> row-major matrices with <C> columns
771 * and <R> rows, the matrix is stored identically to a row of <S>*<R>
772 * row vectors with <C> components each, according to rule (4).
774 if (this->is_matrix() || (this->is_array() &&
775 this->fields.array->is_matrix())) {
776 const struct glsl_type *element_type;
777 const struct glsl_type *vec_type;
778 unsigned int array_len;
780 if (this->is_array()) {
781 element_type = this->fields.array;
782 array_len = this->length;
789 vec_type = get_instance(GLSL_TYPE_FLOAT,
790 element_type->matrix_columns, 1);
791 array_len *= element_type->vector_elements;
793 vec_type = get_instance(GLSL_TYPE_FLOAT,
794 element_type->vector_elements, 1);
795 array_len *= element_type->matrix_columns;
797 const glsl_type *array_type = glsl_type::get_array_instance(vec_type,
800 return array_type->std140_size(false);
803 /* (4) If the member is an array of scalars or vectors, the base alignment
804 * and array stride are set to match the base alignment of a single
805 * array element, according to rules (1), (2), and (3), and rounded up
806 * to the base alignment of a vec4. The array may have padding at the
807 * end; the base offset of the member following the array is rounded up
808 * to the next multiple of the base alignment.
810 * (10) If the member is an array of <S> structures, the <S> elements of
811 * the array are laid out in order, according to rule (9).
813 if (this->is_array()) {
814 if (this->fields.array->is_record()) {
815 return this->length * this->fields.array->std140_size(row_major);
817 unsigned element_base_align =
818 this->fields.array->std140_base_alignment(row_major);
819 return this->length * MAX2(element_base_align, 16);
823 /* (9) If the member is a structure, the base alignment of the
824 * structure is <N>, where <N> is the largest base alignment
825 * value of any of its members, and rounded up to the base
826 * alignment of a vec4. The individual members of this
827 * sub-structure are then assigned offsets by applying this set
828 * of rules recursively, where the base offset of the first
829 * member of the sub-structure is equal to the aligned offset
830 * of the structure. The structure may have padding at the end;
831 * the base offset of the member following the sub-structure is
832 * rounded up to the next multiple of the base alignment of the
835 if (this->is_record()) {
837 for (unsigned i = 0; i < this->length; i++) {
838 const struct glsl_type *field_type = this->fields.structure[i].type;
839 unsigned align = field_type->std140_base_alignment(row_major);
840 size = (size + align - 1) / align * align;
841 size += field_type->std140_size(row_major);
844 this->fields.structure[0].type->std140_base_alignment(row_major));
848 assert(!"not reached");