LIBCOMPILER_FILES = \
builtin_type_macros.h \
+ glsl_types.cpp \
+ glsl_types.h \
shader_enums.c \
shader_enums.h
--- /dev/null
+/*
+ * Copyright © 2009 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include "main/macros.h"
+#include "glsl/glsl_parser_extras.h"
+#include "glsl_types.h"
+#include "util/hash_table.h"
+
+
+mtx_t glsl_type::mutex = _MTX_INITIALIZER_NP;
+hash_table *glsl_type::array_types = NULL;
+hash_table *glsl_type::record_types = NULL;
+hash_table *glsl_type::interface_types = NULL;
+hash_table *glsl_type::subroutine_types = NULL;
+void *glsl_type::mem_ctx = NULL;
+
+void
+glsl_type::init_ralloc_type_ctx(void)
+{
+ if (glsl_type::mem_ctx == NULL) {
+ glsl_type::mem_ctx = ralloc_autofree_context();
+ assert(glsl_type::mem_ctx != NULL);
+ }
+}
+
+glsl_type::glsl_type(GLenum gl_type,
+ glsl_base_type base_type, unsigned vector_elements,
+ unsigned matrix_columns, const char *name) :
+ gl_type(gl_type),
+ base_type(base_type),
+ sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
+ sampler_type(0), interface_packing(0),
+ vector_elements(vector_elements), matrix_columns(matrix_columns),
+ length(0)
+{
+ mtx_lock(&glsl_type::mutex);
+
+ init_ralloc_type_ctx();
+ assert(name != NULL);
+ this->name = ralloc_strdup(this->mem_ctx, name);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ /* Neither dimension is zero or both dimensions are zero.
+ */
+ assert((vector_elements == 0) == (matrix_columns == 0));
+ memset(& fields, 0, sizeof(fields));
+}
+
+glsl_type::glsl_type(GLenum gl_type, glsl_base_type base_type,
+ enum glsl_sampler_dim dim, bool shadow, bool array,
+ unsigned type, const char *name) :
+ gl_type(gl_type),
+ base_type(base_type),
+ sampler_dimensionality(dim), sampler_shadow(shadow),
+ sampler_array(array), sampler_type(type), interface_packing(0),
+ length(0)
+{
+ mtx_lock(&glsl_type::mutex);
+
+ init_ralloc_type_ctx();
+ assert(name != NULL);
+ this->name = ralloc_strdup(this->mem_ctx, name);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ memset(& fields, 0, sizeof(fields));
+
+ if (base_type == GLSL_TYPE_SAMPLER) {
+ /* Samplers take no storage whatsoever. */
+ matrix_columns = vector_elements = 0;
+ } else {
+ matrix_columns = vector_elements = 1;
+ }
+}
+
+glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
+ const char *name) :
+ gl_type(0),
+ base_type(GLSL_TYPE_STRUCT),
+ sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
+ sampler_type(0), interface_packing(0),
+ vector_elements(0), matrix_columns(0),
+ length(num_fields)
+{
+ unsigned int i;
+
+ mtx_lock(&glsl_type::mutex);
+
+ init_ralloc_type_ctx();
+ assert(name != NULL);
+ this->name = ralloc_strdup(this->mem_ctx, name);
+ this->fields.structure = ralloc_array(this->mem_ctx,
+ glsl_struct_field, length);
+
+ for (i = 0; i < length; i++) {
+ this->fields.structure[i].type = fields[i].type;
+ this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
+ fields[i].name);
+ this->fields.structure[i].location = fields[i].location;
+ this->fields.structure[i].interpolation = fields[i].interpolation;
+ this->fields.structure[i].centroid = fields[i].centroid;
+ this->fields.structure[i].sample = fields[i].sample;
+ this->fields.structure[i].matrix_layout = fields[i].matrix_layout;
+ this->fields.structure[i].patch = fields[i].patch;
+ this->fields.structure[i].image_read_only = fields[i].image_read_only;
+ this->fields.structure[i].image_write_only = fields[i].image_write_only;
+ this->fields.structure[i].image_coherent = fields[i].image_coherent;
+ this->fields.structure[i].image_volatile = fields[i].image_volatile;
+ this->fields.structure[i].image_restrict = fields[i].image_restrict;
+ this->fields.structure[i].precision = fields[i].precision;
+ }
+
+ mtx_unlock(&glsl_type::mutex);
+}
+
+glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
+ enum glsl_interface_packing packing, const char *name) :
+ gl_type(0),
+ base_type(GLSL_TYPE_INTERFACE),
+ sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
+ sampler_type(0), interface_packing((unsigned) packing),
+ vector_elements(0), matrix_columns(0),
+ length(num_fields)
+{
+ unsigned int i;
+
+ mtx_lock(&glsl_type::mutex);
+
+ init_ralloc_type_ctx();
+ assert(name != NULL);
+ this->name = ralloc_strdup(this->mem_ctx, name);
+ this->fields.structure = ralloc_array(this->mem_ctx,
+ glsl_struct_field, length);
+ for (i = 0; i < length; i++) {
+ this->fields.structure[i].type = fields[i].type;
+ this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
+ fields[i].name);
+ this->fields.structure[i].location = fields[i].location;
+ this->fields.structure[i].interpolation = fields[i].interpolation;
+ this->fields.structure[i].centroid = fields[i].centroid;
+ this->fields.structure[i].sample = fields[i].sample;
+ this->fields.structure[i].matrix_layout = fields[i].matrix_layout;
+ this->fields.structure[i].patch = fields[i].patch;
+ this->fields.structure[i].precision = fields[i].precision;
+ }
+
+ mtx_unlock(&glsl_type::mutex);
+}
+
+glsl_type::glsl_type(const char *subroutine_name) :
+ gl_type(0),
+ base_type(GLSL_TYPE_SUBROUTINE),
+ sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
+ sampler_type(0), interface_packing(0),
+ vector_elements(1), matrix_columns(1),
+ length(0)
+{
+ mtx_lock(&glsl_type::mutex);
+
+ init_ralloc_type_ctx();
+ assert(subroutine_name != NULL);
+ this->name = ralloc_strdup(this->mem_ctx, subroutine_name);
+ mtx_unlock(&glsl_type::mutex);
+}
+
+bool
+glsl_type::contains_sampler() const
+{
+ if (this->is_array()) {
+ return this->fields.array->contains_sampler();
+ } else if (this->is_record()) {
+ for (unsigned int i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type->contains_sampler())
+ return true;
+ }
+ return false;
+ } else {
+ return this->is_sampler();
+ }
+}
+
+
+bool
+glsl_type::contains_integer() const
+{
+ if (this->is_array()) {
+ return this->fields.array->contains_integer();
+ } else if (this->is_record()) {
+ for (unsigned int i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type->contains_integer())
+ return true;
+ }
+ return false;
+ } else {
+ return this->is_integer();
+ }
+}
+
+bool
+glsl_type::contains_double() const
+{
+ if (this->is_array()) {
+ return this->fields.array->contains_double();
+ } else if (this->is_record()) {
+ for (unsigned int i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type->contains_double())
+ return true;
+ }
+ return false;
+ } else {
+ return this->is_double();
+ }
+}
+
+bool
+glsl_type::contains_opaque() const {
+ switch (base_type) {
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_IMAGE:
+ case GLSL_TYPE_ATOMIC_UINT:
+ return true;
+ case GLSL_TYPE_ARRAY:
+ return fields.array->contains_opaque();
+ case GLSL_TYPE_STRUCT:
+ for (unsigned int i = 0; i < length; i++) {
+ if (fields.structure[i].type->contains_opaque())
+ return true;
+ }
+ return false;
+ default:
+ return false;
+ }
+}
+
+bool
+glsl_type::contains_subroutine() const
+{
+ if (this->is_array()) {
+ return this->fields.array->contains_subroutine();
+ } else if (this->is_record()) {
+ for (unsigned int i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type->contains_subroutine())
+ return true;
+ }
+ return false;
+ } else {
+ return this->is_subroutine();
+ }
+}
+
+gl_texture_index
+glsl_type::sampler_index() const
+{
+ const glsl_type *const t = (this->is_array()) ? this->fields.array : this;
+
+ assert(t->is_sampler());
+
+ switch (t->sampler_dimensionality) {
+ case GLSL_SAMPLER_DIM_1D:
+ return (t->sampler_array) ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX;
+ case GLSL_SAMPLER_DIM_2D:
+ return (t->sampler_array) ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX;
+ case GLSL_SAMPLER_DIM_3D:
+ return TEXTURE_3D_INDEX;
+ case GLSL_SAMPLER_DIM_CUBE:
+ return (t->sampler_array) ? TEXTURE_CUBE_ARRAY_INDEX : TEXTURE_CUBE_INDEX;
+ case GLSL_SAMPLER_DIM_RECT:
+ return TEXTURE_RECT_INDEX;
+ case GLSL_SAMPLER_DIM_BUF:
+ return TEXTURE_BUFFER_INDEX;
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ return TEXTURE_EXTERNAL_INDEX;
+ case GLSL_SAMPLER_DIM_MS:
+ return (t->sampler_array) ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : TEXTURE_2D_MULTISAMPLE_INDEX;
+ default:
+ assert(!"Should not get here.");
+ return TEXTURE_BUFFER_INDEX;
+ }
+}
+
+bool
+glsl_type::contains_image() const
+{
+ if (this->is_array()) {
+ return this->fields.array->contains_image();
+ } else if (this->is_record()) {
+ for (unsigned int i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type->contains_image())
+ return true;
+ }
+ return false;
+ } else {
+ return this->is_image();
+ }
+}
+
+const glsl_type *glsl_type::get_base_type() const
+{
+ switch (base_type) {
+ case GLSL_TYPE_UINT:
+ return uint_type;
+ case GLSL_TYPE_INT:
+ return int_type;
+ case GLSL_TYPE_FLOAT:
+ return float_type;
+ case GLSL_TYPE_DOUBLE:
+ return double_type;
+ case GLSL_TYPE_BOOL:
+ return bool_type;
+ default:
+ return error_type;
+ }
+}
+
+
+const glsl_type *glsl_type::get_scalar_type() const
+{
+ const glsl_type *type = this;
+
+ /* Handle arrays */
+ while (type->base_type == GLSL_TYPE_ARRAY)
+ type = type->fields.array;
+
+ /* Handle vectors and matrices */
+ switch (type->base_type) {
+ case GLSL_TYPE_UINT:
+ return uint_type;
+ case GLSL_TYPE_INT:
+ return int_type;
+ case GLSL_TYPE_FLOAT:
+ return float_type;
+ case GLSL_TYPE_DOUBLE:
+ return double_type;
+ case GLSL_TYPE_BOOL:
+ return bool_type;
+ default:
+ /* Handle everything else */
+ return type;
+ }
+}
+
+
+void
+_mesa_glsl_release_types(void)
+{
+ /* Should only be called during atexit (either when unloading shared
+ * object, or if process terminates), so no mutex-locking should be
+ * necessary.
+ */
+ if (glsl_type::array_types != NULL) {
+ _mesa_hash_table_destroy(glsl_type::array_types, NULL);
+ glsl_type::array_types = NULL;
+ }
+
+ if (glsl_type::record_types != NULL) {
+ _mesa_hash_table_destroy(glsl_type::record_types, NULL);
+ glsl_type::record_types = NULL;
+ }
+
+ if (glsl_type::interface_types != NULL) {
+ _mesa_hash_table_destroy(glsl_type::interface_types, NULL);
+ glsl_type::interface_types = NULL;
+ }
+}
+
+
+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), interface_packing(0),
+ vector_elements(0), matrix_columns(0),
+ length(length), name(NULL)
+{
+ this->fields.array = array;
+ /* Inherit the gl type of the base. The GL type is used for
+ * uniform/statevar handling in Mesa and the arrayness of the type
+ * is represented by the size rather than the type.
+ */
+ this->gl_type = array->gl_type;
+
+ /* 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;
+
+ mtx_lock(&glsl_type::mutex);
+ char *const n = (char *) ralloc_size(this->mem_ctx, name_length);
+ mtx_unlock(&glsl_type::mutex);
+
+ if (length == 0)
+ snprintf(n, name_length, "%s[]", array->name);
+ else {
+ /* insert outermost dimensions in the correct spot
+ * otherwise the dimension order will be backwards
+ */
+ const char *pos = strchr(array->name, '[');
+ if (pos) {
+ int idx = pos - array->name;
+ snprintf(n, idx+1, "%s", array->name);
+ snprintf(n + idx, name_length - idx, "[%u]%s",
+ length, array->name + idx);
+ } else {
+ snprintf(n, name_length, "%s[%u]", array->name, length);
+ }
+ }
+
+ this->name = n;
+}
+
+
+const glsl_type *
+glsl_type::vec(unsigned components)
+{
+ if (components == 0 || components > 4)
+ return error_type;
+
+ static const glsl_type *const ts[] = {
+ float_type, vec2_type, vec3_type, vec4_type
+ };
+ return ts[components - 1];
+}
+
+const glsl_type *
+glsl_type::dvec(unsigned components)
+{
+ if (components == 0 || components > 4)
+ return error_type;
+
+ static const glsl_type *const ts[] = {
+ double_type, dvec2_type, dvec3_type, dvec4_type
+ };
+ return ts[components - 1];
+}
+
+const glsl_type *
+glsl_type::ivec(unsigned components)
+{
+ if (components == 0 || components > 4)
+ return error_type;
+
+ static const glsl_type *const ts[] = {
+ int_type, ivec2_type, ivec3_type, ivec4_type
+ };
+ return ts[components - 1];
+}
+
+
+const glsl_type *
+glsl_type::uvec(unsigned components)
+{
+ if (components == 0 || components > 4)
+ return error_type;
+
+ static const glsl_type *const ts[] = {
+ uint_type, uvec2_type, uvec3_type, uvec4_type
+ };
+ return ts[components - 1];
+}
+
+
+const glsl_type *
+glsl_type::bvec(unsigned components)
+{
+ if (components == 0 || components > 4)
+ return error_type;
+
+ static const glsl_type *const ts[] = {
+ bool_type, bvec2_type, bvec3_type, bvec4_type
+ };
+ return ts[components - 1];
+}
+
+
+const glsl_type *
+glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns)
+{
+ 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 uvec(rows);
+ case GLSL_TYPE_INT:
+ return ivec(rows);
+ case GLSL_TYPE_FLOAT:
+ return vec(rows);
+ case GLSL_TYPE_DOUBLE:
+ return dvec(rows);
+ case GLSL_TYPE_BOOL:
+ return bvec(rows);
+ default:
+ return error_type;
+ }
+ } else {
+ if ((base_type != GLSL_TYPE_FLOAT && base_type != GLSL_TYPE_DOUBLE) || (rows == 1))
+ return error_type;
+
+ /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
+ * combinations are valid:
+ *
+ * 1 2 3 4
+ * 1
+ * 2 x x x
+ * 3 x x x
+ * 4 x x x
+ */
+#define IDX(c,r) (((c-1)*3) + (r-1))
+
+ if (base_type == GLSL_TYPE_DOUBLE) {
+ switch (IDX(columns, rows)) {
+ case IDX(2,2): return dmat2_type;
+ case IDX(2,3): return dmat2x3_type;
+ case IDX(2,4): return dmat2x4_type;
+ case IDX(3,2): return dmat3x2_type;
+ case IDX(3,3): return dmat3_type;
+ case IDX(3,4): return dmat3x4_type;
+ case IDX(4,2): return dmat4x2_type;
+ case IDX(4,3): return dmat4x3_type;
+ case IDX(4,4): return dmat4_type;
+ default: return error_type;
+ }
+ } else {
+ switch (IDX(columns, rows)) {
+ case IDX(2,2): return mat2_type;
+ case IDX(2,3): return mat2x3_type;
+ case IDX(2,4): return mat2x4_type;
+ case IDX(3,2): return mat3x2_type;
+ case IDX(3,3): return mat3_type;
+ case IDX(3,4): return mat3x4_type;
+ case IDX(4,2): return mat4x2_type;
+ case IDX(4,3): return mat4x3_type;
+ case IDX(4,4): return mat4_type;
+ default: return error_type;
+ }
+ }
+ }
+
+ assert(!"Should not get here.");
+ return error_type;
+}
+
+const glsl_type *
+glsl_type::get_sampler_instance(enum glsl_sampler_dim dim,
+ bool shadow,
+ bool array,
+ glsl_base_type type)
+{
+ switch (type) {
+ case GLSL_TYPE_FLOAT:
+ switch (dim) {
+ case GLSL_SAMPLER_DIM_1D:
+ if (shadow)
+ return (array ? sampler1DArrayShadow_type : sampler1DShadow_type);
+ else
+ return (array ? sampler1DArray_type : sampler1D_type);
+ case GLSL_SAMPLER_DIM_2D:
+ if (shadow)
+ return (array ? sampler2DArrayShadow_type : sampler2DShadow_type);
+ else
+ return (array ? sampler2DArray_type : sampler2D_type);
+ case GLSL_SAMPLER_DIM_3D:
+ if (shadow || array)
+ return error_type;
+ else
+ return sampler3D_type;
+ case GLSL_SAMPLER_DIM_CUBE:
+ if (shadow)
+ return (array ? samplerCubeArrayShadow_type : samplerCubeShadow_type);
+ else
+ return (array ? samplerCubeArray_type : samplerCube_type);
+ case GLSL_SAMPLER_DIM_RECT:
+ if (array)
+ return error_type;
+ if (shadow)
+ return sampler2DRectShadow_type;
+ else
+ return sampler2DRect_type;
+ case GLSL_SAMPLER_DIM_BUF:
+ if (shadow || array)
+ return error_type;
+ else
+ return samplerBuffer_type;
+ case GLSL_SAMPLER_DIM_MS:
+ if (shadow)
+ return error_type;
+ return (array ? sampler2DMSArray_type : sampler2DMS_type);
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ if (shadow || array)
+ return error_type;
+ else
+ return samplerExternalOES_type;
+ }
+ case GLSL_TYPE_INT:
+ if (shadow)
+ return error_type;
+ switch (dim) {
+ case GLSL_SAMPLER_DIM_1D:
+ return (array ? isampler1DArray_type : isampler1D_type);
+ case GLSL_SAMPLER_DIM_2D:
+ return (array ? isampler2DArray_type : isampler2D_type);
+ case GLSL_SAMPLER_DIM_3D:
+ if (array)
+ return error_type;
+ return isampler3D_type;
+ case GLSL_SAMPLER_DIM_CUBE:
+ return (array ? isamplerCubeArray_type : isamplerCube_type);
+ case GLSL_SAMPLER_DIM_RECT:
+ if (array)
+ return error_type;
+ return isampler2DRect_type;
+ case GLSL_SAMPLER_DIM_BUF:
+ if (array)
+ return error_type;
+ return isamplerBuffer_type;
+ case GLSL_SAMPLER_DIM_MS:
+ return (array ? isampler2DMSArray_type : isampler2DMS_type);
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ return error_type;
+ }
+ case GLSL_TYPE_UINT:
+ if (shadow)
+ return error_type;
+ switch (dim) {
+ case GLSL_SAMPLER_DIM_1D:
+ return (array ? usampler1DArray_type : usampler1D_type);
+ case GLSL_SAMPLER_DIM_2D:
+ return (array ? usampler2DArray_type : usampler2D_type);
+ case GLSL_SAMPLER_DIM_3D:
+ if (array)
+ return error_type;
+ return usampler3D_type;
+ case GLSL_SAMPLER_DIM_CUBE:
+ return (array ? usamplerCubeArray_type : usamplerCube_type);
+ case GLSL_SAMPLER_DIM_RECT:
+ if (array)
+ return error_type;
+ return usampler2DRect_type;
+ case GLSL_SAMPLER_DIM_BUF:
+ if (array)
+ return error_type;
+ return usamplerBuffer_type;
+ case GLSL_SAMPLER_DIM_MS:
+ return (array ? usampler2DMSArray_type : usampler2DMS_type);
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ return error_type;
+ }
+ default:
+ return error_type;
+ }
+
+ unreachable("switch statement above should be complete");
+}
+
+const glsl_type *
+glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
+{
+ /* Generate a name using the base type pointer in the key. This is
+ * done because the name of the base type may not be unique across
+ * shaders. For example, two shaders may have different record types
+ * named 'foo'.
+ */
+ char key[128];
+ snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
+
+ mtx_lock(&glsl_type::mutex);
+
+ if (array_types == NULL) {
+ array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
+ _mesa_key_string_equal);
+ }
+
+ const struct hash_entry *entry = _mesa_hash_table_search(array_types, key);
+ if (entry == NULL) {
+ mtx_unlock(&glsl_type::mutex);
+ const glsl_type *t = new glsl_type(base, array_size);
+ mtx_lock(&glsl_type::mutex);
+
+ entry = _mesa_hash_table_insert(array_types,
+ ralloc_strdup(mem_ctx, key),
+ (void *) t);
+ }
+
+ assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_ARRAY);
+ assert(((glsl_type *) entry->data)->length == array_size);
+ assert(((glsl_type *) entry->data)->fields.array == base);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ return (glsl_type *) entry->data;
+}
+
+
+bool
+glsl_type::record_compare(const glsl_type *b) const
+{
+ if (this->length != b->length)
+ return false;
+
+ if (this->interface_packing != b->interface_packing)
+ return false;
+
+ /* From the GLSL 4.20 specification (Sec 4.2):
+ *
+ * "Structures must have the same name, sequence of type names, and
+ * type definitions, and field names to be considered the same type."
+ *
+ * GLSL ES behaves the same (Ver 1.00 Sec 4.2.4, Ver 3.00 Sec 4.2.5).
+ *
+ * Note that we cannot force type name check when comparing unnamed
+ * structure types, these have a unique name assigned during parsing.
+ */
+ if (!this->is_anonymous() && !b->is_anonymous())
+ if (strcmp(this->name, b->name) != 0)
+ return false;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ if (this->fields.structure[i].type != b->fields.structure[i].type)
+ return false;
+ if (strcmp(this->fields.structure[i].name,
+ b->fields.structure[i].name) != 0)
+ return false;
+ if (this->fields.structure[i].matrix_layout
+ != b->fields.structure[i].matrix_layout)
+ return false;
+ if (this->fields.structure[i].location
+ != b->fields.structure[i].location)
+ return false;
+ if (this->fields.structure[i].interpolation
+ != b->fields.structure[i].interpolation)
+ return false;
+ if (this->fields.structure[i].centroid
+ != b->fields.structure[i].centroid)
+ return false;
+ if (this->fields.structure[i].sample
+ != b->fields.structure[i].sample)
+ return false;
+ if (this->fields.structure[i].patch
+ != b->fields.structure[i].patch)
+ return false;
+ if (this->fields.structure[i].image_read_only
+ != b->fields.structure[i].image_read_only)
+ return false;
+ if (this->fields.structure[i].image_write_only
+ != b->fields.structure[i].image_write_only)
+ return false;
+ if (this->fields.structure[i].image_coherent
+ != b->fields.structure[i].image_coherent)
+ return false;
+ if (this->fields.structure[i].image_volatile
+ != b->fields.structure[i].image_volatile)
+ return false;
+ if (this->fields.structure[i].image_restrict
+ != b->fields.structure[i].image_restrict)
+ return false;
+ if (this->fields.structure[i].precision
+ != b->fields.structure[i].precision)
+ return false;
+ }
+
+ return true;
+}
+
+
+bool
+glsl_type::record_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 strcmp(key1->name, key2->name) == 0 && key1->record_compare(key2);
+}
+
+
+/**
+ * Generate an integer hash value for a glsl_type structure type.
+ */
+unsigned
+glsl_type::record_key_hash(const void *a)
+{
+ const glsl_type *const key = (glsl_type *) a;
+ uintptr_t hash = key->length;
+ unsigned retval;
+
+ for (unsigned i = 0; i < key->length; i++) {
+ /* casting pointer to uintptr_t */
+ hash = (hash * 13 ) + (uintptr_t) key->fields.structure[i].type;
+ }
+
+ if (sizeof(hash) == 8)
+ retval = (hash & 0xffffffff) ^ ((uint64_t) hash >> 32);
+ else
+ retval = hash;
+
+ return retval;
+}
+
+
+const glsl_type *
+glsl_type::get_record_instance(const glsl_struct_field *fields,
+ unsigned num_fields,
+ const char *name)
+{
+ const glsl_type key(fields, num_fields, name);
+
+ mtx_lock(&glsl_type::mutex);
+
+ if (record_types == NULL) {
+ record_types = _mesa_hash_table_create(NULL, record_key_hash,
+ record_key_compare);
+ }
+
+ const struct hash_entry *entry = _mesa_hash_table_search(record_types,
+ &key);
+ if (entry == NULL) {
+ mtx_unlock(&glsl_type::mutex);
+ const glsl_type *t = new glsl_type(fields, num_fields, name);
+ mtx_lock(&glsl_type::mutex);
+
+ entry = _mesa_hash_table_insert(record_types, t, (void *) t);
+ }
+
+ assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_STRUCT);
+ assert(((glsl_type *) entry->data)->length == num_fields);
+ assert(strcmp(((glsl_type *) entry->data)->name, name) == 0);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ return (glsl_type *) entry->data;
+}
+
+
+const glsl_type *
+glsl_type::get_interface_instance(const glsl_struct_field *fields,
+ unsigned num_fields,
+ enum glsl_interface_packing packing,
+ const char *block_name)
+{
+ const glsl_type key(fields, num_fields, packing, block_name);
+
+ mtx_lock(&glsl_type::mutex);
+
+ if (interface_types == NULL) {
+ interface_types = _mesa_hash_table_create(NULL, record_key_hash,
+ record_key_compare);
+ }
+
+ const struct hash_entry *entry = _mesa_hash_table_search(interface_types,
+ &key);
+ if (entry == NULL) {
+ mtx_unlock(&glsl_type::mutex);
+ const glsl_type *t = new glsl_type(fields, num_fields,
+ packing, block_name);
+ mtx_lock(&glsl_type::mutex);
+
+ entry = _mesa_hash_table_insert(interface_types, t, (void *) t);
+ }
+
+ assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_INTERFACE);
+ assert(((glsl_type *) entry->data)->length == num_fields);
+ assert(strcmp(((glsl_type *) entry->data)->name, block_name) == 0);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ return (glsl_type *) entry->data;
+}
+
+const glsl_type *
+glsl_type::get_subroutine_instance(const char *subroutine_name)
+{
+ const glsl_type key(subroutine_name);
+
+ mtx_lock(&glsl_type::mutex);
+
+ if (subroutine_types == NULL) {
+ subroutine_types = _mesa_hash_table_create(NULL, record_key_hash,
+ record_key_compare);
+ }
+
+ const struct hash_entry *entry = _mesa_hash_table_search(subroutine_types,
+ &key);
+ if (entry == NULL) {
+ mtx_unlock(&glsl_type::mutex);
+ const glsl_type *t = new glsl_type(subroutine_name);
+ mtx_lock(&glsl_type::mutex);
+
+ entry = _mesa_hash_table_insert(subroutine_types, t, (void *) t);
+ }
+
+ assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_SUBROUTINE);
+ assert(strcmp(((glsl_type *) entry->data)->name, subroutine_name) == 0);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ return (glsl_type *) entry->data;
+}
+
+
+const glsl_type *
+glsl_type::get_mul_type(const glsl_type *type_a, const glsl_type *type_b)
+{
+ if (type_a == type_b) {
+ return type_a;
+ } else if (type_a->is_matrix() && type_b->is_matrix()) {
+ /* Matrix multiply. The columns of A must match the rows of B. Given
+ * the other previously tested constraints, this means the vector type
+ * of a row from A must be the same as the vector type of a column from
+ * B.
+ */
+ if (type_a->row_type() == type_b->column_type()) {
+ /* The resulting matrix has the number of columns of matrix B and
+ * the number of rows of matrix A. We get the row count of A by
+ * looking at the size of a vector that makes up a column. The
+ * transpose (size of a row) is done for B.
+ */
+ const glsl_type *const type =
+ get_instance(type_a->base_type,
+ type_a->column_type()->vector_elements,
+ type_b->row_type()->vector_elements);
+ assert(type != error_type);
+
+ return type;
+ }
+ } else if (type_a->is_matrix()) {
+ /* A is a matrix and B is a column vector. Columns of A must match
+ * rows of B. Given the other previously tested constraints, this
+ * means the vector type of a row from A must be the same as the
+ * vector the type of B.
+ */
+ if (type_a->row_type() == type_b) {
+ /* The resulting vector has a number of elements equal to
+ * the number of rows of matrix A. */
+ const glsl_type *const type =
+ get_instance(type_a->base_type,
+ type_a->column_type()->vector_elements,
+ 1);
+ assert(type != error_type);
+
+ return type;
+ }
+ } else {
+ assert(type_b->is_matrix());
+
+ /* A is a row vector and B is a matrix. Columns of A must match rows
+ * of B. Given the other previously tested constraints, this means
+ * the type of A must be the same as the vector type of a column from
+ * B.
+ */
+ if (type_a == type_b->column_type()) {
+ /* The resulting vector has a number of elements equal to
+ * the number of columns of matrix B. */
+ const glsl_type *const type =
+ get_instance(type_a->base_type,
+ type_b->row_type()->vector_elements,
+ 1);
+ assert(type != error_type);
+
+ return type;
+ }
+ }
+
+ return error_type;
+}
+
+
+const glsl_type *
+glsl_type::field_type(const char *name) const
+{
+ if (this->base_type != GLSL_TYPE_STRUCT
+ && this->base_type != GLSL_TYPE_INTERFACE)
+ 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
+ && this->base_type != GLSL_TYPE_INTERFACE)
+ return -1;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ if (strcmp(name, this->fields.structure[i].name) == 0)
+ return i;
+ }
+
+ return -1;
+}
+
+
+unsigned
+glsl_type::component_slots() const
+{
+ switch (this->base_type) {
+ case GLSL_TYPE_UINT:
+ case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_BOOL:
+ return this->components();
+
+ case GLSL_TYPE_DOUBLE:
+ return 2 * this->components();
+
+ case GLSL_TYPE_STRUCT:
+ case GLSL_TYPE_INTERFACE: {
+ unsigned size = 0;
+
+ for (unsigned i = 0; i < this->length; i++)
+ size += this->fields.structure[i].type->component_slots();
+
+ return size;
+ }
+
+ case GLSL_TYPE_ARRAY:
+ return this->length * this->fields.array->component_slots();
+
+ case GLSL_TYPE_IMAGE:
+ return 1;
+ case GLSL_TYPE_SUBROUTINE:
+ return 1;
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_ATOMIC_UINT:
+ case GLSL_TYPE_VOID:
+ case GLSL_TYPE_ERROR:
+ break;
+ }
+
+ return 0;
+}
+
+unsigned
+glsl_type::record_location_offset(unsigned length) const
+{
+ unsigned offset = 0;
+ const glsl_type *t = this->without_array();
+ if (t->is_record()) {
+ assert(length <= t->length);
+
+ for (unsigned i = 0; i < length; i++) {
+ const glsl_type *st = t->fields.structure[i].type;
+ const glsl_type *wa = st->without_array();
+ if (wa->is_record()) {
+ unsigned r_offset = wa->record_location_offset(wa->length);
+ offset += st->is_array() ?
+ st->arrays_of_arrays_size() * r_offset : r_offset;
+ } else if (st->is_array() && st->fields.array->is_array()) {
+ unsigned outer_array_size = st->length;
+ const glsl_type *base_type = st->fields.array;
+
+ /* For arrays of arrays the outer arrays take up a uniform
+ * slot for each element. The innermost array elements share a
+ * single slot so we ignore the innermost array when calculating
+ * the offset.
+ */
+ while (base_type->fields.array->is_array()) {
+ outer_array_size = outer_array_size * base_type->length;
+ base_type = base_type->fields.array;
+ }
+ offset += outer_array_size;
+ } else {
+ /* We dont worry about arrays here because unless the array
+ * contains a structure or another array it only takes up a single
+ * uniform slot.
+ */
+ offset += 1;
+ }
+ }
+ }
+ return offset;
+}
+
+unsigned
+glsl_type::uniform_locations() const
+{
+ unsigned size = 0;
+
+ switch (this->base_type) {
+ case GLSL_TYPE_UINT:
+ case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_DOUBLE:
+ case GLSL_TYPE_BOOL:
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_IMAGE:
+ case GLSL_TYPE_SUBROUTINE:
+ return 1;
+
+ case GLSL_TYPE_STRUCT:
+ case GLSL_TYPE_INTERFACE:
+ for (unsigned i = 0; i < this->length; i++)
+ size += this->fields.structure[i].type->uniform_locations();
+ return size;
+ case GLSL_TYPE_ARRAY:
+ return this->length * this->fields.array->uniform_locations();
+ default:
+ return 0;
+ }
+}
+
+bool
+glsl_type::can_implicitly_convert_to(const glsl_type *desired,
+ _mesa_glsl_parse_state *state) const
+{
+ if (this == desired)
+ return true;
+
+ /* There is no conversion among matrix types. */
+ if (this->matrix_columns > 1 || desired->matrix_columns > 1)
+ return false;
+
+ /* Vector size must match. */
+ if (this->vector_elements != desired->vector_elements)
+ return false;
+
+ /* int and uint can be converted to float. */
+ if (desired->is_float() && this->is_integer())
+ return true;
+
+ /* With GLSL 4.0 / ARB_gpu_shader5, int can be converted to uint.
+ * Note that state may be NULL here, when resolving function calls in the
+ * linker. By this time, all the state-dependent checks have already
+ * happened though, so allow anything that's allowed in any shader version. */
+ if ((!state || state->is_version(400, 0) || state->ARB_gpu_shader5_enable) &&
+ desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT)
+ return true;
+
+ /* No implicit conversions from double. */
+ if ((!state || state->has_double()) && this->is_double())
+ return false;
+
+ /* Conversions from different types to double. */
+ if ((!state || state->has_double()) && desired->is_double()) {
+ if (this->is_float())
+ return true;
+ if (this->is_integer())
+ return true;
+ }
+
+ return false;
+}
+
+unsigned
+glsl_type::std140_base_alignment(bool row_major) const
+{
+ unsigned N = is_double() ? 8 : 4;
+
+ /* (1) If the member is a scalar consuming <N> basic machine units, the
+ * base alignment is <N>.
+ *
+ * (2) If the member is a two- or four-component vector with components
+ * consuming <N> basic machine units, the base alignment is 2<N> or
+ * 4<N>, respectively.
+ *
+ * (3) If the member is a three-component vector with components consuming
+ * <N> basic machine units, the base alignment is 4<N>.
+ */
+ if (this->is_scalar() || this->is_vector()) {
+ switch (this->vector_elements) {
+ case 1:
+ return N;
+ case 2:
+ return 2 * N;
+ case 3:
+ case 4:
+ return 4 * N;
+ }
+ }
+
+ /* (4) If the member is an array of scalars or vectors, the base alignment
+ * and array stride are set to match the base alignment of a single
+ * array element, according to rules (1), (2), and (3), and rounded up
+ * to the base alignment of a vec4. The array may have padding at the
+ * end; the base offset of the member following the array is rounded up
+ * to the next multiple of the base alignment.
+ *
+ * (6) If the member is an array of <S> column-major matrices with <C>
+ * columns and <R> rows, the matrix is stored identically to a row of
+ * <S>*<C> column vectors with <R> components each, according to rule
+ * (4).
+ *
+ * (8) If the member is an array of <S> row-major matrices with <C> columns
+ * and <R> rows, the matrix is stored identically to a row of <S>*<R>
+ * row vectors with <C> components each, according to rule (4).
+ *
+ * (10) If the member is an array of <S> structures, the <S> elements of
+ * the array are laid out in order, according to rule (9).
+ */
+ if (this->is_array()) {
+ if (this->fields.array->is_scalar() ||
+ this->fields.array->is_vector() ||
+ this->fields.array->is_matrix()) {
+ return MAX2(this->fields.array->std140_base_alignment(row_major), 16);
+ } else {
+ assert(this->fields.array->is_record() ||
+ this->fields.array->is_array());
+ return this->fields.array->std140_base_alignment(row_major);
+ }
+ }
+
+ /* (5) If the member is a column-major matrix with <C> columns and
+ * <R> rows, the matrix is stored identically to an array of
+ * <C> column vectors with <R> components each, according to
+ * rule (4).
+ *
+ * (7) If the member is a row-major matrix with <C> columns and <R>
+ * rows, the matrix is stored identically to an array of <R>
+ * row vectors with <C> components each, according to rule (4).
+ */
+ if (this->is_matrix()) {
+ const struct glsl_type *vec_type, *array_type;
+ int c = this->matrix_columns;
+ int r = this->vector_elements;
+
+ if (row_major) {
+ vec_type = get_instance(base_type, c, 1);
+ array_type = glsl_type::get_array_instance(vec_type, r);
+ } else {
+ vec_type = get_instance(base_type, r, 1);
+ array_type = glsl_type::get_array_instance(vec_type, c);
+ }
+
+ return array_type->std140_base_alignment(false);
+ }
+
+ /* (9) If the member is a structure, the base alignment of the
+ * structure is <N>, where <N> is the largest base alignment
+ * value of any of its members, and rounded up to the base
+ * alignment of a vec4. The individual members of this
+ * sub-structure are then assigned offsets by applying this set
+ * of rules recursively, where the base offset of the first
+ * member of the sub-structure is equal to the aligned offset
+ * of the structure. The structure may have padding at the end;
+ * the base offset of the member following the sub-structure is
+ * rounded up to the next multiple of the base alignment of the
+ * structure.
+ */
+ if (this->is_record()) {
+ unsigned base_alignment = 16;
+ for (unsigned i = 0; i < this->length; i++) {
+ bool field_row_major = row_major;
+ const enum glsl_matrix_layout matrix_layout =
+ glsl_matrix_layout(this->fields.structure[i].matrix_layout);
+ if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
+ field_row_major = true;
+ } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
+ field_row_major = false;
+ }
+
+ const struct glsl_type *field_type = this->fields.structure[i].type;
+ base_alignment = MAX2(base_alignment,
+ field_type->std140_base_alignment(field_row_major));
+ }
+ return base_alignment;
+ }
+
+ assert(!"not reached");
+ return -1;
+}
+
+unsigned
+glsl_type::std140_size(bool row_major) const
+{
+ unsigned N = is_double() ? 8 : 4;
+
+ /* (1) If the member is a scalar consuming <N> basic machine units, the
+ * base alignment is <N>.
+ *
+ * (2) If the member is a two- or four-component vector with components
+ * consuming <N> basic machine units, the base alignment is 2<N> or
+ * 4<N>, respectively.
+ *
+ * (3) If the member is a three-component vector with components consuming
+ * <N> basic machine units, the base alignment is 4<N>.
+ */
+ if (this->is_scalar() || this->is_vector()) {
+ return this->vector_elements * N;
+ }
+
+ /* (5) If the member is a column-major matrix with <C> columns and
+ * <R> rows, the matrix is stored identically to an array of
+ * <C> column vectors with <R> components each, according to
+ * rule (4).
+ *
+ * (6) If the member is an array of <S> column-major matrices with <C>
+ * columns and <R> rows, the matrix is stored identically to a row of
+ * <S>*<C> column vectors with <R> components each, according to rule
+ * (4).
+ *
+ * (7) If the member is a row-major matrix with <C> columns and <R>
+ * rows, the matrix is stored identically to an array of <R>
+ * row vectors with <C> components each, according to rule (4).
+ *
+ * (8) If the member is an array of <S> row-major matrices with <C> columns
+ * and <R> rows, the matrix is stored identically to a row of <S>*<R>
+ * row vectors with <C> components each, according to rule (4).
+ */
+ if (this->without_array()->is_matrix()) {
+ const struct glsl_type *element_type;
+ const struct glsl_type *vec_type;
+ unsigned int array_len;
+
+ if (this->is_array()) {
+ element_type = this->without_array();
+ array_len = this->arrays_of_arrays_size();
+ } else {
+ element_type = this;
+ array_len = 1;
+ }
+
+ if (row_major) {
+ vec_type = get_instance(element_type->base_type,
+ element_type->matrix_columns, 1);
+
+ array_len *= element_type->vector_elements;
+ } else {
+ vec_type = get_instance(element_type->base_type,
+ element_type->vector_elements, 1);
+ array_len *= element_type->matrix_columns;
+ }
+ const glsl_type *array_type = glsl_type::get_array_instance(vec_type,
+ array_len);
+
+ return array_type->std140_size(false);
+ }
+
+ /* (4) If the member is an array of scalars or vectors, the base alignment
+ * and array stride are set to match the base alignment of a single
+ * array element, according to rules (1), (2), and (3), and rounded up
+ * to the base alignment of a vec4. The array may have padding at the
+ * end; the base offset of the member following the array is rounded up
+ * to the next multiple of the base alignment.
+ *
+ * (10) If the member is an array of <S> structures, the <S> elements of
+ * the array are laid out in order, according to rule (9).
+ */
+ if (this->is_array()) {
+ if (this->without_array()->is_record()) {
+ return this->arrays_of_arrays_size() *
+ this->without_array()->std140_size(row_major);
+ } else {
+ unsigned element_base_align =
+ this->without_array()->std140_base_alignment(row_major);
+ return this->arrays_of_arrays_size() * MAX2(element_base_align, 16);
+ }
+ }
+
+ /* (9) If the member is a structure, the base alignment of the
+ * structure is <N>, where <N> is the largest base alignment
+ * value of any of its members, and rounded up to the base
+ * alignment of a vec4. The individual members of this
+ * sub-structure are then assigned offsets by applying this set
+ * of rules recursively, where the base offset of the first
+ * member of the sub-structure is equal to the aligned offset
+ * of the structure. The structure may have padding at the end;
+ * the base offset of the member following the sub-structure is
+ * rounded up to the next multiple of the base alignment of the
+ * structure.
+ */
+ if (this->is_record() || this->is_interface()) {
+ unsigned size = 0;
+ unsigned max_align = 0;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ bool field_row_major = row_major;
+ const enum glsl_matrix_layout matrix_layout =
+ glsl_matrix_layout(this->fields.structure[i].matrix_layout);
+ if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
+ field_row_major = true;
+ } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
+ field_row_major = false;
+ }
+
+ const struct glsl_type *field_type = this->fields.structure[i].type;
+ unsigned align = field_type->std140_base_alignment(field_row_major);
+
+ /* Ignore unsized arrays when calculating size */
+ if (field_type->is_unsized_array())
+ continue;
+
+ size = glsl_align(size, align);
+ size += field_type->std140_size(field_row_major);
+
+ max_align = MAX2(align, max_align);
+
+ if (field_type->is_record() && (i + 1 < this->length))
+ size = glsl_align(size, 16);
+ }
+ size = glsl_align(size, MAX2(max_align, 16));
+ return size;
+ }
+
+ assert(!"not reached");
+ return -1;
+}
+
+unsigned
+glsl_type::std430_base_alignment(bool row_major) const
+{
+
+ unsigned N = is_double() ? 8 : 4;
+
+ /* (1) If the member is a scalar consuming <N> basic machine units, the
+ * base alignment is <N>.
+ *
+ * (2) If the member is a two- or four-component vector with components
+ * consuming <N> basic machine units, the base alignment is 2<N> or
+ * 4<N>, respectively.
+ *
+ * (3) If the member is a three-component vector with components consuming
+ * <N> basic machine units, the base alignment is 4<N>.
+ */
+ if (this->is_scalar() || this->is_vector()) {
+ switch (this->vector_elements) {
+ case 1:
+ return N;
+ case 2:
+ return 2 * N;
+ case 3:
+ case 4:
+ return 4 * N;
+ }
+ }
+
+ /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout":
+ *
+ * "When using the std430 storage layout, shader storage blocks will be
+ * laid out in buffer storage identically to uniform and shader storage
+ * blocks using the std140 layout, except that the base alignment and
+ * stride of arrays of scalars and vectors in rule 4 and of structures
+ * in rule 9 are not rounded up a multiple of the base alignment of a vec4.
+ */
+
+ /* (1) If the member is a scalar consuming <N> basic machine units, the
+ * base alignment is <N>.
+ *
+ * (2) If the member is a two- or four-component vector with components
+ * consuming <N> basic machine units, the base alignment is 2<N> or
+ * 4<N>, respectively.
+ *
+ * (3) If the member is a three-component vector with components consuming
+ * <N> basic machine units, the base alignment is 4<N>.
+ */
+ if (this->is_array())
+ return this->fields.array->std430_base_alignment(row_major);
+
+ /* (5) If the member is a column-major matrix with <C> columns and
+ * <R> rows, the matrix is stored identically to an array of
+ * <C> column vectors with <R> components each, according to
+ * rule (4).
+ *
+ * (7) If the member is a row-major matrix with <C> columns and <R>
+ * rows, the matrix is stored identically to an array of <R>
+ * row vectors with <C> components each, according to rule (4).
+ */
+ if (this->is_matrix()) {
+ const struct glsl_type *vec_type, *array_type;
+ int c = this->matrix_columns;
+ int r = this->vector_elements;
+
+ if (row_major) {
+ vec_type = get_instance(base_type, c, 1);
+ array_type = glsl_type::get_array_instance(vec_type, r);
+ } else {
+ vec_type = get_instance(base_type, r, 1);
+ array_type = glsl_type::get_array_instance(vec_type, c);
+ }
+
+ return array_type->std430_base_alignment(false);
+ }
+
+ /* (9) If the member is a structure, the base alignment of the
+ * structure is <N>, where <N> is the largest base alignment
+ * value of any of its members, and rounded up to the base
+ * alignment of a vec4. The individual members of this
+ * sub-structure are then assigned offsets by applying this set
+ * of rules recursively, where the base offset of the first
+ * member of the sub-structure is equal to the aligned offset
+ * of the structure. The structure may have padding at the end;
+ * the base offset of the member following the sub-structure is
+ * rounded up to the next multiple of the base alignment of the
+ * structure.
+ */
+ if (this->is_record()) {
+ unsigned base_alignment = 0;
+ for (unsigned i = 0; i < this->length; i++) {
+ bool field_row_major = row_major;
+ const enum glsl_matrix_layout matrix_layout =
+ glsl_matrix_layout(this->fields.structure[i].matrix_layout);
+ if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
+ field_row_major = true;
+ } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
+ field_row_major = false;
+ }
+
+ const struct glsl_type *field_type = this->fields.structure[i].type;
+ base_alignment = MAX2(base_alignment,
+ field_type->std430_base_alignment(field_row_major));
+ }
+ assert(base_alignment > 0);
+ return base_alignment;
+ }
+ assert(!"not reached");
+ return -1;
+}
+
+unsigned
+glsl_type::std430_array_stride(bool row_major) const
+{
+ unsigned N = is_double() ? 8 : 4;
+
+ /* Notice that the array stride of a vec3 is not 3 * N but 4 * N.
+ * See OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout"
+ *
+ * (3) If the member is a three-component vector with components consuming
+ * <N> basic machine units, the base alignment is 4<N>.
+ */
+ if (this->is_vector() && this->vector_elements == 3)
+ return 4 * N;
+
+ /* By default use std430_size(row_major) */
+ return this->std430_size(row_major);
+}
+
+unsigned
+glsl_type::std430_size(bool row_major) const
+{
+ unsigned N = is_double() ? 8 : 4;
+
+ /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout":
+ *
+ * "When using the std430 storage layout, shader storage blocks will be
+ * laid out in buffer storage identically to uniform and shader storage
+ * blocks using the std140 layout, except that the base alignment and
+ * stride of arrays of scalars and vectors in rule 4 and of structures
+ * in rule 9 are not rounded up a multiple of the base alignment of a vec4.
+ */
+ if (this->is_scalar() || this->is_vector())
+ return this->vector_elements * N;
+
+ if (this->without_array()->is_matrix()) {
+ const struct glsl_type *element_type;
+ const struct glsl_type *vec_type;
+ unsigned int array_len;
+
+ if (this->is_array()) {
+ element_type = this->without_array();
+ array_len = this->arrays_of_arrays_size();
+ } else {
+ element_type = this;
+ array_len = 1;
+ }
+
+ if (row_major) {
+ vec_type = get_instance(element_type->base_type,
+ element_type->matrix_columns, 1);
+
+ array_len *= element_type->vector_elements;
+ } else {
+ vec_type = get_instance(element_type->base_type,
+ element_type->vector_elements, 1);
+ array_len *= element_type->matrix_columns;
+ }
+ const glsl_type *array_type = glsl_type::get_array_instance(vec_type,
+ array_len);
+
+ return array_type->std430_size(false);
+ }
+
+ if (this->is_array()) {
+ if (this->without_array()->is_record())
+ return this->arrays_of_arrays_size() *
+ this->without_array()->std430_size(row_major);
+ else
+ return this->arrays_of_arrays_size() *
+ this->without_array()->std430_base_alignment(row_major);
+ }
+
+ if (this->is_record() || this->is_interface()) {
+ unsigned size = 0;
+ unsigned max_align = 0;
+
+ for (unsigned i = 0; i < this->length; i++) {
+ bool field_row_major = row_major;
+ const enum glsl_matrix_layout matrix_layout =
+ glsl_matrix_layout(this->fields.structure[i].matrix_layout);
+ if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
+ field_row_major = true;
+ } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
+ field_row_major = false;
+ }
+
+ const struct glsl_type *field_type = this->fields.structure[i].type;
+ unsigned align = field_type->std430_base_alignment(field_row_major);
+ size = glsl_align(size, align);
+ size += field_type->std430_size(field_row_major);
+
+ max_align = MAX2(align, max_align);
+ }
+ size = glsl_align(size, max_align);
+ return size;
+ }
+
+ assert(!"not reached");
+ return -1;
+}
+
+unsigned
+glsl_type::count_attribute_slots(bool vertex_input_slots) const
+{
+ /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
+ *
+ * "A scalar input counts the same amount against this limit as a vec4,
+ * so applications may want to consider packing groups of four
+ * unrelated float inputs together into a vector to better utilize the
+ * capabilities of the underlying hardware. A matrix input will use up
+ * multiple locations. The number of locations used will equal the
+ * number of columns in the matrix."
+ *
+ * The spec does not explicitly say how arrays are counted. However, it
+ * should be safe to assume the total number of slots consumed by an array
+ * is the number of entries in the array multiplied by the number of slots
+ * consumed by a single element of the array.
+ *
+ * The spec says nothing about how structs are counted, because vertex
+ * attributes are not allowed to be (or contain) structs. However, Mesa
+ * allows varying structs, the number of varying slots taken up by a
+ * varying struct is simply equal to the sum of the number of slots taken
+ * up by each element.
+ *
+ * Doubles are counted different depending on whether they are vertex
+ * inputs or everything else. Vertex inputs from ARB_vertex_attrib_64bit
+ * take one location no matter what size they are, otherwise dvec3/4
+ * take two locations.
+ */
+ switch (this->base_type) {
+ case GLSL_TYPE_UINT:
+ case GLSL_TYPE_INT:
+ case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_BOOL:
+ return this->matrix_columns;
+ case GLSL_TYPE_DOUBLE:
+ if (this->vector_elements > 2 && !vertex_input_slots)
+ return this->matrix_columns * 2;
+ else
+ return this->matrix_columns;
+ case GLSL_TYPE_STRUCT:
+ case GLSL_TYPE_INTERFACE: {
+ unsigned size = 0;
+
+ for (unsigned i = 0; i < this->length; i++)
+ size += this->fields.structure[i].type->count_attribute_slots(vertex_input_slots);
+
+ return size;
+ }
+
+ case GLSL_TYPE_ARRAY:
+ return this->length * this->fields.array->count_attribute_slots(vertex_input_slots);
+
+ case GLSL_TYPE_SAMPLER:
+ case GLSL_TYPE_IMAGE:
+ case GLSL_TYPE_ATOMIC_UINT:
+ case GLSL_TYPE_VOID:
+ case GLSL_TYPE_SUBROUTINE:
+ case GLSL_TYPE_ERROR:
+ break;
+ }
+
+ assert(!"Unexpected type in count_attribute_slots()");
+
+ return 0;
+}
+
+int
+glsl_type::coordinate_components() const
+{
+ int size;
+
+ switch (sampler_dimensionality) {
+ case GLSL_SAMPLER_DIM_1D:
+ case GLSL_SAMPLER_DIM_BUF:
+ size = 1;
+ break;
+ case GLSL_SAMPLER_DIM_2D:
+ case GLSL_SAMPLER_DIM_RECT:
+ case GLSL_SAMPLER_DIM_MS:
+ case GLSL_SAMPLER_DIM_EXTERNAL:
+ size = 2;
+ break;
+ case GLSL_SAMPLER_DIM_3D:
+ case GLSL_SAMPLER_DIM_CUBE:
+ size = 3;
+ break;
+ default:
+ assert(!"Should not get here.");
+ size = 1;
+ break;
+ }
+
+ /* Array textures need an additional component for the array index, except
+ * for cubemap array images that behave like a 2D array of interleaved
+ * cubemap faces.
+ */
+ if (sampler_array &&
+ !(base_type == GLSL_TYPE_IMAGE &&
+ sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE))
+ size += 1;
+
+ return size;
+}
+
+/**
+ * Declarations of type flyweights (glsl_type::_foo_type) and
+ * convenience pointers (glsl_type::foo_type).
+ * @{
+ */
+#define DECL_TYPE(NAME, ...) \
+ const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \
+ const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type;
+
+#define STRUCT_TYPE(NAME)
+
+#include "compiler/builtin_type_macros.h"
+/** @} */
--- /dev/null
+/* -*- c++ -*- */
+/*
+ * Copyright © 2009 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+#ifndef GLSL_TYPES_H
+#define GLSL_TYPES_H
+
+#include <string.h>
+#include <assert.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _mesa_glsl_parse_state;
+struct glsl_symbol_table;
+
+extern void
+_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state);
+
+extern void
+_mesa_glsl_release_types(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+enum glsl_base_type {
+ GLSL_TYPE_UINT = 0,
+ GLSL_TYPE_INT,
+ GLSL_TYPE_FLOAT,
+ GLSL_TYPE_DOUBLE,
+ GLSL_TYPE_BOOL,
+ GLSL_TYPE_SAMPLER,
+ GLSL_TYPE_IMAGE,
+ GLSL_TYPE_ATOMIC_UINT,
+ GLSL_TYPE_STRUCT,
+ GLSL_TYPE_INTERFACE,
+ GLSL_TYPE_ARRAY,
+ GLSL_TYPE_VOID,
+ GLSL_TYPE_SUBROUTINE,
+ GLSL_TYPE_ERROR
+};
+
+enum glsl_sampler_dim {
+ GLSL_SAMPLER_DIM_1D = 0,
+ GLSL_SAMPLER_DIM_2D,
+ GLSL_SAMPLER_DIM_3D,
+ GLSL_SAMPLER_DIM_CUBE,
+ GLSL_SAMPLER_DIM_RECT,
+ GLSL_SAMPLER_DIM_BUF,
+ GLSL_SAMPLER_DIM_EXTERNAL,
+ GLSL_SAMPLER_DIM_MS
+};
+
+enum glsl_interface_packing {
+ GLSL_INTERFACE_PACKING_STD140,
+ GLSL_INTERFACE_PACKING_SHARED,
+ GLSL_INTERFACE_PACKING_PACKED,
+ GLSL_INTERFACE_PACKING_STD430
+};
+
+enum glsl_matrix_layout {
+ /**
+ * The layout of the matrix is inherited from the object containing the
+ * matrix (the top level structure or the uniform block).
+ */
+ GLSL_MATRIX_LAYOUT_INHERITED,
+
+ /**
+ * Explicit column-major layout
+ *
+ * If a uniform block doesn't have an explicit layout set, it will default
+ * to this layout.
+ */
+ GLSL_MATRIX_LAYOUT_COLUMN_MAJOR,
+
+ /**
+ * Row-major layout
+ */
+ GLSL_MATRIX_LAYOUT_ROW_MAJOR
+};
+
+enum {
+ GLSL_PRECISION_NONE = 0,
+ GLSL_PRECISION_HIGH,
+ GLSL_PRECISION_MEDIUM,
+ GLSL_PRECISION_LOW
+};
+
+#ifdef __cplusplus
+#include "GL/gl.h"
+#include "util/ralloc.h"
+#include "main/mtypes.h" /* for gl_texture_index, C++'s enum rules are broken */
+
+struct glsl_type {
+ GLenum gl_type;
+ glsl_base_type base_type;
+
+ unsigned sampler_dimensionality:3; /**< \see glsl_sampler_dim */
+ unsigned sampler_shadow:1;
+ unsigned sampler_array:1;
+ unsigned sampler_type:2; /**< Type of data returned using this
+ * sampler or image. Only \c
+ * GLSL_TYPE_FLOAT, \c GLSL_TYPE_INT,
+ * and \c GLSL_TYPE_UINT are valid.
+ */
+ unsigned interface_packing:2;
+
+ /* Callers of this ralloc-based new need not call delete. It's
+ * easier to just ralloc_free 'mem_ctx' (or any of its ancestors). */
+ static void* operator new(size_t size)
+ {
+ mtx_lock(&glsl_type::mutex);
+
+ /* mem_ctx should have been created by the static members */
+ assert(glsl_type::mem_ctx != NULL);
+
+ void *type;
+
+ type = ralloc_size(glsl_type::mem_ctx, size);
+ assert(type != NULL);
+
+ mtx_unlock(&glsl_type::mutex);
+
+ return type;
+ }
+
+ /* If the user *does* call delete, that's OK, we will just
+ * ralloc_free in that case. */
+ static void operator delete(void *type)
+ {
+ mtx_lock(&glsl_type::mutex);
+ ralloc_free(type);
+ mtx_unlock(&glsl_type::mutex);
+ }
+
+ /**
+ * \name Vector and matrix element counts
+ *
+ * For scalars, each of these values will be 1. For non-numeric types
+ * these will be 0.
+ */
+ /*@{*/
+ uint8_t vector_elements; /**< 1, 2, 3, or 4 vector elements. */
+ uint8_t matrix_columns; /**< 1, 2, 3, or 4 matrix columns. */
+ /*@}*/
+
+ /**
+ * For \c GLSL_TYPE_ARRAY, this is the length of the array. For
+ * \c GLSL_TYPE_STRUCT or \c GLSL_TYPE_INTERFACE, it is the number of
+ * elements in the structure and the number of values pointed to by
+ * \c fields.structure (below).
+ */
+ unsigned length;
+
+ /**
+ * Name of the data type
+ *
+ * Will never be \c NULL.
+ */
+ const char *name;
+
+ /**
+ * Subtype of composite data types.
+ */
+ union {
+ const struct glsl_type *array; /**< Type of array elements. */
+ const struct glsl_type *parameters; /**< Parameters to function. */
+ struct glsl_struct_field *structure; /**< List of struct fields. */
+ } fields;
+
+ /**
+ * \name Pointers to various public type singletons
+ */
+ /*@{*/
+#undef DECL_TYPE
+#define DECL_TYPE(NAME, ...) \
+ static const glsl_type *const NAME##_type;
+#undef STRUCT_TYPE
+#define STRUCT_TYPE(NAME) \
+ static const glsl_type *const struct_##NAME##_type;
+#include "compiler/builtin_type_macros.h"
+ /*@}*/
+
+ /**
+ * Convenience accessors for vector types (shorter than get_instance()).
+ * @{
+ */
+ static const glsl_type *vec(unsigned components);
+ static const glsl_type *dvec(unsigned components);
+ static const glsl_type *ivec(unsigned components);
+ static const glsl_type *uvec(unsigned components);
+ static const glsl_type *bvec(unsigned components);
+ /**@}*/
+
+ /**
+ * For numeric and boolean derived types returns the basic scalar type
+ *
+ * If the type is a numeric or boolean scalar, vector, or matrix type,
+ * this function gets the scalar type of the individual components. For
+ * all other types, including arrays of numeric or boolean types, the
+ * error type is returned.
+ */
+ const glsl_type *get_base_type() const;
+
+ /**
+ * Get the basic scalar type which this type aggregates.
+ *
+ * If the type is a numeric or boolean scalar, vector, or matrix, or an
+ * array of any of those, this function gets the scalar type of the
+ * individual components. For structs and arrays of structs, this function
+ * returns the struct type. For samplers and arrays of samplers, this
+ * function returns the sampler type.
+ */
+ const glsl_type *get_scalar_type() const;
+
+ /**
+ * Get the instance of a built-in scalar, vector, or matrix type
+ */
+ static const glsl_type *get_instance(unsigned base_type, unsigned rows,
+ unsigned columns);
+
+ /**
+ * Get the instance of a sampler type
+ */
+ static const glsl_type *get_sampler_instance(enum glsl_sampler_dim dim,
+ bool shadow,
+ bool array,
+ glsl_base_type type);
+
+
+ /**
+ * Get the instance of an array type
+ */
+ static const glsl_type *get_array_instance(const glsl_type *base,
+ unsigned elements);
+
+ /**
+ * Get the instance of a record type
+ */
+ static const glsl_type *get_record_instance(const glsl_struct_field *fields,
+ unsigned num_fields,
+ const char *name);
+
+ /**
+ * Get the instance of an interface block type
+ */
+ static const glsl_type *get_interface_instance(const glsl_struct_field *fields,
+ unsigned num_fields,
+ enum glsl_interface_packing packing,
+ const char *block_name);
+
+ /**
+ * Get the instance of an subroutine type
+ */
+ static const glsl_type *get_subroutine_instance(const char *subroutine_name);
+
+ /**
+ * Get the type resulting from a multiplication of \p type_a * \p type_b
+ */
+ static const glsl_type *get_mul_type(const glsl_type *type_a,
+ const glsl_type *type_b);
+
+ /**
+ * Query the total number of scalars that make up a scalar, vector or matrix
+ */
+ unsigned components() const
+ {
+ return vector_elements * matrix_columns;
+ }
+
+ /**
+ * Calculate the number of components slots required to hold this type
+ *
+ * This is used to determine how many uniform or varying locations a type
+ * might occupy.
+ */
+ unsigned component_slots() const;
+
+ /**
+ * Calculate offset between the base location of the struct in
+ * uniform storage and a struct member.
+ * For the initial call, length is the index of the member to find the
+ * offset for.
+ */
+ unsigned record_location_offset(unsigned length) const;
+
+ /**
+ * Calculate the number of unique values from glGetUniformLocation for the
+ * elements of the type.
+ *
+ * This is used to allocate slots in the UniformRemapTable, the amount of
+ * locations may not match with actual used storage space by the driver.
+ */
+ unsigned uniform_locations() const;
+
+ /**
+ * Calculate the number of attribute slots required to hold this type
+ *
+ * This implements the language rules of GLSL 1.50 for counting the number
+ * of slots used by a vertex attribute. It also determines the number of
+ * varying slots the type will use up in the absence of varying packing
+ * (and thus, it can be used to measure the number of varying slots used by
+ * the varyings that are generated by lower_packed_varyings).
+ *
+ * For vertex shader attributes - doubles only take one slot.
+ * For inter-shader varyings - dvec3/dvec4 take two slots.
+ */
+ unsigned count_attribute_slots(bool vertex_input_slots) const;
+
+ /**
+ * Alignment in bytes of the start of this type in a std140 uniform
+ * block.
+ */
+ unsigned std140_base_alignment(bool row_major) const;
+
+ /** Size in bytes of this type in a std140 uniform block.
+ *
+ * Note that this is not GL_UNIFORM_SIZE (which is the number of
+ * elements in the array)
+ */
+ unsigned std140_size(bool row_major) const;
+
+ /**
+ * Alignment in bytes of the start of this type in a std430 shader
+ * storage block.
+ */
+ unsigned std430_base_alignment(bool row_major) const;
+
+ /**
+ * Calculate array stride in bytes of this type in a std430 shader storage
+ * block.
+ */
+ unsigned std430_array_stride(bool row_major) const;
+
+ /**
+ * Size in bytes of this type in a std430 shader storage block.
+ *
+ * Note that this is not GL_BUFFER_SIZE
+ */
+ unsigned std430_size(bool row_major) const;
+
+ /**
+ * \brief Can this type be implicitly converted to another?
+ *
+ * \return True if the types are identical or if this type can be converted
+ * to \c desired according to Section 4.1.10 of the GLSL spec.
+ *
+ * \verbatim
+ * From page 25 (31 of the pdf) of the GLSL 1.50 spec, Section 4.1.10
+ * Implicit Conversions:
+ *
+ * In some situations, an expression and its type will be implicitly
+ * converted to a different type. The following table shows all allowed
+ * implicit conversions:
+ *
+ * Type of expression | Can be implicitly converted to
+ * --------------------------------------------------
+ * int float
+ * uint
+ *
+ * ivec2 vec2
+ * uvec2
+ *
+ * ivec3 vec3
+ * uvec3
+ *
+ * ivec4 vec4
+ * uvec4
+ *
+ * There are no implicit array or structure conversions. For example,
+ * an array of int cannot be implicitly converted to an array of float.
+ * There are no implicit conversions between signed and unsigned
+ * integers.
+ * \endverbatim
+ */
+ bool can_implicitly_convert_to(const glsl_type *desired,
+ _mesa_glsl_parse_state *state) const;
+
+ /**
+ * Query whether or not a type is a scalar (non-vector and non-matrix).
+ */
+ bool is_scalar() const
+ {
+ return (vector_elements == 1)
+ && (base_type >= GLSL_TYPE_UINT)
+ && (base_type <= GLSL_TYPE_BOOL);
+ }
+
+ /**
+ * Query whether or not a type is a vector
+ */
+ bool is_vector() const
+ {
+ return (vector_elements > 1)
+ && (matrix_columns == 1)
+ && (base_type >= GLSL_TYPE_UINT)
+ && (base_type <= GLSL_TYPE_BOOL);
+ }
+
+ /**
+ * Query whether or not a type is a matrix
+ */
+ bool is_matrix() const
+ {
+ /* GLSL only has float matrices. */
+ return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT || base_type == GLSL_TYPE_DOUBLE);
+ }
+
+ /**
+ * Query whether or not a type is a non-array numeric type
+ */
+ bool is_numeric() const
+ {
+ return (base_type >= GLSL_TYPE_UINT) && (base_type <= GLSL_TYPE_DOUBLE);
+ }
+
+ /**
+ * Query whether or not a type is an integral type
+ */
+ bool is_integer() const
+ {
+ return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT);
+ }
+
+ /**
+ * Query whether or not type is an integral type, or for struct and array
+ * types, contains an integral type.
+ */
+ bool contains_integer() const;
+
+ /**
+ * Query whether or not type is a double type, or for struct and array
+ * types, contains a double type.
+ */
+ bool contains_double() const;
+
+ /**
+ * Query whether or not a type is a float type
+ */
+ bool is_float() const
+ {
+ return base_type == GLSL_TYPE_FLOAT;
+ }
+
+ /**
+ * Query whether or not a type is a double type
+ */
+ bool is_double() const
+ {
+ return base_type == GLSL_TYPE_DOUBLE;
+ }
+
+ /**
+ * Query whether a double takes two slots.
+ */
+ bool is_dual_slot_double() const
+ {
+ return base_type == GLSL_TYPE_DOUBLE && vector_elements > 2;
+ }
+
+ /**
+ * Query whether or not a type is a non-array boolean type
+ */
+ bool is_boolean() const
+ {
+ return base_type == GLSL_TYPE_BOOL;
+ }
+
+ /**
+ * Query whether or not a type is a sampler
+ */
+ bool is_sampler() const
+ {
+ return base_type == GLSL_TYPE_SAMPLER;
+ }
+
+ /**
+ * Query whether or not type is a sampler, or for struct and array
+ * types, contains a sampler.
+ */
+ bool contains_sampler() const;
+
+ /**
+ * Get the Mesa texture target index for a sampler type.
+ */
+ gl_texture_index sampler_index() const;
+
+ /**
+ * Query whether or not type is an image, or for struct and array
+ * types, contains an image.
+ */
+ bool contains_image() const;
+
+ /**
+ * Query whether or not a type is an image
+ */
+ bool is_image() const
+ {
+ return base_type == GLSL_TYPE_IMAGE;
+ }
+
+ /**
+ * Query whether or not a type is an array
+ */
+ bool is_array() const
+ {
+ return base_type == GLSL_TYPE_ARRAY;
+ }
+
+ bool is_array_of_arrays() const
+ {
+ return is_array() && fields.array->is_array();
+ }
+
+ /**
+ * Query whether or not a type is a record
+ */
+ bool is_record() const
+ {
+ return base_type == GLSL_TYPE_STRUCT;
+ }
+
+ /**
+ * Query whether or not a type is an interface
+ */
+ bool is_interface() const
+ {
+ return base_type == GLSL_TYPE_INTERFACE;
+ }
+
+ /**
+ * Query whether or not a type is the void type singleton.
+ */
+ bool is_void() const
+ {
+ return base_type == GLSL_TYPE_VOID;
+ }
+
+ /**
+ * Query whether or not a type is the error type singleton.
+ */
+ bool is_error() const
+ {
+ return base_type == GLSL_TYPE_ERROR;
+ }
+
+ /**
+ * Query if a type is unnamed/anonymous (named by the parser)
+ */
+
+ bool is_subroutine() const
+ {
+ return base_type == GLSL_TYPE_SUBROUTINE;
+ }
+ bool contains_subroutine() const;
+
+ bool is_anonymous() const
+ {
+ return !strncmp(name, "#anon", 5);
+ }
+
+ /**
+ * Get the type stripped of any arrays
+ *
+ * \return
+ * Pointer to the type of elements of the first non-array type for array
+ * types, or pointer to itself for non-array types.
+ */
+ const glsl_type *without_array() const
+ {
+ const glsl_type *t = this;
+
+ while (t->is_array())
+ t = t->fields.array;
+
+ return t;
+ }
+
+ /**
+ * Return the total number of elements in an array including the elements
+ * in arrays of arrays.
+ */
+ unsigned arrays_of_arrays_size() const
+ {
+ if (!is_array())
+ return 0;
+
+ unsigned size = length;
+ const glsl_type *base_type = fields.array;
+
+ while (base_type->is_array()) {
+ size = size * base_type->length;
+ base_type = base_type->fields.array;
+ }
+ return size;
+ }
+
+ /**
+ * Return the amount of atomic counter storage required for a type.
+ */
+ unsigned atomic_size() const
+ {
+ if (base_type == GLSL_TYPE_ATOMIC_UINT)
+ return ATOMIC_COUNTER_SIZE;
+ else if (is_array())
+ return length * fields.array->atomic_size();
+ else
+ return 0;
+ }
+
+ /**
+ * Return whether a type contains any atomic counters.
+ */
+ bool contains_atomic() const
+ {
+ return atomic_size() > 0;
+ }
+
+ /**
+ * Return whether a type contains any opaque types.
+ */
+ bool contains_opaque() const;
+
+ /**
+ * Query the full type of a matrix row
+ *
+ * \return
+ * If the type is not a matrix, \c glsl_type::error_type is returned.
+ * Otherwise a type matching the rows of the matrix is returned.
+ */
+ const glsl_type *row_type() const
+ {
+ return is_matrix()
+ ? get_instance(base_type, matrix_columns, 1)
+ : error_type;
+ }
+
+ /**
+ * Query the full type of a matrix column
+ *
+ * \return
+ * If the type is not a matrix, \c glsl_type::error_type is returned.
+ * Otherwise a type matching the columns of the matrix is returned.
+ */
+ const glsl_type *column_type() const
+ {
+ return is_matrix()
+ ? get_instance(base_type, vector_elements, 1)
+ : error_type;
+ }
+
+ /**
+ * Get the type of a structure field
+ *
+ * \return
+ * Pointer to the type of the named field. If the type is not a structure
+ * or the named field does not exist, \c glsl_type::error_type is returned.
+ */
+ const glsl_type *field_type(const char *name) const;
+
+ /**
+ * Get the location of a field within a record type
+ */
+ int field_index(const char *name) const;
+
+ /**
+ * Query the number of elements in an array type
+ *
+ * \return
+ * The number of elements in the array for array types or -1 for non-array
+ * types. If the number of elements in the array has not yet been declared,
+ * zero is returned.
+ */
+ int array_size() const
+ {
+ return is_array() ? length : -1;
+ }
+
+ /**
+ * Query whether the array size for all dimensions has been declared.
+ */
+ bool is_unsized_array() const
+ {
+ return is_array() && length == 0;
+ }
+
+ /**
+ * Return the number of coordinate components needed for this
+ * sampler or image type.
+ *
+ * This is based purely on the sampler's dimensionality. For example, this
+ * returns 1 for sampler1D, and 3 for sampler2DArray.
+ *
+ * Note that this is often different than actual coordinate type used in
+ * a texturing built-in function, since those pack additional values (such
+ * as the shadow comparitor or projector) into the coordinate type.
+ */
+ int coordinate_components() const;
+
+ /**
+ * Compare a record type against another record type.
+ *
+ * This is useful for matching record types declared across shader stages.
+ */
+ bool record_compare(const glsl_type *b) const;
+
+private:
+
+ static mtx_t mutex;
+
+ /**
+ * ralloc context for all glsl_type allocations
+ *
+ * Set on the first call to \c glsl_type::new.
+ */
+ static void *mem_ctx;
+
+ void init_ralloc_type_ctx(void);
+
+ /** Constructor for vector and matrix types */
+ glsl_type(GLenum gl_type,
+ glsl_base_type base_type, unsigned vector_elements,
+ unsigned matrix_columns, const char *name);
+
+ /** Constructor for sampler or image types */
+ glsl_type(GLenum gl_type, glsl_base_type base_type,
+ enum glsl_sampler_dim dim, bool shadow, bool array,
+ unsigned type, const char *name);
+
+ /** Constructor for record types */
+ glsl_type(const glsl_struct_field *fields, unsigned num_fields,
+ const char *name);
+
+ /** Constructor for interface types */
+ glsl_type(const glsl_struct_field *fields, unsigned num_fields,
+ enum glsl_interface_packing packing, const char *name);
+
+ /** Constructor for array types */
+ glsl_type(const glsl_type *array, unsigned length);
+
+ /** Constructor for subroutine types */
+ glsl_type(const char *name);
+
+ /** Hash table containing the known array types. */
+ static struct hash_table *array_types;
+
+ /** Hash table containing the known record types. */
+ static struct hash_table *record_types;
+
+ /** Hash table containing the known interface types. */
+ static struct hash_table *interface_types;
+
+ /** Hash table containing the known subroutine types. */
+ static struct hash_table *subroutine_types;
+
+ static bool record_key_compare(const void *a, const void *b);
+ static unsigned record_key_hash(const void *key);
+
+ /**
+ * \name Built-in type flyweights
+ */
+ /*@{*/
+#undef DECL_TYPE
+#define DECL_TYPE(NAME, ...) static const glsl_type _##NAME##_type;
+#undef STRUCT_TYPE
+#define STRUCT_TYPE(NAME) static const glsl_type _struct_##NAME##_type;
+#include "compiler/builtin_type_macros.h"
+ /*@}*/
+
+ /**
+ * \name Friend functions.
+ *
+ * These functions are friends because they must have C linkage and the
+ * need to call various private methods or access various private static
+ * data.
+ */
+ /*@{*/
+ friend void _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *);
+ friend void _mesa_glsl_release_types(void);
+ /*@}*/
+};
+
+struct glsl_struct_field {
+ const struct glsl_type *type;
+ const char *name;
+
+ /**
+ * For interface blocks, gl_varying_slot corresponding to the input/output
+ * if this is a built-in input/output (i.e. a member of the built-in
+ * gl_PerVertex interface block); -1 otherwise.
+ *
+ * Ignored for structs.
+ */
+ int location;
+
+ /**
+ * For interface blocks, the interpolation mode (as in
+ * ir_variable::interpolation). 0 otherwise.
+ */
+ unsigned interpolation:2;
+
+ /**
+ * For interface blocks, 1 if this variable uses centroid interpolation (as
+ * in ir_variable::centroid). 0 otherwise.
+ */
+ unsigned centroid:1;
+
+ /**
+ * For interface blocks, 1 if this variable uses sample interpolation (as
+ * in ir_variable::sample). 0 otherwise.
+ */
+ unsigned sample:1;
+
+ /**
+ * Layout of the matrix. Uses glsl_matrix_layout values.
+ */
+ unsigned matrix_layout:2;
+
+ /**
+ * For interface blocks, 1 if this variable is a per-patch input or output
+ * (as in ir_variable::patch). 0 otherwise.
+ */
+ unsigned patch:1;
+
+ /**
+ * Precision qualifier
+ */
+ unsigned precision:2;
+
+ /**
+ * Image qualifiers, applicable to buffer variables defined in shader
+ * storage buffer objects (SSBOs)
+ */
+ unsigned image_read_only:1;
+ unsigned image_write_only:1;
+ unsigned image_coherent:1;
+ unsigned image_volatile:1;
+ unsigned image_restrict:1;
+
+ glsl_struct_field(const struct glsl_type *_type, const char *_name)
+ : type(_type), name(_name), location(-1), interpolation(0), centroid(0),
+ sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0),
+ precision(GLSL_PRECISION_NONE)
+ {
+ /* empty */
+ }
+
+ glsl_struct_field()
+ {
+ /* empty */
+ }
+};
+
+static inline unsigned int
+glsl_align(unsigned int a, unsigned int align)
+{
+ return (a + align - 1) / align * align;
+}
+
+#undef DECL_TYPE
+#undef STRUCT_TYPE
+#endif /* __cplusplus */
+
+#endif /* GLSL_TYPES_H */
nir/nir_opt_algebraic.c
NIR_FILES = \
- nir/glsl_types.cpp \
- nir/glsl_types.h \
nir/nir.c \
nir/nir.h \
nir/nir_array.h \
'#src/gallium/include',
'#src/gallium/auxiliary',
'#src/glsl',
- '#src/glsl/nir',
'#src/glsl/glcpp',
])
for l in ('LIBGLCPP_FILES', 'LIBGLSL_FILES'):
glsl_sources += source_lists[l]
-# add nir/glsl_types.cpp manually, because SCons still doesn't know about NIR.
-# XXX: Remove this once we build NIR and NIR_FILES.
-glsl_sources += [
- 'nir/glsl_types.cpp',
-]
-
if env['msvc']:
env.Prepend(CPPPATH = ['#/src/getopt'])
env.PrependUnique(LIBS = [getopt])
*/
#include "ast.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
void
#include "glsl_symbol_table.h"
#include "ast.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "main/core.h" /* for MIN2 */
#include "main/shaderobj.h"
#include "glsl_symbol_table.h"
#include "glsl_parser_extras.h"
#include "ast.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/hash_table.h"
#include "main/shaderobj.h"
#include "ir.h"
* version and set of enabled extensions.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl_parser_extras.h"
#include "util/macros.h"
#include "ast.h"
#include "glsl_parser_extras.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "main/context.h"
#ifdef _MSC_VER
#include "ir.h"
#include "glsl_parser_extras.h"
#include "ast.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
ir_rvalue *
_mesa_ast_field_selection_to_hir(const ast_expression *expr,
#include <string.h>
#include "main/core.h" /* for MAX2 */
#include "ir.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
ir_rvalue::ir_rvalue(enum ir_node_type t)
: ir_instruction(t)
#include <stdlib.h>
#include "util/ralloc.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "list.h"
#include "ir_visitor.h"
#include "ir_hierarchical_visitor.h"
#include <string.h>
#include "main/compiler.h"
#include "ir.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/hash_table.h"
ir_rvalue *
#include "util/rounding.h" /* for _mesa_roundeven */
#include "util/half_float.h"
#include "ir.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/hash_table.h"
static float
* DEALINGS IN THE SOFTWARE.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "glsl_parser_extras.h"
#include "main/errors.h"
*/
#include "ir_print_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl_parser_extras.h"
#include "main/macros.h"
#include "util/hash_table.h"
#include "ir_reader.h"
#include "glsl_parser_extras.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "s_expression.h"
static const bool debug = false;
#include "ir.h"
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
ir_visitor_status
ir_rvalue_base_visitor::rvalue_visit(ir_expression *ir)
#include "main/core.h" /* for struct gl_program */
#include "ir.h"
#include "ir_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir_hierarchical_visitor.h"
#include "util/hash_table.h"
#include "util/set.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_variable_refcount.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "util/hash_table.h"
ir_variable_refcount_visitor::ir_variable_refcount_visitor()
#include "ir.h"
#include "ir_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
struct assignment_entry {
exec_node link;
* DEALINGS IN THE SOFTWARE.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "loop_analysis.h"
#include "ir_hierarchical_visitor.h"
#include <limits.h>
#include "main/compiler.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "loop_analysis.h"
#include "ir_hierarchical_visitor.h"
* DEALINGS IN THE SOFTWARE.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "loop_analysis.h"
#include "ir_hierarchical_visitor.h"
#include "ir.h"
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
class lower_const_array_visitor : public ir_rvalue_visitor {
* Unconditional discards are treated as having a condition of "true".
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
namespace {
* interpretation.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "program/hash_table.h"
* to attempt to flatten any if-statements appearing at depth > N.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "program/hash_table.h"
#include "c99_math.h"
#include "program/prog_instruction.h" /* for swizzle */
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "ir_builder.h"
#include "ir_optimization.h"
* prevents further optimization, and thus is not currently performed.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include <string.h>
#include "ir.h"
#include "ir.h"
#include "ir_expression_flattening.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
* \author Chris Forbes <chrisf@ijw.co.nz>
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
#include "ir_builder.h"
#include "ir_optimization.h"
* lowers subroutines to an if ladder.
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl_parser_extras.h"
#include "ir.h"
#include "ir_builder.h"
#include "ir.h"
#include "ir_rvalue_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "main/macros.h"
/**
#include "ir.h"
#include "ir_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "main/macros.h"
/**
+++ /dev/null
-/*
- * Copyright © 2009 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include "main/macros.h"
-#include "glsl_parser_extras.h"
-#include "glsl_types.h"
-#include "util/hash_table.h"
-
-
-mtx_t glsl_type::mutex = _MTX_INITIALIZER_NP;
-hash_table *glsl_type::array_types = NULL;
-hash_table *glsl_type::record_types = NULL;
-hash_table *glsl_type::interface_types = NULL;
-hash_table *glsl_type::subroutine_types = NULL;
-void *glsl_type::mem_ctx = NULL;
-
-void
-glsl_type::init_ralloc_type_ctx(void)
-{
- if (glsl_type::mem_ctx == NULL) {
- glsl_type::mem_ctx = ralloc_autofree_context();
- assert(glsl_type::mem_ctx != NULL);
- }
-}
-
-glsl_type::glsl_type(GLenum gl_type,
- glsl_base_type base_type, unsigned vector_elements,
- unsigned matrix_columns, const char *name) :
- gl_type(gl_type),
- base_type(base_type),
- sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampler_type(0), interface_packing(0),
- vector_elements(vector_elements), matrix_columns(matrix_columns),
- length(0)
-{
- mtx_lock(&glsl_type::mutex);
-
- init_ralloc_type_ctx();
- assert(name != NULL);
- this->name = ralloc_strdup(this->mem_ctx, name);
-
- mtx_unlock(&glsl_type::mutex);
-
- /* Neither dimension is zero or both dimensions are zero.
- */
- assert((vector_elements == 0) == (matrix_columns == 0));
- memset(& fields, 0, sizeof(fields));
-}
-
-glsl_type::glsl_type(GLenum gl_type, glsl_base_type base_type,
- enum glsl_sampler_dim dim, bool shadow, bool array,
- unsigned type, const char *name) :
- gl_type(gl_type),
- base_type(base_type),
- sampler_dimensionality(dim), sampler_shadow(shadow),
- sampler_array(array), sampler_type(type), interface_packing(0),
- length(0)
-{
- mtx_lock(&glsl_type::mutex);
-
- init_ralloc_type_ctx();
- assert(name != NULL);
- this->name = ralloc_strdup(this->mem_ctx, name);
-
- mtx_unlock(&glsl_type::mutex);
-
- memset(& fields, 0, sizeof(fields));
-
- if (base_type == GLSL_TYPE_SAMPLER) {
- /* Samplers take no storage whatsoever. */
- matrix_columns = vector_elements = 0;
- } else {
- matrix_columns = vector_elements = 1;
- }
-}
-
-glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
- const char *name) :
- gl_type(0),
- base_type(GLSL_TYPE_STRUCT),
- sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampler_type(0), interface_packing(0),
- vector_elements(0), matrix_columns(0),
- length(num_fields)
-{
- unsigned int i;
-
- mtx_lock(&glsl_type::mutex);
-
- init_ralloc_type_ctx();
- assert(name != NULL);
- this->name = ralloc_strdup(this->mem_ctx, name);
- this->fields.structure = ralloc_array(this->mem_ctx,
- glsl_struct_field, length);
-
- for (i = 0; i < length; i++) {
- this->fields.structure[i].type = fields[i].type;
- this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
- fields[i].name);
- this->fields.structure[i].location = fields[i].location;
- this->fields.structure[i].interpolation = fields[i].interpolation;
- this->fields.structure[i].centroid = fields[i].centroid;
- this->fields.structure[i].sample = fields[i].sample;
- this->fields.structure[i].matrix_layout = fields[i].matrix_layout;
- this->fields.structure[i].patch = fields[i].patch;
- this->fields.structure[i].image_read_only = fields[i].image_read_only;
- this->fields.structure[i].image_write_only = fields[i].image_write_only;
- this->fields.structure[i].image_coherent = fields[i].image_coherent;
- this->fields.structure[i].image_volatile = fields[i].image_volatile;
- this->fields.structure[i].image_restrict = fields[i].image_restrict;
- this->fields.structure[i].precision = fields[i].precision;
- }
-
- mtx_unlock(&glsl_type::mutex);
-}
-
-glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
- enum glsl_interface_packing packing, const char *name) :
- gl_type(0),
- base_type(GLSL_TYPE_INTERFACE),
- sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampler_type(0), interface_packing((unsigned) packing),
- vector_elements(0), matrix_columns(0),
- length(num_fields)
-{
- unsigned int i;
-
- mtx_lock(&glsl_type::mutex);
-
- init_ralloc_type_ctx();
- assert(name != NULL);
- this->name = ralloc_strdup(this->mem_ctx, name);
- this->fields.structure = ralloc_array(this->mem_ctx,
- glsl_struct_field, length);
- for (i = 0; i < length; i++) {
- this->fields.structure[i].type = fields[i].type;
- this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
- fields[i].name);
- this->fields.structure[i].location = fields[i].location;
- this->fields.structure[i].interpolation = fields[i].interpolation;
- this->fields.structure[i].centroid = fields[i].centroid;
- this->fields.structure[i].sample = fields[i].sample;
- this->fields.structure[i].matrix_layout = fields[i].matrix_layout;
- this->fields.structure[i].patch = fields[i].patch;
- this->fields.structure[i].precision = fields[i].precision;
- }
-
- mtx_unlock(&glsl_type::mutex);
-}
-
-glsl_type::glsl_type(const char *subroutine_name) :
- gl_type(0),
- base_type(GLSL_TYPE_SUBROUTINE),
- sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampler_type(0), interface_packing(0),
- vector_elements(1), matrix_columns(1),
- length(0)
-{
- mtx_lock(&glsl_type::mutex);
-
- init_ralloc_type_ctx();
- assert(subroutine_name != NULL);
- this->name = ralloc_strdup(this->mem_ctx, subroutine_name);
- mtx_unlock(&glsl_type::mutex);
-}
-
-bool
-glsl_type::contains_sampler() const
-{
- if (this->is_array()) {
- return this->fields.array->contains_sampler();
- } else if (this->is_record()) {
- for (unsigned int i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type->contains_sampler())
- return true;
- }
- return false;
- } else {
- return this->is_sampler();
- }
-}
-
-
-bool
-glsl_type::contains_integer() const
-{
- if (this->is_array()) {
- return this->fields.array->contains_integer();
- } else if (this->is_record()) {
- for (unsigned int i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type->contains_integer())
- return true;
- }
- return false;
- } else {
- return this->is_integer();
- }
-}
-
-bool
-glsl_type::contains_double() const
-{
- if (this->is_array()) {
- return this->fields.array->contains_double();
- } else if (this->is_record()) {
- for (unsigned int i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type->contains_double())
- return true;
- }
- return false;
- } else {
- return this->is_double();
- }
-}
-
-bool
-glsl_type::contains_opaque() const {
- switch (base_type) {
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_IMAGE:
- case GLSL_TYPE_ATOMIC_UINT:
- return true;
- case GLSL_TYPE_ARRAY:
- return fields.array->contains_opaque();
- case GLSL_TYPE_STRUCT:
- for (unsigned int i = 0; i < length; i++) {
- if (fields.structure[i].type->contains_opaque())
- return true;
- }
- return false;
- default:
- return false;
- }
-}
-
-bool
-glsl_type::contains_subroutine() const
-{
- if (this->is_array()) {
- return this->fields.array->contains_subroutine();
- } else if (this->is_record()) {
- for (unsigned int i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type->contains_subroutine())
- return true;
- }
- return false;
- } else {
- return this->is_subroutine();
- }
-}
-
-gl_texture_index
-glsl_type::sampler_index() const
-{
- const glsl_type *const t = (this->is_array()) ? this->fields.array : this;
-
- assert(t->is_sampler());
-
- switch (t->sampler_dimensionality) {
- case GLSL_SAMPLER_DIM_1D:
- return (t->sampler_array) ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX;
- case GLSL_SAMPLER_DIM_2D:
- return (t->sampler_array) ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX;
- case GLSL_SAMPLER_DIM_3D:
- return TEXTURE_3D_INDEX;
- case GLSL_SAMPLER_DIM_CUBE:
- return (t->sampler_array) ? TEXTURE_CUBE_ARRAY_INDEX : TEXTURE_CUBE_INDEX;
- case GLSL_SAMPLER_DIM_RECT:
- return TEXTURE_RECT_INDEX;
- case GLSL_SAMPLER_DIM_BUF:
- return TEXTURE_BUFFER_INDEX;
- case GLSL_SAMPLER_DIM_EXTERNAL:
- return TEXTURE_EXTERNAL_INDEX;
- case GLSL_SAMPLER_DIM_MS:
- return (t->sampler_array) ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : TEXTURE_2D_MULTISAMPLE_INDEX;
- default:
- assert(!"Should not get here.");
- return TEXTURE_BUFFER_INDEX;
- }
-}
-
-bool
-glsl_type::contains_image() const
-{
- if (this->is_array()) {
- return this->fields.array->contains_image();
- } else if (this->is_record()) {
- for (unsigned int i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type->contains_image())
- return true;
- }
- return false;
- } else {
- return this->is_image();
- }
-}
-
-const glsl_type *glsl_type::get_base_type() const
-{
- switch (base_type) {
- case GLSL_TYPE_UINT:
- return uint_type;
- case GLSL_TYPE_INT:
- return int_type;
- case GLSL_TYPE_FLOAT:
- return float_type;
- case GLSL_TYPE_DOUBLE:
- return double_type;
- case GLSL_TYPE_BOOL:
- return bool_type;
- default:
- return error_type;
- }
-}
-
-
-const glsl_type *glsl_type::get_scalar_type() const
-{
- const glsl_type *type = this;
-
- /* Handle arrays */
- while (type->base_type == GLSL_TYPE_ARRAY)
- type = type->fields.array;
-
- /* Handle vectors and matrices */
- switch (type->base_type) {
- case GLSL_TYPE_UINT:
- return uint_type;
- case GLSL_TYPE_INT:
- return int_type;
- case GLSL_TYPE_FLOAT:
- return float_type;
- case GLSL_TYPE_DOUBLE:
- return double_type;
- case GLSL_TYPE_BOOL:
- return bool_type;
- default:
- /* Handle everything else */
- return type;
- }
-}
-
-
-void
-_mesa_glsl_release_types(void)
-{
- /* Should only be called during atexit (either when unloading shared
- * object, or if process terminates), so no mutex-locking should be
- * necessary.
- */
- if (glsl_type::array_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::array_types, NULL);
- glsl_type::array_types = NULL;
- }
-
- if (glsl_type::record_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::record_types, NULL);
- glsl_type::record_types = NULL;
- }
-
- if (glsl_type::interface_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::interface_types, NULL);
- glsl_type::interface_types = NULL;
- }
-}
-
-
-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), interface_packing(0),
- vector_elements(0), matrix_columns(0),
- length(length), name(NULL)
-{
- this->fields.array = array;
- /* Inherit the gl type of the base. The GL type is used for
- * uniform/statevar handling in Mesa and the arrayness of the type
- * is represented by the size rather than the type.
- */
- this->gl_type = array->gl_type;
-
- /* 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;
-
- mtx_lock(&glsl_type::mutex);
- char *const n = (char *) ralloc_size(this->mem_ctx, name_length);
- mtx_unlock(&glsl_type::mutex);
-
- if (length == 0)
- snprintf(n, name_length, "%s[]", array->name);
- else {
- /* insert outermost dimensions in the correct spot
- * otherwise the dimension order will be backwards
- */
- const char *pos = strchr(array->name, '[');
- if (pos) {
- int idx = pos - array->name;
- snprintf(n, idx+1, "%s", array->name);
- snprintf(n + idx, name_length - idx, "[%u]%s",
- length, array->name + idx);
- } else {
- snprintf(n, name_length, "%s[%u]", array->name, length);
- }
- }
-
- this->name = n;
-}
-
-
-const glsl_type *
-glsl_type::vec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- float_type, vec2_type, vec3_type, vec4_type
- };
- return ts[components - 1];
-}
-
-const glsl_type *
-glsl_type::dvec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- double_type, dvec2_type, dvec3_type, dvec4_type
- };
- return ts[components - 1];
-}
-
-const glsl_type *
-glsl_type::ivec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- int_type, ivec2_type, ivec3_type, ivec4_type
- };
- return ts[components - 1];
-}
-
-
-const glsl_type *
-glsl_type::uvec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- uint_type, uvec2_type, uvec3_type, uvec4_type
- };
- return ts[components - 1];
-}
-
-
-const glsl_type *
-glsl_type::bvec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- bool_type, bvec2_type, bvec3_type, bvec4_type
- };
- return ts[components - 1];
-}
-
-
-const glsl_type *
-glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns)
-{
- 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 uvec(rows);
- case GLSL_TYPE_INT:
- return ivec(rows);
- case GLSL_TYPE_FLOAT:
- return vec(rows);
- case GLSL_TYPE_DOUBLE:
- return dvec(rows);
- case GLSL_TYPE_BOOL:
- return bvec(rows);
- default:
- return error_type;
- }
- } else {
- if ((base_type != GLSL_TYPE_FLOAT && base_type != GLSL_TYPE_DOUBLE) || (rows == 1))
- return error_type;
-
- /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
- * combinations are valid:
- *
- * 1 2 3 4
- * 1
- * 2 x x x
- * 3 x x x
- * 4 x x x
- */
-#define IDX(c,r) (((c-1)*3) + (r-1))
-
- if (base_type == GLSL_TYPE_DOUBLE) {
- switch (IDX(columns, rows)) {
- case IDX(2,2): return dmat2_type;
- case IDX(2,3): return dmat2x3_type;
- case IDX(2,4): return dmat2x4_type;
- case IDX(3,2): return dmat3x2_type;
- case IDX(3,3): return dmat3_type;
- case IDX(3,4): return dmat3x4_type;
- case IDX(4,2): return dmat4x2_type;
- case IDX(4,3): return dmat4x3_type;
- case IDX(4,4): return dmat4_type;
- default: return error_type;
- }
- } else {
- switch (IDX(columns, rows)) {
- case IDX(2,2): return mat2_type;
- case IDX(2,3): return mat2x3_type;
- case IDX(2,4): return mat2x4_type;
- case IDX(3,2): return mat3x2_type;
- case IDX(3,3): return mat3_type;
- case IDX(3,4): return mat3x4_type;
- case IDX(4,2): return mat4x2_type;
- case IDX(4,3): return mat4x3_type;
- case IDX(4,4): return mat4_type;
- default: return error_type;
- }
- }
- }
-
- assert(!"Should not get here.");
- return error_type;
-}
-
-const glsl_type *
-glsl_type::get_sampler_instance(enum glsl_sampler_dim dim,
- bool shadow,
- bool array,
- glsl_base_type type)
-{
- switch (type) {
- case GLSL_TYPE_FLOAT:
- switch (dim) {
- case GLSL_SAMPLER_DIM_1D:
- if (shadow)
- return (array ? sampler1DArrayShadow_type : sampler1DShadow_type);
- else
- return (array ? sampler1DArray_type : sampler1D_type);
- case GLSL_SAMPLER_DIM_2D:
- if (shadow)
- return (array ? sampler2DArrayShadow_type : sampler2DShadow_type);
- else
- return (array ? sampler2DArray_type : sampler2D_type);
- case GLSL_SAMPLER_DIM_3D:
- if (shadow || array)
- return error_type;
- else
- return sampler3D_type;
- case GLSL_SAMPLER_DIM_CUBE:
- if (shadow)
- return (array ? samplerCubeArrayShadow_type : samplerCubeShadow_type);
- else
- return (array ? samplerCubeArray_type : samplerCube_type);
- case GLSL_SAMPLER_DIM_RECT:
- if (array)
- return error_type;
- if (shadow)
- return sampler2DRectShadow_type;
- else
- return sampler2DRect_type;
- case GLSL_SAMPLER_DIM_BUF:
- if (shadow || array)
- return error_type;
- else
- return samplerBuffer_type;
- case GLSL_SAMPLER_DIM_MS:
- if (shadow)
- return error_type;
- return (array ? sampler2DMSArray_type : sampler2DMS_type);
- case GLSL_SAMPLER_DIM_EXTERNAL:
- if (shadow || array)
- return error_type;
- else
- return samplerExternalOES_type;
- }
- case GLSL_TYPE_INT:
- if (shadow)
- return error_type;
- switch (dim) {
- case GLSL_SAMPLER_DIM_1D:
- return (array ? isampler1DArray_type : isampler1D_type);
- case GLSL_SAMPLER_DIM_2D:
- return (array ? isampler2DArray_type : isampler2D_type);
- case GLSL_SAMPLER_DIM_3D:
- if (array)
- return error_type;
- return isampler3D_type;
- case GLSL_SAMPLER_DIM_CUBE:
- return (array ? isamplerCubeArray_type : isamplerCube_type);
- case GLSL_SAMPLER_DIM_RECT:
- if (array)
- return error_type;
- return isampler2DRect_type;
- case GLSL_SAMPLER_DIM_BUF:
- if (array)
- return error_type;
- return isamplerBuffer_type;
- case GLSL_SAMPLER_DIM_MS:
- return (array ? isampler2DMSArray_type : isampler2DMS_type);
- case GLSL_SAMPLER_DIM_EXTERNAL:
- return error_type;
- }
- case GLSL_TYPE_UINT:
- if (shadow)
- return error_type;
- switch (dim) {
- case GLSL_SAMPLER_DIM_1D:
- return (array ? usampler1DArray_type : usampler1D_type);
- case GLSL_SAMPLER_DIM_2D:
- return (array ? usampler2DArray_type : usampler2D_type);
- case GLSL_SAMPLER_DIM_3D:
- if (array)
- return error_type;
- return usampler3D_type;
- case GLSL_SAMPLER_DIM_CUBE:
- return (array ? usamplerCubeArray_type : usamplerCube_type);
- case GLSL_SAMPLER_DIM_RECT:
- if (array)
- return error_type;
- return usampler2DRect_type;
- case GLSL_SAMPLER_DIM_BUF:
- if (array)
- return error_type;
- return usamplerBuffer_type;
- case GLSL_SAMPLER_DIM_MS:
- return (array ? usampler2DMSArray_type : usampler2DMS_type);
- case GLSL_SAMPLER_DIM_EXTERNAL:
- return error_type;
- }
- default:
- return error_type;
- }
-
- unreachable("switch statement above should be complete");
-}
-
-const glsl_type *
-glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
-{
- /* Generate a name using the base type pointer in the key. This is
- * done because the name of the base type may not be unique across
- * shaders. For example, two shaders may have different record types
- * named 'foo'.
- */
- char key[128];
- snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
-
- mtx_lock(&glsl_type::mutex);
-
- if (array_types == NULL) {
- array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
- _mesa_key_string_equal);
- }
-
- const struct hash_entry *entry = _mesa_hash_table_search(array_types, key);
- if (entry == NULL) {
- mtx_unlock(&glsl_type::mutex);
- const glsl_type *t = new glsl_type(base, array_size);
- mtx_lock(&glsl_type::mutex);
-
- entry = _mesa_hash_table_insert(array_types,
- ralloc_strdup(mem_ctx, key),
- (void *) t);
- }
-
- assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_ARRAY);
- assert(((glsl_type *) entry->data)->length == array_size);
- assert(((glsl_type *) entry->data)->fields.array == base);
-
- mtx_unlock(&glsl_type::mutex);
-
- return (glsl_type *) entry->data;
-}
-
-
-bool
-glsl_type::record_compare(const glsl_type *b) const
-{
- if (this->length != b->length)
- return false;
-
- if (this->interface_packing != b->interface_packing)
- return false;
-
- /* From the GLSL 4.20 specification (Sec 4.2):
- *
- * "Structures must have the same name, sequence of type names, and
- * type definitions, and field names to be considered the same type."
- *
- * GLSL ES behaves the same (Ver 1.00 Sec 4.2.4, Ver 3.00 Sec 4.2.5).
- *
- * Note that we cannot force type name check when comparing unnamed
- * structure types, these have a unique name assigned during parsing.
- */
- if (!this->is_anonymous() && !b->is_anonymous())
- if (strcmp(this->name, b->name) != 0)
- return false;
-
- for (unsigned i = 0; i < this->length; i++) {
- if (this->fields.structure[i].type != b->fields.structure[i].type)
- return false;
- if (strcmp(this->fields.structure[i].name,
- b->fields.structure[i].name) != 0)
- return false;
- if (this->fields.structure[i].matrix_layout
- != b->fields.structure[i].matrix_layout)
- return false;
- if (this->fields.structure[i].location
- != b->fields.structure[i].location)
- return false;
- if (this->fields.structure[i].interpolation
- != b->fields.structure[i].interpolation)
- return false;
- if (this->fields.structure[i].centroid
- != b->fields.structure[i].centroid)
- return false;
- if (this->fields.structure[i].sample
- != b->fields.structure[i].sample)
- return false;
- if (this->fields.structure[i].patch
- != b->fields.structure[i].patch)
- return false;
- if (this->fields.structure[i].image_read_only
- != b->fields.structure[i].image_read_only)
- return false;
- if (this->fields.structure[i].image_write_only
- != b->fields.structure[i].image_write_only)
- return false;
- if (this->fields.structure[i].image_coherent
- != b->fields.structure[i].image_coherent)
- return false;
- if (this->fields.structure[i].image_volatile
- != b->fields.structure[i].image_volatile)
- return false;
- if (this->fields.structure[i].image_restrict
- != b->fields.structure[i].image_restrict)
- return false;
- if (this->fields.structure[i].precision
- != b->fields.structure[i].precision)
- return false;
- }
-
- return true;
-}
-
-
-bool
-glsl_type::record_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 strcmp(key1->name, key2->name) == 0 && key1->record_compare(key2);
-}
-
-
-/**
- * Generate an integer hash value for a glsl_type structure type.
- */
-unsigned
-glsl_type::record_key_hash(const void *a)
-{
- const glsl_type *const key = (glsl_type *) a;
- uintptr_t hash = key->length;
- unsigned retval;
-
- for (unsigned i = 0; i < key->length; i++) {
- /* casting pointer to uintptr_t */
- hash = (hash * 13 ) + (uintptr_t) key->fields.structure[i].type;
- }
-
- if (sizeof(hash) == 8)
- retval = (hash & 0xffffffff) ^ ((uint64_t) hash >> 32);
- else
- retval = hash;
-
- return retval;
-}
-
-
-const glsl_type *
-glsl_type::get_record_instance(const glsl_struct_field *fields,
- unsigned num_fields,
- const char *name)
-{
- const glsl_type key(fields, num_fields, name);
-
- mtx_lock(&glsl_type::mutex);
-
- if (record_types == NULL) {
- record_types = _mesa_hash_table_create(NULL, record_key_hash,
- record_key_compare);
- }
-
- const struct hash_entry *entry = _mesa_hash_table_search(record_types,
- &key);
- if (entry == NULL) {
- mtx_unlock(&glsl_type::mutex);
- const glsl_type *t = new glsl_type(fields, num_fields, name);
- mtx_lock(&glsl_type::mutex);
-
- entry = _mesa_hash_table_insert(record_types, t, (void *) t);
- }
-
- assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_STRUCT);
- assert(((glsl_type *) entry->data)->length == num_fields);
- assert(strcmp(((glsl_type *) entry->data)->name, name) == 0);
-
- mtx_unlock(&glsl_type::mutex);
-
- return (glsl_type *) entry->data;
-}
-
-
-const glsl_type *
-glsl_type::get_interface_instance(const glsl_struct_field *fields,
- unsigned num_fields,
- enum glsl_interface_packing packing,
- const char *block_name)
-{
- const glsl_type key(fields, num_fields, packing, block_name);
-
- mtx_lock(&glsl_type::mutex);
-
- if (interface_types == NULL) {
- interface_types = _mesa_hash_table_create(NULL, record_key_hash,
- record_key_compare);
- }
-
- const struct hash_entry *entry = _mesa_hash_table_search(interface_types,
- &key);
- if (entry == NULL) {
- mtx_unlock(&glsl_type::mutex);
- const glsl_type *t = new glsl_type(fields, num_fields,
- packing, block_name);
- mtx_lock(&glsl_type::mutex);
-
- entry = _mesa_hash_table_insert(interface_types, t, (void *) t);
- }
-
- assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_INTERFACE);
- assert(((glsl_type *) entry->data)->length == num_fields);
- assert(strcmp(((glsl_type *) entry->data)->name, block_name) == 0);
-
- mtx_unlock(&glsl_type::mutex);
-
- return (glsl_type *) entry->data;
-}
-
-const glsl_type *
-glsl_type::get_subroutine_instance(const char *subroutine_name)
-{
- const glsl_type key(subroutine_name);
-
- mtx_lock(&glsl_type::mutex);
-
- if (subroutine_types == NULL) {
- subroutine_types = _mesa_hash_table_create(NULL, record_key_hash,
- record_key_compare);
- }
-
- const struct hash_entry *entry = _mesa_hash_table_search(subroutine_types,
- &key);
- if (entry == NULL) {
- mtx_unlock(&glsl_type::mutex);
- const glsl_type *t = new glsl_type(subroutine_name);
- mtx_lock(&glsl_type::mutex);
-
- entry = _mesa_hash_table_insert(subroutine_types, t, (void *) t);
- }
-
- assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_SUBROUTINE);
- assert(strcmp(((glsl_type *) entry->data)->name, subroutine_name) == 0);
-
- mtx_unlock(&glsl_type::mutex);
-
- return (glsl_type *) entry->data;
-}
-
-
-const glsl_type *
-glsl_type::get_mul_type(const glsl_type *type_a, const glsl_type *type_b)
-{
- if (type_a == type_b) {
- return type_a;
- } else if (type_a->is_matrix() && type_b->is_matrix()) {
- /* Matrix multiply. The columns of A must match the rows of B. Given
- * the other previously tested constraints, this means the vector type
- * of a row from A must be the same as the vector type of a column from
- * B.
- */
- if (type_a->row_type() == type_b->column_type()) {
- /* The resulting matrix has the number of columns of matrix B and
- * the number of rows of matrix A. We get the row count of A by
- * looking at the size of a vector that makes up a column. The
- * transpose (size of a row) is done for B.
- */
- const glsl_type *const type =
- get_instance(type_a->base_type,
- type_a->column_type()->vector_elements,
- type_b->row_type()->vector_elements);
- assert(type != error_type);
-
- return type;
- }
- } else if (type_a->is_matrix()) {
- /* A is a matrix and B is a column vector. Columns of A must match
- * rows of B. Given the other previously tested constraints, this
- * means the vector type of a row from A must be the same as the
- * vector the type of B.
- */
- if (type_a->row_type() == type_b) {
- /* The resulting vector has a number of elements equal to
- * the number of rows of matrix A. */
- const glsl_type *const type =
- get_instance(type_a->base_type,
- type_a->column_type()->vector_elements,
- 1);
- assert(type != error_type);
-
- return type;
- }
- } else {
- assert(type_b->is_matrix());
-
- /* A is a row vector and B is a matrix. Columns of A must match rows
- * of B. Given the other previously tested constraints, this means
- * the type of A must be the same as the vector type of a column from
- * B.
- */
- if (type_a == type_b->column_type()) {
- /* The resulting vector has a number of elements equal to
- * the number of columns of matrix B. */
- const glsl_type *const type =
- get_instance(type_a->base_type,
- type_b->row_type()->vector_elements,
- 1);
- assert(type != error_type);
-
- return type;
- }
- }
-
- return error_type;
-}
-
-
-const glsl_type *
-glsl_type::field_type(const char *name) const
-{
- if (this->base_type != GLSL_TYPE_STRUCT
- && this->base_type != GLSL_TYPE_INTERFACE)
- 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
- && this->base_type != GLSL_TYPE_INTERFACE)
- return -1;
-
- for (unsigned i = 0; i < this->length; i++) {
- if (strcmp(name, this->fields.structure[i].name) == 0)
- return i;
- }
-
- return -1;
-}
-
-
-unsigned
-glsl_type::component_slots() const
-{
- switch (this->base_type) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_BOOL:
- return this->components();
-
- case GLSL_TYPE_DOUBLE:
- return 2 * this->components();
-
- case GLSL_TYPE_STRUCT:
- case GLSL_TYPE_INTERFACE: {
- unsigned size = 0;
-
- for (unsigned i = 0; i < this->length; i++)
- size += this->fields.structure[i].type->component_slots();
-
- return size;
- }
-
- case GLSL_TYPE_ARRAY:
- return this->length * this->fields.array->component_slots();
-
- case GLSL_TYPE_IMAGE:
- return 1;
- case GLSL_TYPE_SUBROUTINE:
- return 1;
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_ATOMIC_UINT:
- case GLSL_TYPE_VOID:
- case GLSL_TYPE_ERROR:
- break;
- }
-
- return 0;
-}
-
-unsigned
-glsl_type::record_location_offset(unsigned length) const
-{
- unsigned offset = 0;
- const glsl_type *t = this->without_array();
- if (t->is_record()) {
- assert(length <= t->length);
-
- for (unsigned i = 0; i < length; i++) {
- const glsl_type *st = t->fields.structure[i].type;
- const glsl_type *wa = st->without_array();
- if (wa->is_record()) {
- unsigned r_offset = wa->record_location_offset(wa->length);
- offset += st->is_array() ?
- st->arrays_of_arrays_size() * r_offset : r_offset;
- } else if (st->is_array() && st->fields.array->is_array()) {
- unsigned outer_array_size = st->length;
- const glsl_type *base_type = st->fields.array;
-
- /* For arrays of arrays the outer arrays take up a uniform
- * slot for each element. The innermost array elements share a
- * single slot so we ignore the innermost array when calculating
- * the offset.
- */
- while (base_type->fields.array->is_array()) {
- outer_array_size = outer_array_size * base_type->length;
- base_type = base_type->fields.array;
- }
- offset += outer_array_size;
- } else {
- /* We dont worry about arrays here because unless the array
- * contains a structure or another array it only takes up a single
- * uniform slot.
- */
- offset += 1;
- }
- }
- }
- return offset;
-}
-
-unsigned
-glsl_type::uniform_locations() const
-{
- unsigned size = 0;
-
- switch (this->base_type) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_DOUBLE:
- case GLSL_TYPE_BOOL:
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_IMAGE:
- case GLSL_TYPE_SUBROUTINE:
- return 1;
-
- case GLSL_TYPE_STRUCT:
- case GLSL_TYPE_INTERFACE:
- for (unsigned i = 0; i < this->length; i++)
- size += this->fields.structure[i].type->uniform_locations();
- return size;
- case GLSL_TYPE_ARRAY:
- return this->length * this->fields.array->uniform_locations();
- default:
- return 0;
- }
-}
-
-bool
-glsl_type::can_implicitly_convert_to(const glsl_type *desired,
- _mesa_glsl_parse_state *state) const
-{
- if (this == desired)
- return true;
-
- /* There is no conversion among matrix types. */
- if (this->matrix_columns > 1 || desired->matrix_columns > 1)
- return false;
-
- /* Vector size must match. */
- if (this->vector_elements != desired->vector_elements)
- return false;
-
- /* int and uint can be converted to float. */
- if (desired->is_float() && this->is_integer())
- return true;
-
- /* With GLSL 4.0 / ARB_gpu_shader5, int can be converted to uint.
- * Note that state may be NULL here, when resolving function calls in the
- * linker. By this time, all the state-dependent checks have already
- * happened though, so allow anything that's allowed in any shader version. */
- if ((!state || state->is_version(400, 0) || state->ARB_gpu_shader5_enable) &&
- desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT)
- return true;
-
- /* No implicit conversions from double. */
- if ((!state || state->has_double()) && this->is_double())
- return false;
-
- /* Conversions from different types to double. */
- if ((!state || state->has_double()) && desired->is_double()) {
- if (this->is_float())
- return true;
- if (this->is_integer())
- return true;
- }
-
- return false;
-}
-
-unsigned
-glsl_type::std140_base_alignment(bool row_major) const
-{
- unsigned N = is_double() ? 8 : 4;
-
- /* (1) If the member is a scalar consuming <N> basic machine units, the
- * base alignment is <N>.
- *
- * (2) If the member is a two- or four-component vector with components
- * consuming <N> basic machine units, the base alignment is 2<N> or
- * 4<N>, respectively.
- *
- * (3) If the member is a three-component vector with components consuming
- * <N> basic machine units, the base alignment is 4<N>.
- */
- if (this->is_scalar() || this->is_vector()) {
- switch (this->vector_elements) {
- case 1:
- return N;
- case 2:
- return 2 * N;
- case 3:
- case 4:
- return 4 * N;
- }
- }
-
- /* (4) If the member is an array of scalars or vectors, the base alignment
- * and array stride are set to match the base alignment of a single
- * array element, according to rules (1), (2), and (3), and rounded up
- * to the base alignment of a vec4. The array may have padding at the
- * end; the base offset of the member following the array is rounded up
- * to the next multiple of the base alignment.
- *
- * (6) If the member is an array of <S> column-major matrices with <C>
- * columns and <R> rows, the matrix is stored identically to a row of
- * <S>*<C> column vectors with <R> components each, according to rule
- * (4).
- *
- * (8) If the member is an array of <S> row-major matrices with <C> columns
- * and <R> rows, the matrix is stored identically to a row of <S>*<R>
- * row vectors with <C> components each, according to rule (4).
- *
- * (10) If the member is an array of <S> structures, the <S> elements of
- * the array are laid out in order, according to rule (9).
- */
- if (this->is_array()) {
- if (this->fields.array->is_scalar() ||
- this->fields.array->is_vector() ||
- this->fields.array->is_matrix()) {
- return MAX2(this->fields.array->std140_base_alignment(row_major), 16);
- } else {
- assert(this->fields.array->is_record() ||
- this->fields.array->is_array());
- return this->fields.array->std140_base_alignment(row_major);
- }
- }
-
- /* (5) If the member is a column-major matrix with <C> columns and
- * <R> rows, the matrix is stored identically to an array of
- * <C> column vectors with <R> components each, according to
- * rule (4).
- *
- * (7) If the member is a row-major matrix with <C> columns and <R>
- * rows, the matrix is stored identically to an array of <R>
- * row vectors with <C> components each, according to rule (4).
- */
- if (this->is_matrix()) {
- const struct glsl_type *vec_type, *array_type;
- int c = this->matrix_columns;
- int r = this->vector_elements;
-
- if (row_major) {
- vec_type = get_instance(base_type, c, 1);
- array_type = glsl_type::get_array_instance(vec_type, r);
- } else {
- vec_type = get_instance(base_type, r, 1);
- array_type = glsl_type::get_array_instance(vec_type, c);
- }
-
- return array_type->std140_base_alignment(false);
- }
-
- /* (9) If the member is a structure, the base alignment of the
- * structure is <N>, where <N> is the largest base alignment
- * value of any of its members, and rounded up to the base
- * alignment of a vec4. The individual members of this
- * sub-structure are then assigned offsets by applying this set
- * of rules recursively, where the base offset of the first
- * member of the sub-structure is equal to the aligned offset
- * of the structure. The structure may have padding at the end;
- * the base offset of the member following the sub-structure is
- * rounded up to the next multiple of the base alignment of the
- * structure.
- */
- if (this->is_record()) {
- unsigned base_alignment = 16;
- for (unsigned i = 0; i < this->length; i++) {
- bool field_row_major = row_major;
- const enum glsl_matrix_layout matrix_layout =
- glsl_matrix_layout(this->fields.structure[i].matrix_layout);
- if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
- field_row_major = true;
- } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
- field_row_major = false;
- }
-
- const struct glsl_type *field_type = this->fields.structure[i].type;
- base_alignment = MAX2(base_alignment,
- field_type->std140_base_alignment(field_row_major));
- }
- return base_alignment;
- }
-
- assert(!"not reached");
- return -1;
-}
-
-unsigned
-glsl_type::std140_size(bool row_major) const
-{
- unsigned N = is_double() ? 8 : 4;
-
- /* (1) If the member is a scalar consuming <N> basic machine units, the
- * base alignment is <N>.
- *
- * (2) If the member is a two- or four-component vector with components
- * consuming <N> basic machine units, the base alignment is 2<N> or
- * 4<N>, respectively.
- *
- * (3) If the member is a three-component vector with components consuming
- * <N> basic machine units, the base alignment is 4<N>.
- */
- if (this->is_scalar() || this->is_vector()) {
- return this->vector_elements * N;
- }
-
- /* (5) If the member is a column-major matrix with <C> columns and
- * <R> rows, the matrix is stored identically to an array of
- * <C> column vectors with <R> components each, according to
- * rule (4).
- *
- * (6) If the member is an array of <S> column-major matrices with <C>
- * columns and <R> rows, the matrix is stored identically to a row of
- * <S>*<C> column vectors with <R> components each, according to rule
- * (4).
- *
- * (7) If the member is a row-major matrix with <C> columns and <R>
- * rows, the matrix is stored identically to an array of <R>
- * row vectors with <C> components each, according to rule (4).
- *
- * (8) If the member is an array of <S> row-major matrices with <C> columns
- * and <R> rows, the matrix is stored identically to a row of <S>*<R>
- * row vectors with <C> components each, according to rule (4).
- */
- if (this->without_array()->is_matrix()) {
- const struct glsl_type *element_type;
- const struct glsl_type *vec_type;
- unsigned int array_len;
-
- if (this->is_array()) {
- element_type = this->without_array();
- array_len = this->arrays_of_arrays_size();
- } else {
- element_type = this;
- array_len = 1;
- }
-
- if (row_major) {
- vec_type = get_instance(element_type->base_type,
- element_type->matrix_columns, 1);
-
- array_len *= element_type->vector_elements;
- } else {
- vec_type = get_instance(element_type->base_type,
- element_type->vector_elements, 1);
- array_len *= element_type->matrix_columns;
- }
- const glsl_type *array_type = glsl_type::get_array_instance(vec_type,
- array_len);
-
- return array_type->std140_size(false);
- }
-
- /* (4) If the member is an array of scalars or vectors, the base alignment
- * and array stride are set to match the base alignment of a single
- * array element, according to rules (1), (2), and (3), and rounded up
- * to the base alignment of a vec4. The array may have padding at the
- * end; the base offset of the member following the array is rounded up
- * to the next multiple of the base alignment.
- *
- * (10) If the member is an array of <S> structures, the <S> elements of
- * the array are laid out in order, according to rule (9).
- */
- if (this->is_array()) {
- if (this->without_array()->is_record()) {
- return this->arrays_of_arrays_size() *
- this->without_array()->std140_size(row_major);
- } else {
- unsigned element_base_align =
- this->without_array()->std140_base_alignment(row_major);
- return this->arrays_of_arrays_size() * MAX2(element_base_align, 16);
- }
- }
-
- /* (9) If the member is a structure, the base alignment of the
- * structure is <N>, where <N> is the largest base alignment
- * value of any of its members, and rounded up to the base
- * alignment of a vec4. The individual members of this
- * sub-structure are then assigned offsets by applying this set
- * of rules recursively, where the base offset of the first
- * member of the sub-structure is equal to the aligned offset
- * of the structure. The structure may have padding at the end;
- * the base offset of the member following the sub-structure is
- * rounded up to the next multiple of the base alignment of the
- * structure.
- */
- if (this->is_record() || this->is_interface()) {
- unsigned size = 0;
- unsigned max_align = 0;
-
- for (unsigned i = 0; i < this->length; i++) {
- bool field_row_major = row_major;
- const enum glsl_matrix_layout matrix_layout =
- glsl_matrix_layout(this->fields.structure[i].matrix_layout);
- if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
- field_row_major = true;
- } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
- field_row_major = false;
- }
-
- const struct glsl_type *field_type = this->fields.structure[i].type;
- unsigned align = field_type->std140_base_alignment(field_row_major);
-
- /* Ignore unsized arrays when calculating size */
- if (field_type->is_unsized_array())
- continue;
-
- size = glsl_align(size, align);
- size += field_type->std140_size(field_row_major);
-
- max_align = MAX2(align, max_align);
-
- if (field_type->is_record() && (i + 1 < this->length))
- size = glsl_align(size, 16);
- }
- size = glsl_align(size, MAX2(max_align, 16));
- return size;
- }
-
- assert(!"not reached");
- return -1;
-}
-
-unsigned
-glsl_type::std430_base_alignment(bool row_major) const
-{
-
- unsigned N = is_double() ? 8 : 4;
-
- /* (1) If the member is a scalar consuming <N> basic machine units, the
- * base alignment is <N>.
- *
- * (2) If the member is a two- or four-component vector with components
- * consuming <N> basic machine units, the base alignment is 2<N> or
- * 4<N>, respectively.
- *
- * (3) If the member is a three-component vector with components consuming
- * <N> basic machine units, the base alignment is 4<N>.
- */
- if (this->is_scalar() || this->is_vector()) {
- switch (this->vector_elements) {
- case 1:
- return N;
- case 2:
- return 2 * N;
- case 3:
- case 4:
- return 4 * N;
- }
- }
-
- /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout":
- *
- * "When using the std430 storage layout, shader storage blocks will be
- * laid out in buffer storage identically to uniform and shader storage
- * blocks using the std140 layout, except that the base alignment and
- * stride of arrays of scalars and vectors in rule 4 and of structures
- * in rule 9 are not rounded up a multiple of the base alignment of a vec4.
- */
-
- /* (1) If the member is a scalar consuming <N> basic machine units, the
- * base alignment is <N>.
- *
- * (2) If the member is a two- or four-component vector with components
- * consuming <N> basic machine units, the base alignment is 2<N> or
- * 4<N>, respectively.
- *
- * (3) If the member is a three-component vector with components consuming
- * <N> basic machine units, the base alignment is 4<N>.
- */
- if (this->is_array())
- return this->fields.array->std430_base_alignment(row_major);
-
- /* (5) If the member is a column-major matrix with <C> columns and
- * <R> rows, the matrix is stored identically to an array of
- * <C> column vectors with <R> components each, according to
- * rule (4).
- *
- * (7) If the member is a row-major matrix with <C> columns and <R>
- * rows, the matrix is stored identically to an array of <R>
- * row vectors with <C> components each, according to rule (4).
- */
- if (this->is_matrix()) {
- const struct glsl_type *vec_type, *array_type;
- int c = this->matrix_columns;
- int r = this->vector_elements;
-
- if (row_major) {
- vec_type = get_instance(base_type, c, 1);
- array_type = glsl_type::get_array_instance(vec_type, r);
- } else {
- vec_type = get_instance(base_type, r, 1);
- array_type = glsl_type::get_array_instance(vec_type, c);
- }
-
- return array_type->std430_base_alignment(false);
- }
-
- /* (9) If the member is a structure, the base alignment of the
- * structure is <N>, where <N> is the largest base alignment
- * value of any of its members, and rounded up to the base
- * alignment of a vec4. The individual members of this
- * sub-structure are then assigned offsets by applying this set
- * of rules recursively, where the base offset of the first
- * member of the sub-structure is equal to the aligned offset
- * of the structure. The structure may have padding at the end;
- * the base offset of the member following the sub-structure is
- * rounded up to the next multiple of the base alignment of the
- * structure.
- */
- if (this->is_record()) {
- unsigned base_alignment = 0;
- for (unsigned i = 0; i < this->length; i++) {
- bool field_row_major = row_major;
- const enum glsl_matrix_layout matrix_layout =
- glsl_matrix_layout(this->fields.structure[i].matrix_layout);
- if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
- field_row_major = true;
- } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
- field_row_major = false;
- }
-
- const struct glsl_type *field_type = this->fields.structure[i].type;
- base_alignment = MAX2(base_alignment,
- field_type->std430_base_alignment(field_row_major));
- }
- assert(base_alignment > 0);
- return base_alignment;
- }
- assert(!"not reached");
- return -1;
-}
-
-unsigned
-glsl_type::std430_array_stride(bool row_major) const
-{
- unsigned N = is_double() ? 8 : 4;
-
- /* Notice that the array stride of a vec3 is not 3 * N but 4 * N.
- * See OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout"
- *
- * (3) If the member is a three-component vector with components consuming
- * <N> basic machine units, the base alignment is 4<N>.
- */
- if (this->is_vector() && this->vector_elements == 3)
- return 4 * N;
-
- /* By default use std430_size(row_major) */
- return this->std430_size(row_major);
-}
-
-unsigned
-glsl_type::std430_size(bool row_major) const
-{
- unsigned N = is_double() ? 8 : 4;
-
- /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout":
- *
- * "When using the std430 storage layout, shader storage blocks will be
- * laid out in buffer storage identically to uniform and shader storage
- * blocks using the std140 layout, except that the base alignment and
- * stride of arrays of scalars and vectors in rule 4 and of structures
- * in rule 9 are not rounded up a multiple of the base alignment of a vec4.
- */
- if (this->is_scalar() || this->is_vector())
- return this->vector_elements * N;
-
- if (this->without_array()->is_matrix()) {
- const struct glsl_type *element_type;
- const struct glsl_type *vec_type;
- unsigned int array_len;
-
- if (this->is_array()) {
- element_type = this->without_array();
- array_len = this->arrays_of_arrays_size();
- } else {
- element_type = this;
- array_len = 1;
- }
-
- if (row_major) {
- vec_type = get_instance(element_type->base_type,
- element_type->matrix_columns, 1);
-
- array_len *= element_type->vector_elements;
- } else {
- vec_type = get_instance(element_type->base_type,
- element_type->vector_elements, 1);
- array_len *= element_type->matrix_columns;
- }
- const glsl_type *array_type = glsl_type::get_array_instance(vec_type,
- array_len);
-
- return array_type->std430_size(false);
- }
-
- if (this->is_array()) {
- if (this->without_array()->is_record())
- return this->arrays_of_arrays_size() *
- this->without_array()->std430_size(row_major);
- else
- return this->arrays_of_arrays_size() *
- this->without_array()->std430_base_alignment(row_major);
- }
-
- if (this->is_record() || this->is_interface()) {
- unsigned size = 0;
- unsigned max_align = 0;
-
- for (unsigned i = 0; i < this->length; i++) {
- bool field_row_major = row_major;
- const enum glsl_matrix_layout matrix_layout =
- glsl_matrix_layout(this->fields.structure[i].matrix_layout);
- if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) {
- field_row_major = true;
- } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) {
- field_row_major = false;
- }
-
- const struct glsl_type *field_type = this->fields.structure[i].type;
- unsigned align = field_type->std430_base_alignment(field_row_major);
- size = glsl_align(size, align);
- size += field_type->std430_size(field_row_major);
-
- max_align = MAX2(align, max_align);
- }
- size = glsl_align(size, max_align);
- return size;
- }
-
- assert(!"not reached");
- return -1;
-}
-
-unsigned
-glsl_type::count_attribute_slots(bool vertex_input_slots) const
-{
- /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec:
- *
- * "A scalar input counts the same amount against this limit as a vec4,
- * so applications may want to consider packing groups of four
- * unrelated float inputs together into a vector to better utilize the
- * capabilities of the underlying hardware. A matrix input will use up
- * multiple locations. The number of locations used will equal the
- * number of columns in the matrix."
- *
- * The spec does not explicitly say how arrays are counted. However, it
- * should be safe to assume the total number of slots consumed by an array
- * is the number of entries in the array multiplied by the number of slots
- * consumed by a single element of the array.
- *
- * The spec says nothing about how structs are counted, because vertex
- * attributes are not allowed to be (or contain) structs. However, Mesa
- * allows varying structs, the number of varying slots taken up by a
- * varying struct is simply equal to the sum of the number of slots taken
- * up by each element.
- *
- * Doubles are counted different depending on whether they are vertex
- * inputs or everything else. Vertex inputs from ARB_vertex_attrib_64bit
- * take one location no matter what size they are, otherwise dvec3/4
- * take two locations.
- */
- switch (this->base_type) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_BOOL:
- return this->matrix_columns;
- case GLSL_TYPE_DOUBLE:
- if (this->vector_elements > 2 && !vertex_input_slots)
- return this->matrix_columns * 2;
- else
- return this->matrix_columns;
- case GLSL_TYPE_STRUCT:
- case GLSL_TYPE_INTERFACE: {
- unsigned size = 0;
-
- for (unsigned i = 0; i < this->length; i++)
- size += this->fields.structure[i].type->count_attribute_slots(vertex_input_slots);
-
- return size;
- }
-
- case GLSL_TYPE_ARRAY:
- return this->length * this->fields.array->count_attribute_slots(vertex_input_slots);
-
- case GLSL_TYPE_SAMPLER:
- case GLSL_TYPE_IMAGE:
- case GLSL_TYPE_ATOMIC_UINT:
- case GLSL_TYPE_VOID:
- case GLSL_TYPE_SUBROUTINE:
- case GLSL_TYPE_ERROR:
- break;
- }
-
- assert(!"Unexpected type in count_attribute_slots()");
-
- return 0;
-}
-
-int
-glsl_type::coordinate_components() const
-{
- int size;
-
- switch (sampler_dimensionality) {
- case GLSL_SAMPLER_DIM_1D:
- case GLSL_SAMPLER_DIM_BUF:
- size = 1;
- break;
- case GLSL_SAMPLER_DIM_2D:
- case GLSL_SAMPLER_DIM_RECT:
- case GLSL_SAMPLER_DIM_MS:
- case GLSL_SAMPLER_DIM_EXTERNAL:
- size = 2;
- break;
- case GLSL_SAMPLER_DIM_3D:
- case GLSL_SAMPLER_DIM_CUBE:
- size = 3;
- break;
- default:
- assert(!"Should not get here.");
- size = 1;
- break;
- }
-
- /* Array textures need an additional component for the array index, except
- * for cubemap array images that behave like a 2D array of interleaved
- * cubemap faces.
- */
- if (sampler_array &&
- !(base_type == GLSL_TYPE_IMAGE &&
- sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE))
- size += 1;
-
- return size;
-}
-
-/**
- * Declarations of type flyweights (glsl_type::_foo_type) and
- * convenience pointers (glsl_type::foo_type).
- * @{
- */
-#define DECL_TYPE(NAME, ...) \
- const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \
- const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type;
-
-#define STRUCT_TYPE(NAME)
-
-#include "compiler/builtin_type_macros.h"
-/** @} */
+++ /dev/null
-/* -*- c++ -*- */
-/*
- * Copyright © 2009 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#pragma once
-#ifndef GLSL_TYPES_H
-#define GLSL_TYPES_H
-
-#include <string.h>
-#include <assert.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct _mesa_glsl_parse_state;
-struct glsl_symbol_table;
-
-extern void
-_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state);
-
-extern void
-_mesa_glsl_release_types(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-enum glsl_base_type {
- GLSL_TYPE_UINT = 0,
- GLSL_TYPE_INT,
- GLSL_TYPE_FLOAT,
- GLSL_TYPE_DOUBLE,
- GLSL_TYPE_BOOL,
- GLSL_TYPE_SAMPLER,
- GLSL_TYPE_IMAGE,
- GLSL_TYPE_ATOMIC_UINT,
- GLSL_TYPE_STRUCT,
- GLSL_TYPE_INTERFACE,
- GLSL_TYPE_ARRAY,
- GLSL_TYPE_VOID,
- GLSL_TYPE_SUBROUTINE,
- GLSL_TYPE_ERROR
-};
-
-enum glsl_sampler_dim {
- GLSL_SAMPLER_DIM_1D = 0,
- GLSL_SAMPLER_DIM_2D,
- GLSL_SAMPLER_DIM_3D,
- GLSL_SAMPLER_DIM_CUBE,
- GLSL_SAMPLER_DIM_RECT,
- GLSL_SAMPLER_DIM_BUF,
- GLSL_SAMPLER_DIM_EXTERNAL,
- GLSL_SAMPLER_DIM_MS
-};
-
-enum glsl_interface_packing {
- GLSL_INTERFACE_PACKING_STD140,
- GLSL_INTERFACE_PACKING_SHARED,
- GLSL_INTERFACE_PACKING_PACKED,
- GLSL_INTERFACE_PACKING_STD430
-};
-
-enum glsl_matrix_layout {
- /**
- * The layout of the matrix is inherited from the object containing the
- * matrix (the top level structure or the uniform block).
- */
- GLSL_MATRIX_LAYOUT_INHERITED,
-
- /**
- * Explicit column-major layout
- *
- * If a uniform block doesn't have an explicit layout set, it will default
- * to this layout.
- */
- GLSL_MATRIX_LAYOUT_COLUMN_MAJOR,
-
- /**
- * Row-major layout
- */
- GLSL_MATRIX_LAYOUT_ROW_MAJOR
-};
-
-enum {
- GLSL_PRECISION_NONE = 0,
- GLSL_PRECISION_HIGH,
- GLSL_PRECISION_MEDIUM,
- GLSL_PRECISION_LOW
-};
-
-#ifdef __cplusplus
-#include "GL/gl.h"
-#include "util/ralloc.h"
-#include "main/mtypes.h" /* for gl_texture_index, C++'s enum rules are broken */
-
-struct glsl_type {
- GLenum gl_type;
- glsl_base_type base_type;
-
- unsigned sampler_dimensionality:3; /**< \see glsl_sampler_dim */
- unsigned sampler_shadow:1;
- unsigned sampler_array:1;
- unsigned sampler_type:2; /**< Type of data returned using this
- * sampler or image. Only \c
- * GLSL_TYPE_FLOAT, \c GLSL_TYPE_INT,
- * and \c GLSL_TYPE_UINT are valid.
- */
- unsigned interface_packing:2;
-
- /* Callers of this ralloc-based new need not call delete. It's
- * easier to just ralloc_free 'mem_ctx' (or any of its ancestors). */
- static void* operator new(size_t size)
- {
- mtx_lock(&glsl_type::mutex);
-
- /* mem_ctx should have been created by the static members */
- assert(glsl_type::mem_ctx != NULL);
-
- void *type;
-
- type = ralloc_size(glsl_type::mem_ctx, size);
- assert(type != NULL);
-
- mtx_unlock(&glsl_type::mutex);
-
- return type;
- }
-
- /* If the user *does* call delete, that's OK, we will just
- * ralloc_free in that case. */
- static void operator delete(void *type)
- {
- mtx_lock(&glsl_type::mutex);
- ralloc_free(type);
- mtx_unlock(&glsl_type::mutex);
- }
-
- /**
- * \name Vector and matrix element counts
- *
- * For scalars, each of these values will be 1. For non-numeric types
- * these will be 0.
- */
- /*@{*/
- uint8_t vector_elements; /**< 1, 2, 3, or 4 vector elements. */
- uint8_t matrix_columns; /**< 1, 2, 3, or 4 matrix columns. */
- /*@}*/
-
- /**
- * For \c GLSL_TYPE_ARRAY, this is the length of the array. For
- * \c GLSL_TYPE_STRUCT or \c GLSL_TYPE_INTERFACE, it is the number of
- * elements in the structure and the number of values pointed to by
- * \c fields.structure (below).
- */
- unsigned length;
-
- /**
- * Name of the data type
- *
- * Will never be \c NULL.
- */
- const char *name;
-
- /**
- * Subtype of composite data types.
- */
- union {
- const struct glsl_type *array; /**< Type of array elements. */
- const struct glsl_type *parameters; /**< Parameters to function. */
- struct glsl_struct_field *structure; /**< List of struct fields. */
- } fields;
-
- /**
- * \name Pointers to various public type singletons
- */
- /*@{*/
-#undef DECL_TYPE
-#define DECL_TYPE(NAME, ...) \
- static const glsl_type *const NAME##_type;
-#undef STRUCT_TYPE
-#define STRUCT_TYPE(NAME) \
- static const glsl_type *const struct_##NAME##_type;
-#include "compiler/builtin_type_macros.h"
- /*@}*/
-
- /**
- * Convenience accessors for vector types (shorter than get_instance()).
- * @{
- */
- static const glsl_type *vec(unsigned components);
- static const glsl_type *dvec(unsigned components);
- static const glsl_type *ivec(unsigned components);
- static const glsl_type *uvec(unsigned components);
- static const glsl_type *bvec(unsigned components);
- /**@}*/
-
- /**
- * For numeric and boolean derived types returns the basic scalar type
- *
- * If the type is a numeric or boolean scalar, vector, or matrix type,
- * this function gets the scalar type of the individual components. For
- * all other types, including arrays of numeric or boolean types, the
- * error type is returned.
- */
- const glsl_type *get_base_type() const;
-
- /**
- * Get the basic scalar type which this type aggregates.
- *
- * If the type is a numeric or boolean scalar, vector, or matrix, or an
- * array of any of those, this function gets the scalar type of the
- * individual components. For structs and arrays of structs, this function
- * returns the struct type. For samplers and arrays of samplers, this
- * function returns the sampler type.
- */
- const glsl_type *get_scalar_type() const;
-
- /**
- * Get the instance of a built-in scalar, vector, or matrix type
- */
- static const glsl_type *get_instance(unsigned base_type, unsigned rows,
- unsigned columns);
-
- /**
- * Get the instance of a sampler type
- */
- static const glsl_type *get_sampler_instance(enum glsl_sampler_dim dim,
- bool shadow,
- bool array,
- glsl_base_type type);
-
-
- /**
- * Get the instance of an array type
- */
- static const glsl_type *get_array_instance(const glsl_type *base,
- unsigned elements);
-
- /**
- * Get the instance of a record type
- */
- static const glsl_type *get_record_instance(const glsl_struct_field *fields,
- unsigned num_fields,
- const char *name);
-
- /**
- * Get the instance of an interface block type
- */
- static const glsl_type *get_interface_instance(const glsl_struct_field *fields,
- unsigned num_fields,
- enum glsl_interface_packing packing,
- const char *block_name);
-
- /**
- * Get the instance of an subroutine type
- */
- static const glsl_type *get_subroutine_instance(const char *subroutine_name);
-
- /**
- * Get the type resulting from a multiplication of \p type_a * \p type_b
- */
- static const glsl_type *get_mul_type(const glsl_type *type_a,
- const glsl_type *type_b);
-
- /**
- * Query the total number of scalars that make up a scalar, vector or matrix
- */
- unsigned components() const
- {
- return vector_elements * matrix_columns;
- }
-
- /**
- * Calculate the number of components slots required to hold this type
- *
- * This is used to determine how many uniform or varying locations a type
- * might occupy.
- */
- unsigned component_slots() const;
-
- /**
- * Calculate offset between the base location of the struct in
- * uniform storage and a struct member.
- * For the initial call, length is the index of the member to find the
- * offset for.
- */
- unsigned record_location_offset(unsigned length) const;
-
- /**
- * Calculate the number of unique values from glGetUniformLocation for the
- * elements of the type.
- *
- * This is used to allocate slots in the UniformRemapTable, the amount of
- * locations may not match with actual used storage space by the driver.
- */
- unsigned uniform_locations() const;
-
- /**
- * Calculate the number of attribute slots required to hold this type
- *
- * This implements the language rules of GLSL 1.50 for counting the number
- * of slots used by a vertex attribute. It also determines the number of
- * varying slots the type will use up in the absence of varying packing
- * (and thus, it can be used to measure the number of varying slots used by
- * the varyings that are generated by lower_packed_varyings).
- *
- * For vertex shader attributes - doubles only take one slot.
- * For inter-shader varyings - dvec3/dvec4 take two slots.
- */
- unsigned count_attribute_slots(bool vertex_input_slots) const;
-
- /**
- * Alignment in bytes of the start of this type in a std140 uniform
- * block.
- */
- unsigned std140_base_alignment(bool row_major) const;
-
- /** Size in bytes of this type in a std140 uniform block.
- *
- * Note that this is not GL_UNIFORM_SIZE (which is the number of
- * elements in the array)
- */
- unsigned std140_size(bool row_major) const;
-
- /**
- * Alignment in bytes of the start of this type in a std430 shader
- * storage block.
- */
- unsigned std430_base_alignment(bool row_major) const;
-
- /**
- * Calculate array stride in bytes of this type in a std430 shader storage
- * block.
- */
- unsigned std430_array_stride(bool row_major) const;
-
- /**
- * Size in bytes of this type in a std430 shader storage block.
- *
- * Note that this is not GL_BUFFER_SIZE
- */
- unsigned std430_size(bool row_major) const;
-
- /**
- * \brief Can this type be implicitly converted to another?
- *
- * \return True if the types are identical or if this type can be converted
- * to \c desired according to Section 4.1.10 of the GLSL spec.
- *
- * \verbatim
- * From page 25 (31 of the pdf) of the GLSL 1.50 spec, Section 4.1.10
- * Implicit Conversions:
- *
- * In some situations, an expression and its type will be implicitly
- * converted to a different type. The following table shows all allowed
- * implicit conversions:
- *
- * Type of expression | Can be implicitly converted to
- * --------------------------------------------------
- * int float
- * uint
- *
- * ivec2 vec2
- * uvec2
- *
- * ivec3 vec3
- * uvec3
- *
- * ivec4 vec4
- * uvec4
- *
- * There are no implicit array or structure conversions. For example,
- * an array of int cannot be implicitly converted to an array of float.
- * There are no implicit conversions between signed and unsigned
- * integers.
- * \endverbatim
- */
- bool can_implicitly_convert_to(const glsl_type *desired,
- _mesa_glsl_parse_state *state) const;
-
- /**
- * Query whether or not a type is a scalar (non-vector and non-matrix).
- */
- bool is_scalar() const
- {
- return (vector_elements == 1)
- && (base_type >= GLSL_TYPE_UINT)
- && (base_type <= GLSL_TYPE_BOOL);
- }
-
- /**
- * Query whether or not a type is a vector
- */
- bool is_vector() const
- {
- return (vector_elements > 1)
- && (matrix_columns == 1)
- && (base_type >= GLSL_TYPE_UINT)
- && (base_type <= GLSL_TYPE_BOOL);
- }
-
- /**
- * Query whether or not a type is a matrix
- */
- bool is_matrix() const
- {
- /* GLSL only has float matrices. */
- return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT || base_type == GLSL_TYPE_DOUBLE);
- }
-
- /**
- * Query whether or not a type is a non-array numeric type
- */
- bool is_numeric() const
- {
- return (base_type >= GLSL_TYPE_UINT) && (base_type <= GLSL_TYPE_DOUBLE);
- }
-
- /**
- * Query whether or not a type is an integral type
- */
- bool is_integer() const
- {
- return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT);
- }
-
- /**
- * Query whether or not type is an integral type, or for struct and array
- * types, contains an integral type.
- */
- bool contains_integer() const;
-
- /**
- * Query whether or not type is a double type, or for struct and array
- * types, contains a double type.
- */
- bool contains_double() const;
-
- /**
- * Query whether or not a type is a float type
- */
- bool is_float() const
- {
- return base_type == GLSL_TYPE_FLOAT;
- }
-
- /**
- * Query whether or not a type is a double type
- */
- bool is_double() const
- {
- return base_type == GLSL_TYPE_DOUBLE;
- }
-
- /**
- * Query whether a double takes two slots.
- */
- bool is_dual_slot_double() const
- {
- return base_type == GLSL_TYPE_DOUBLE && vector_elements > 2;
- }
-
- /**
- * Query whether or not a type is a non-array boolean type
- */
- bool is_boolean() const
- {
- return base_type == GLSL_TYPE_BOOL;
- }
-
- /**
- * Query whether or not a type is a sampler
- */
- bool is_sampler() const
- {
- return base_type == GLSL_TYPE_SAMPLER;
- }
-
- /**
- * Query whether or not type is a sampler, or for struct and array
- * types, contains a sampler.
- */
- bool contains_sampler() const;
-
- /**
- * Get the Mesa texture target index for a sampler type.
- */
- gl_texture_index sampler_index() const;
-
- /**
- * Query whether or not type is an image, or for struct and array
- * types, contains an image.
- */
- bool contains_image() const;
-
- /**
- * Query whether or not a type is an image
- */
- bool is_image() const
- {
- return base_type == GLSL_TYPE_IMAGE;
- }
-
- /**
- * Query whether or not a type is an array
- */
- bool is_array() const
- {
- return base_type == GLSL_TYPE_ARRAY;
- }
-
- bool is_array_of_arrays() const
- {
- return is_array() && fields.array->is_array();
- }
-
- /**
- * Query whether or not a type is a record
- */
- bool is_record() const
- {
- return base_type == GLSL_TYPE_STRUCT;
- }
-
- /**
- * Query whether or not a type is an interface
- */
- bool is_interface() const
- {
- return base_type == GLSL_TYPE_INTERFACE;
- }
-
- /**
- * Query whether or not a type is the void type singleton.
- */
- bool is_void() const
- {
- return base_type == GLSL_TYPE_VOID;
- }
-
- /**
- * Query whether or not a type is the error type singleton.
- */
- bool is_error() const
- {
- return base_type == GLSL_TYPE_ERROR;
- }
-
- /**
- * Query if a type is unnamed/anonymous (named by the parser)
- */
-
- bool is_subroutine() const
- {
- return base_type == GLSL_TYPE_SUBROUTINE;
- }
- bool contains_subroutine() const;
-
- bool is_anonymous() const
- {
- return !strncmp(name, "#anon", 5);
- }
-
- /**
- * Get the type stripped of any arrays
- *
- * \return
- * Pointer to the type of elements of the first non-array type for array
- * types, or pointer to itself for non-array types.
- */
- const glsl_type *without_array() const
- {
- const glsl_type *t = this;
-
- while (t->is_array())
- t = t->fields.array;
-
- return t;
- }
-
- /**
- * Return the total number of elements in an array including the elements
- * in arrays of arrays.
- */
- unsigned arrays_of_arrays_size() const
- {
- if (!is_array())
- return 0;
-
- unsigned size = length;
- const glsl_type *base_type = fields.array;
-
- while (base_type->is_array()) {
- size = size * base_type->length;
- base_type = base_type->fields.array;
- }
- return size;
- }
-
- /**
- * Return the amount of atomic counter storage required for a type.
- */
- unsigned atomic_size() const
- {
- if (base_type == GLSL_TYPE_ATOMIC_UINT)
- return ATOMIC_COUNTER_SIZE;
- else if (is_array())
- return length * fields.array->atomic_size();
- else
- return 0;
- }
-
- /**
- * Return whether a type contains any atomic counters.
- */
- bool contains_atomic() const
- {
- return atomic_size() > 0;
- }
-
- /**
- * Return whether a type contains any opaque types.
- */
- bool contains_opaque() const;
-
- /**
- * Query the full type of a matrix row
- *
- * \return
- * If the type is not a matrix, \c glsl_type::error_type is returned.
- * Otherwise a type matching the rows of the matrix is returned.
- */
- const glsl_type *row_type() const
- {
- return is_matrix()
- ? get_instance(base_type, matrix_columns, 1)
- : error_type;
- }
-
- /**
- * Query the full type of a matrix column
- *
- * \return
- * If the type is not a matrix, \c glsl_type::error_type is returned.
- * Otherwise a type matching the columns of the matrix is returned.
- */
- const glsl_type *column_type() const
- {
- return is_matrix()
- ? get_instance(base_type, vector_elements, 1)
- : error_type;
- }
-
- /**
- * Get the type of a structure field
- *
- * \return
- * Pointer to the type of the named field. If the type is not a structure
- * or the named field does not exist, \c glsl_type::error_type is returned.
- */
- const glsl_type *field_type(const char *name) const;
-
- /**
- * Get the location of a field within a record type
- */
- int field_index(const char *name) const;
-
- /**
- * Query the number of elements in an array type
- *
- * \return
- * The number of elements in the array for array types or -1 for non-array
- * types. If the number of elements in the array has not yet been declared,
- * zero is returned.
- */
- int array_size() const
- {
- return is_array() ? length : -1;
- }
-
- /**
- * Query whether the array size for all dimensions has been declared.
- */
- bool is_unsized_array() const
- {
- return is_array() && length == 0;
- }
-
- /**
- * Return the number of coordinate components needed for this
- * sampler or image type.
- *
- * This is based purely on the sampler's dimensionality. For example, this
- * returns 1 for sampler1D, and 3 for sampler2DArray.
- *
- * Note that this is often different than actual coordinate type used in
- * a texturing built-in function, since those pack additional values (such
- * as the shadow comparitor or projector) into the coordinate type.
- */
- int coordinate_components() const;
-
- /**
- * Compare a record type against another record type.
- *
- * This is useful for matching record types declared across shader stages.
- */
- bool record_compare(const glsl_type *b) const;
-
-private:
-
- static mtx_t mutex;
-
- /**
- * ralloc context for all glsl_type allocations
- *
- * Set on the first call to \c glsl_type::new.
- */
- static void *mem_ctx;
-
- void init_ralloc_type_ctx(void);
-
- /** Constructor for vector and matrix types */
- glsl_type(GLenum gl_type,
- glsl_base_type base_type, unsigned vector_elements,
- unsigned matrix_columns, const char *name);
-
- /** Constructor for sampler or image types */
- glsl_type(GLenum gl_type, glsl_base_type base_type,
- enum glsl_sampler_dim dim, bool shadow, bool array,
- unsigned type, const char *name);
-
- /** Constructor for record types */
- glsl_type(const glsl_struct_field *fields, unsigned num_fields,
- const char *name);
-
- /** Constructor for interface types */
- glsl_type(const glsl_struct_field *fields, unsigned num_fields,
- enum glsl_interface_packing packing, const char *name);
-
- /** Constructor for array types */
- glsl_type(const glsl_type *array, unsigned length);
-
- /** Constructor for subroutine types */
- glsl_type(const char *name);
-
- /** Hash table containing the known array types. */
- static struct hash_table *array_types;
-
- /** Hash table containing the known record types. */
- static struct hash_table *record_types;
-
- /** Hash table containing the known interface types. */
- static struct hash_table *interface_types;
-
- /** Hash table containing the known subroutine types. */
- static struct hash_table *subroutine_types;
-
- static bool record_key_compare(const void *a, const void *b);
- static unsigned record_key_hash(const void *key);
-
- /**
- * \name Built-in type flyweights
- */
- /*@{*/
-#undef DECL_TYPE
-#define DECL_TYPE(NAME, ...) static const glsl_type _##NAME##_type;
-#undef STRUCT_TYPE
-#define STRUCT_TYPE(NAME) static const glsl_type _struct_##NAME##_type;
-#include "compiler/builtin_type_macros.h"
- /*@}*/
-
- /**
- * \name Friend functions.
- *
- * These functions are friends because they must have C linkage and the
- * need to call various private methods or access various private static
- * data.
- */
- /*@{*/
- friend void _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *);
- friend void _mesa_glsl_release_types(void);
- /*@}*/
-};
-
-struct glsl_struct_field {
- const struct glsl_type *type;
- const char *name;
-
- /**
- * For interface blocks, gl_varying_slot corresponding to the input/output
- * if this is a built-in input/output (i.e. a member of the built-in
- * gl_PerVertex interface block); -1 otherwise.
- *
- * Ignored for structs.
- */
- int location;
-
- /**
- * For interface blocks, the interpolation mode (as in
- * ir_variable::interpolation). 0 otherwise.
- */
- unsigned interpolation:2;
-
- /**
- * For interface blocks, 1 if this variable uses centroid interpolation (as
- * in ir_variable::centroid). 0 otherwise.
- */
- unsigned centroid:1;
-
- /**
- * For interface blocks, 1 if this variable uses sample interpolation (as
- * in ir_variable::sample). 0 otherwise.
- */
- unsigned sample:1;
-
- /**
- * Layout of the matrix. Uses glsl_matrix_layout values.
- */
- unsigned matrix_layout:2;
-
- /**
- * For interface blocks, 1 if this variable is a per-patch input or output
- * (as in ir_variable::patch). 0 otherwise.
- */
- unsigned patch:1;
-
- /**
- * Precision qualifier
- */
- unsigned precision:2;
-
- /**
- * Image qualifiers, applicable to buffer variables defined in shader
- * storage buffer objects (SSBOs)
- */
- unsigned image_read_only:1;
- unsigned image_write_only:1;
- unsigned image_coherent:1;
- unsigned image_volatile:1;
- unsigned image_restrict:1;
-
- glsl_struct_field(const struct glsl_type *_type, const char *_name)
- : type(_type), name(_name), location(-1), interpolation(0), centroid(0),
- sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0),
- precision(GLSL_PRECISION_NONE)
- {
- /* empty */
- }
-
- glsl_struct_field()
- {
- /* empty */
- }
-};
-
-static inline unsigned int
-glsl_align(unsigned int a, unsigned int align)
-{
- return (a + align - 1) / align * align;
-}
-
-#undef DECL_TYPE
-#undef STRUCT_TYPE
-#endif /* __cplusplus */
-
-#endif /* GLSL_TYPES_H */
#include <stdio.h>
-/* C wrapper around glsl_types.h */
+/* C wrapper around compiler/glsl_types.h */
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#ifdef __cplusplus
extern "C" {
#include "ir_rvalue_visitor.h"
#include "ir_optimization.h"
#include "ir_builder.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
using namespace ir_builder;
#include "ir.h"
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
static bool debug = false;
* (discard <condition>)
*/
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "ir.h"
namespace {
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir_rvalue_visitor.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "util/hash_table.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "util/hash_table.h"
namespace {
#include "ir_visitor.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir_rvalue_visitor.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
static bool debug = false;
#include "ir_rvalue_visitor.h"
#include "ir_optimization.h"
#include "ir_print_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "link_varyings.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_variable_refcount.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "util/hash_table.h"
static bool debug = false;
#include "ir.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
static bool debug = false;
#include "ir.h"
#include "ir_visitor.h"
#include "ir_expression_flattening.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir_visitor.h"
#include "ir_function_inlining.h"
#include "ir_expression_flattening.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/hash_table.h"
static void
#include "ir_optimization.h"
#include "ir_builder.h"
#include "program/prog_instruction.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "main/macros.h"
using namespace ir_builder;
#include "ir.h"
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_rvalue_visitor.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir_variable_refcount.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
namespace {
#include "ir.h"
#include "ir_visitor.h"
#include "ir_optimization.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/prog_instruction.h"
namespace {
'#/src',
'#/src/mapi',
'#/src/glsl',
- '#/src/glsl/nir',
'#/src/mesa',
'#/src/gallium/include',
'#/src/gallium/auxiliary',
* \author Eric Anholt <eric@anholt.net>
*/
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl/ir.h"
#include "program/prog_instruction.h" /* For WRITEMASK_* */
#include "brw_cfg.h"
#include "brw_program.h"
#include "brw_dead_control_flow.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
using namespace brw;
#include "glsl/ir.h"
#include "glsl/ir_expression_flattening.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
class ir_channel_expressions_visitor : public ir_hierarchical_visitor {
public:
#include "main/imports.h"
#include "glsl/ir.h"
#include "glsl/ir_rvalue_visitor.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "util/hash_table.h"
static bool debug = false;
* in the GLSL IR or in the native code.
*/
#include "brw_fs.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
using namespace brw;
* \author Chris Forbes <chrisf@ijw.co.nz>
*/
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl/ir.h"
#include "glsl/ir_builder.h"
#include "glsl/ir_optimization.h"
#include "glsl/glsl_parser_extras.h"
#include "glsl/glsl_symbol_table.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/ir_to_mesa.h"
#include "program/program.h"
#include "program/programopt.h"
#include "main/uniforms.h"
#include "main/enums.h"
#include "ir_uniform.h"
-#include "glsl_types.h"
+#include "compiler/glsl_types.h"
#include "program/program.h"
/**
#define UNIFORMS_H
#include "main/glheader.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl/ir_uniform.h"
#include "program/prog_parameter.h"
#include "glsl/ir_optimization.h"
#include "glsl/ir_uniform.h"
#include "glsl/glsl_parser_extras.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl/linker.h"
#include "glsl/program.h"
#include "program/hash_table.h"
*/
#include "main/mtypes.h"
-#include "glsl/nir/glsl_types.h"
+#include "compiler/glsl_types.h"
#include "glsl/ir.h"
#include "glsl/ir_uniform.h"
#include "glsl/ir_visitor.h"
projects / mesa.git / commitdiff