From: Emil Velikov Date: Mon, 18 Jan 2016 09:35:29 +0000 (+0200) Subject: nir: move glsl_types.{cpp,h} to compiler X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=24f984f64ae58c274f79eaf9148aea37df67131c;p=mesa.git nir: move glsl_types.{cpp,h} to compiler Allows us to remove the SCons workaround :-) Signed-off-by: Emil Velikov Acked-by: Matt Turner Acked-by: Jose Fonseca --- diff --git a/src/compiler/Makefile.sources b/src/compiler/Makefile.sources index 73e1771c8a7..38e75cfd8c6 100644 --- a/src/compiler/Makefile.sources +++ b/src/compiler/Makefile.sources @@ -1,4 +1,6 @@ LIBCOMPILER_FILES = \ builtin_type_macros.h \ + glsl_types.cpp \ + glsl_types.h \ shader_enums.c \ shader_enums.h diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp new file mode 100644 index 00000000000..7e60e7c1098 --- /dev/null +++ b/src/compiler/glsl_types.cpp @@ -0,0 +1,1758 @@ +/* + * 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 +#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 basic machine units, the + * base alignment is . + * + * (2) If the member is a two- or four-component vector with components + * consuming basic machine units, the base alignment is 2 or + * 4, respectively. + * + * (3) If the member is a three-component vector with components consuming + * basic machine units, the base alignment is 4. + */ + 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 column-major matrices with + * columns and rows, the matrix is stored identically to a row of + * * column vectors with components each, according to rule + * (4). + * + * (8) If the member is an array of row-major matrices with columns + * and rows, the matrix is stored identically to a row of * + * row vectors with components each, according to rule (4). + * + * (10) If the member is an array of structures, the 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 columns and + * rows, the matrix is stored identically to an array of + * column vectors with components each, according to + * rule (4). + * + * (7) If the member is a row-major matrix with columns and + * rows, the matrix is stored identically to an array of + * row vectors with 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 , where 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 basic machine units, the + * base alignment is . + * + * (2) If the member is a two- or four-component vector with components + * consuming basic machine units, the base alignment is 2 or + * 4, respectively. + * + * (3) If the member is a three-component vector with components consuming + * basic machine units, the base alignment is 4. + */ + if (this->is_scalar() || this->is_vector()) { + return this->vector_elements * N; + } + + /* (5) If the member is a column-major matrix with columns and + * rows, the matrix is stored identically to an array of + * column vectors with components each, according to + * rule (4). + * + * (6) If the member is an array of column-major matrices with + * columns and rows, the matrix is stored identically to a row of + * * column vectors with components each, according to rule + * (4). + * + * (7) If the member is a row-major matrix with columns and + * rows, the matrix is stored identically to an array of + * row vectors with components each, according to rule (4). + * + * (8) If the member is an array of row-major matrices with columns + * and rows, the matrix is stored identically to a row of * + * row vectors with 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 structures, the 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 , where 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 basic machine units, the + * base alignment is . + * + * (2) If the member is a two- or four-component vector with components + * consuming basic machine units, the base alignment is 2 or + * 4, respectively. + * + * (3) If the member is a three-component vector with components consuming + * basic machine units, the base alignment is 4. + */ + 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 basic machine units, the + * base alignment is . + * + * (2) If the member is a two- or four-component vector with components + * consuming basic machine units, the base alignment is 2 or + * 4, respectively. + * + * (3) If the member is a three-component vector with components consuming + * basic machine units, the base alignment is 4. + */ + if (this->is_array()) + return this->fields.array->std430_base_alignment(row_major); + + /* (5) If the member is a column-major matrix with columns and + * rows, the matrix is stored identically to an array of + * column vectors with components each, according to + * rule (4). + * + * (7) If the member is a row-major matrix with columns and + * rows, the matrix is stored identically to an array of + * row vectors with 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 , where 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 + * basic machine units, the base alignment is 4. + */ + 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" +/** @} */ diff --git a/src/compiler/glsl_types.h b/src/compiler/glsl_types.h new file mode 100644 index 00000000000..e63d7945c9f --- /dev/null +++ b/src/compiler/glsl_types.h @@ -0,0 +1,887 @@ +/* -*- 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 +#include + +#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 */ diff --git a/src/glsl/Makefile.sources b/src/glsl/Makefile.sources index 5a576bc3c7e..a3df4c4263d 100644 --- a/src/glsl/Makefile.sources +++ b/src/glsl/Makefile.sources @@ -18,8 +18,6 @@ NIR_GENERATED_FILES = \ 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 \ diff --git a/src/glsl/SConscript b/src/glsl/SConscript index e89d4e0eb01..ef82a9d317a 100644 --- a/src/glsl/SConscript +++ b/src/glsl/SConscript @@ -16,7 +16,6 @@ env.Prepend(CPPPATH = [ '#src/gallium/include', '#src/gallium/auxiliary', '#src/glsl', - '#src/glsl/nir', '#src/glsl/glcpp', ]) @@ -61,12 +60,6 @@ source_lists = env.ParseSourceList('Makefile.sources') 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]) diff --git a/src/glsl/ast_array_index.cpp b/src/glsl/ast_array_index.cpp index ca7a9a10c36..f5baeb9ea32 100644 --- a/src/glsl/ast_array_index.cpp +++ b/src/glsl/ast_array_index.cpp @@ -22,7 +22,7 @@ */ #include "ast.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "ir.h" void diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp index e32a588f091..0eb456a2b1f 100644 --- a/src/glsl/ast_function.cpp +++ b/src/glsl/ast_function.cpp @@ -23,7 +23,7 @@ #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" diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp index cb57c16f089..dfd31966eb0 100644 --- a/src/glsl/ast_to_hir.cpp +++ b/src/glsl/ast_to_hir.cpp @@ -52,7 +52,7 @@ #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" diff --git a/src/glsl/builtin_types.cpp b/src/glsl/builtin_types.cpp index 4402e2898b2..ee24bd5e411 100644 --- a/src/glsl/builtin_types.cpp +++ b/src/glsl/builtin_types.cpp @@ -34,7 +34,7 @@ * version and set of enabled extensions. */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "glsl_parser_extras.h" #include "util/macros.h" diff --git a/src/glsl/glsl_parser.yy b/src/glsl/glsl_parser.yy index 2109fb2eedd..99bd0e61d0e 100644 --- a/src/glsl/glsl_parser.yy +++ b/src/glsl/glsl_parser.yy @@ -31,7 +31,7 @@ #include "ast.h" #include "glsl_parser_extras.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "main/context.h" #ifdef _MSC_VER diff --git a/src/glsl/hir_field_selection.cpp b/src/glsl/hir_field_selection.cpp index 92bb4139194..eab08ad8235 100644 --- a/src/glsl/hir_field_selection.cpp +++ b/src/glsl/hir_field_selection.cpp @@ -24,7 +24,7 @@ #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, diff --git a/src/glsl/ir.cpp b/src/glsl/ir.cpp index b424edd8e96..de9d314bae4 100644 --- a/src/glsl/ir.cpp +++ b/src/glsl/ir.cpp @@ -23,7 +23,7 @@ #include #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) diff --git a/src/glsl/ir.h b/src/glsl/ir.h index 5b845c6e856..bd7b5506343 100644 --- a/src/glsl/ir.h +++ b/src/glsl/ir.h @@ -30,7 +30,7 @@ #include #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" diff --git a/src/glsl/ir_clone.cpp b/src/glsl/ir_clone.cpp index bee60a241e4..0965b0d3719 100644 --- a/src/glsl/ir_clone.cpp +++ b/src/glsl/ir_clone.cpp @@ -24,7 +24,7 @@ #include #include "main/compiler.h" #include "ir.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "program/hash_table.h" ir_rvalue * diff --git a/src/glsl/ir_constant_expression.cpp b/src/glsl/ir_constant_expression.cpp index c99a8239cbb..fbbf7794da6 100644 --- a/src/glsl/ir_constant_expression.cpp +++ b/src/glsl/ir_constant_expression.cpp @@ -38,7 +38,7 @@ #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 diff --git a/src/glsl/ir_function.cpp b/src/glsl/ir_function.cpp index 93034bedb5a..0b4cb4bd30d 100644 --- a/src/glsl/ir_function.cpp +++ b/src/glsl/ir_function.cpp @@ -21,7 +21,7 @@ * 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" diff --git a/src/glsl/ir_print_visitor.cpp b/src/glsl/ir_print_visitor.cpp index fd7bc2eea98..960b23fe0ed 100644 --- a/src/glsl/ir_print_visitor.cpp +++ b/src/glsl/ir_print_visitor.cpp @@ -22,7 +22,7 @@ */ #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" diff --git a/src/glsl/ir_reader.cpp b/src/glsl/ir_reader.cpp index 7c0af1b712f..15315aac522 100644 --- a/src/glsl/ir_reader.cpp +++ b/src/glsl/ir_reader.cpp @@ -23,7 +23,7 @@ #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; diff --git a/src/glsl/ir_rvalue_visitor.cpp b/src/glsl/ir_rvalue_visitor.cpp index 6486838b8b8..6ab6cf02176 100644 --- a/src/glsl/ir_rvalue_visitor.cpp +++ b/src/glsl/ir_rvalue_visitor.cpp @@ -32,7 +32,7 @@ #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) diff --git a/src/glsl/ir_set_program_inouts.cpp b/src/glsl/ir_set_program_inouts.cpp index a2dea67c6a9..df06923b870 100644 --- a/src/glsl/ir_set_program_inouts.cpp +++ b/src/glsl/ir_set_program_inouts.cpp @@ -40,7 +40,7 @@ #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 { diff --git a/src/glsl/ir_validate.cpp b/src/glsl/ir_validate.cpp index 94814799b9b..cad7069bf98 100644 --- a/src/glsl/ir_validate.cpp +++ b/src/glsl/ir_validate.cpp @@ -37,7 +37,7 @@ #include "ir_hierarchical_visitor.h" #include "util/hash_table.h" #include "util/set.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/ir_variable_refcount.cpp b/src/glsl/ir_variable_refcount.cpp index 790627bd1e3..8306be10b9c 100644 --- a/src/glsl/ir_variable_refcount.cpp +++ b/src/glsl/ir_variable_refcount.cpp @@ -32,7 +32,7 @@ #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() diff --git a/src/glsl/ir_variable_refcount.h b/src/glsl/ir_variable_refcount.h index 5c74c314781..08a11c01495 100644 --- a/src/glsl/ir_variable_refcount.h +++ b/src/glsl/ir_variable_refcount.h @@ -31,7 +31,7 @@ #include "ir.h" #include "ir_visitor.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" struct assignment_entry { exec_node link; diff --git a/src/glsl/loop_analysis.cpp b/src/glsl/loop_analysis.cpp index 21d46ebce53..096a80abb34 100644 --- a/src/glsl/loop_analysis.cpp +++ b/src/glsl/loop_analysis.cpp @@ -21,7 +21,7 @@ * DEALINGS IN THE SOFTWARE. */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "loop_analysis.h" #include "ir_hierarchical_visitor.h" diff --git a/src/glsl/loop_controls.cpp b/src/glsl/loop_controls.cpp index 51804bb5fe8..c717605ec74 100644 --- a/src/glsl/loop_controls.cpp +++ b/src/glsl/loop_controls.cpp @@ -23,7 +23,7 @@ #include #include "main/compiler.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "loop_analysis.h" #include "ir_hierarchical_visitor.h" diff --git a/src/glsl/loop_unroll.cpp b/src/glsl/loop_unroll.cpp index b9ea3507782..aea2743cdb1 100644 --- a/src/glsl/loop_unroll.cpp +++ b/src/glsl/loop_unroll.cpp @@ -21,7 +21,7 @@ * DEALINGS IN THE SOFTWARE. */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "loop_analysis.h" #include "ir_hierarchical_visitor.h" diff --git a/src/glsl/lower_const_arrays_to_uniforms.cpp b/src/glsl/lower_const_arrays_to_uniforms.cpp index 44967dcdb53..2d024d4b78c 100644 --- a/src/glsl/lower_const_arrays_to_uniforms.cpp +++ b/src/glsl/lower_const_arrays_to_uniforms.cpp @@ -40,7 +40,7 @@ #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 { diff --git a/src/glsl/lower_discard.cpp b/src/glsl/lower_discard.cpp index b44d2a6d28d..b62eb20dcb4 100644 --- a/src/glsl/lower_discard.cpp +++ b/src/glsl/lower_discard.cpp @@ -105,7 +105,7 @@ * Unconditional discards are treated as having a condition of "true". */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "ir.h" namespace { diff --git a/src/glsl/lower_discard_flow.cpp b/src/glsl/lower_discard_flow.cpp index ee45bf22155..9d0a56b230d 100644 --- a/src/glsl/lower_discard_flow.cpp +++ b/src/glsl/lower_discard_flow.cpp @@ -44,7 +44,7 @@ * interpretation. */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "ir.h" #include "program/hash_table.h" diff --git a/src/glsl/lower_if_to_cond_assign.cpp b/src/glsl/lower_if_to_cond_assign.cpp index 3232ce92aab..6a7034794b2 100644 --- a/src/glsl/lower_if_to_cond_assign.cpp +++ b/src/glsl/lower_if_to_cond_assign.cpp @@ -45,7 +45,7 @@ * 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" diff --git a/src/glsl/lower_instructions.cpp b/src/glsl/lower_instructions.cpp index 7c2d4d7ce51..1875149b7a6 100644 --- a/src/glsl/lower_instructions.cpp +++ b/src/glsl/lower_instructions.cpp @@ -117,7 +117,7 @@ #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" diff --git a/src/glsl/lower_jumps.cpp b/src/glsl/lower_jumps.cpp index ec7a0c537ff..3cfa2e00ae8 100644 --- a/src/glsl/lower_jumps.cpp +++ b/src/glsl/lower_jumps.cpp @@ -56,7 +56,7 @@ * prevents further optimization, and thus is not currently performed. */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include #include "ir.h" diff --git a/src/glsl/lower_mat_op_to_vec.cpp b/src/glsl/lower_mat_op_to_vec.cpp index e96cda216dd..266fdc6a250 100644 --- a/src/glsl/lower_mat_op_to_vec.cpp +++ b/src/glsl/lower_mat_op_to_vec.cpp @@ -33,7 +33,7 @@ #include "ir.h" #include "ir_expression_flattening.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/lower_offset_array.cpp b/src/glsl/lower_offset_array.cpp index c30f8014342..96486c3a711 100644 --- a/src/glsl/lower_offset_array.cpp +++ b/src/glsl/lower_offset_array.cpp @@ -31,7 +31,7 @@ * \author Chris Forbes */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "ir.h" #include "ir_builder.h" #include "ir_optimization.h" diff --git a/src/glsl/lower_subroutine.cpp b/src/glsl/lower_subroutine.cpp index ac8ade13d99..e80c1be768a 100644 --- a/src/glsl/lower_subroutine.cpp +++ b/src/glsl/lower_subroutine.cpp @@ -27,7 +27,7 @@ * 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" diff --git a/src/glsl/lower_variable_index_to_cond_assign.cpp b/src/glsl/lower_variable_index_to_cond_assign.cpp index a1ba9345e32..278d5450bfb 100644 --- a/src/glsl/lower_variable_index_to_cond_assign.cpp +++ b/src/glsl/lower_variable_index_to_cond_assign.cpp @@ -49,7 +49,7 @@ #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" /** diff --git a/src/glsl/lower_vec_index_to_cond_assign.cpp b/src/glsl/lower_vec_index_to_cond_assign.cpp index b6238825f8a..784db085924 100644 --- a/src/glsl/lower_vec_index_to_cond_assign.cpp +++ b/src/glsl/lower_vec_index_to_cond_assign.cpp @@ -39,7 +39,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/lower_vec_index_to_swizzle.cpp b/src/glsl/lower_vec_index_to_swizzle.cpp index 4d4d2f17ef6..8b18e95509c 100644 --- a/src/glsl/lower_vec_index_to_swizzle.cpp +++ b/src/glsl/lower_vec_index_to_swizzle.cpp @@ -32,7 +32,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "main/macros.h" /** diff --git a/src/glsl/nir/glsl_types.cpp b/src/glsl/nir/glsl_types.cpp deleted file mode 100644 index 655d3b1fe48..00000000000 --- a/src/glsl/nir/glsl_types.cpp +++ /dev/null @@ -1,1758 +0,0 @@ -/* - * 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 -#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 basic machine units, the - * base alignment is . - * - * (2) If the member is a two- or four-component vector with components - * consuming basic machine units, the base alignment is 2 or - * 4, respectively. - * - * (3) If the member is a three-component vector with components consuming - * basic machine units, the base alignment is 4. - */ - 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 column-major matrices with - * columns and rows, the matrix is stored identically to a row of - * * column vectors with components each, according to rule - * (4). - * - * (8) If the member is an array of row-major matrices with columns - * and rows, the matrix is stored identically to a row of * - * row vectors with components each, according to rule (4). - * - * (10) If the member is an array of structures, the 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 columns and - * rows, the matrix is stored identically to an array of - * column vectors with components each, according to - * rule (4). - * - * (7) If the member is a row-major matrix with columns and - * rows, the matrix is stored identically to an array of - * row vectors with 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 , where 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 basic machine units, the - * base alignment is . - * - * (2) If the member is a two- or four-component vector with components - * consuming basic machine units, the base alignment is 2 or - * 4, respectively. - * - * (3) If the member is a three-component vector with components consuming - * basic machine units, the base alignment is 4. - */ - if (this->is_scalar() || this->is_vector()) { - return this->vector_elements * N; - } - - /* (5) If the member is a column-major matrix with columns and - * rows, the matrix is stored identically to an array of - * column vectors with components each, according to - * rule (4). - * - * (6) If the member is an array of column-major matrices with - * columns and rows, the matrix is stored identically to a row of - * * column vectors with components each, according to rule - * (4). - * - * (7) If the member is a row-major matrix with columns and - * rows, the matrix is stored identically to an array of - * row vectors with components each, according to rule (4). - * - * (8) If the member is an array of row-major matrices with columns - * and rows, the matrix is stored identically to a row of * - * row vectors with 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 structures, the 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 , where 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 basic machine units, the - * base alignment is . - * - * (2) If the member is a two- or four-component vector with components - * consuming basic machine units, the base alignment is 2 or - * 4, respectively. - * - * (3) If the member is a three-component vector with components consuming - * basic machine units, the base alignment is 4. - */ - 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 basic machine units, the - * base alignment is . - * - * (2) If the member is a two- or four-component vector with components - * consuming basic machine units, the base alignment is 2 or - * 4, respectively. - * - * (3) If the member is a three-component vector with components consuming - * basic machine units, the base alignment is 4. - */ - if (this->is_array()) - return this->fields.array->std430_base_alignment(row_major); - - /* (5) If the member is a column-major matrix with columns and - * rows, the matrix is stored identically to an array of - * column vectors with components each, according to - * rule (4). - * - * (7) If the member is a row-major matrix with columns and - * rows, the matrix is stored identically to an array of - * row vectors with 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 , where 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 - * basic machine units, the base alignment is 4. - */ - 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" -/** @} */ diff --git a/src/glsl/nir/glsl_types.h b/src/glsl/nir/glsl_types.h deleted file mode 100644 index e63d7945c9f..00000000000 --- a/src/glsl/nir/glsl_types.h +++ /dev/null @@ -1,887 +0,0 @@ -/* -*- 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 -#include - -#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 */ diff --git a/src/glsl/nir/nir_types.h b/src/glsl/nir/nir_types.h index 64a75f607d5..197978804cc 100644 --- a/src/glsl/nir/nir_types.h +++ b/src/glsl/nir/nir_types.h @@ -29,9 +29,9 @@ #include -/* 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" { diff --git a/src/glsl/opt_algebraic.cpp b/src/glsl/opt_algebraic.cpp index c4b87151199..1e58062cb0d 100644 --- a/src/glsl/opt_algebraic.cpp +++ b/src/glsl/opt_algebraic.cpp @@ -33,7 +33,7 @@ #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; diff --git a/src/glsl/opt_array_splitting.cpp b/src/glsl/opt_array_splitting.cpp index 89ce76bed2b..cceec6b6431 100644 --- a/src/glsl/opt_array_splitting.cpp +++ b/src/glsl/opt_array_splitting.cpp @@ -36,7 +36,7 @@ #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; diff --git a/src/glsl/opt_conditional_discard.cpp b/src/glsl/opt_conditional_discard.cpp index 8a3ad24873e..1ca8803f643 100644 --- a/src/glsl/opt_conditional_discard.cpp +++ b/src/glsl/opt_conditional_discard.cpp @@ -33,7 +33,7 @@ * (discard ) */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "ir.h" namespace { diff --git a/src/glsl/opt_constant_folding.cpp b/src/glsl/opt_constant_folding.cpp index 4aae3f0ddf2..150a17b2af6 100644 --- a/src/glsl/opt_constant_folding.cpp +++ b/src/glsl/opt_constant_folding.cpp @@ -30,7 +30,7 @@ #include "ir_visitor.h" #include "ir_rvalue_visitor.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_constant_propagation.cpp b/src/glsl/opt_constant_propagation.cpp index fb24a4fad04..416ba16a3c5 100644 --- a/src/glsl/opt_constant_propagation.cpp +++ b/src/glsl/opt_constant_propagation.cpp @@ -39,7 +39,7 @@ #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 { diff --git a/src/glsl/opt_constant_variable.cpp b/src/glsl/opt_constant_variable.cpp index 56f6a819e1e..3ddb12904c7 100644 --- a/src/glsl/opt_constant_variable.cpp +++ b/src/glsl/opt_constant_variable.cpp @@ -35,7 +35,7 @@ #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 { diff --git a/src/glsl/opt_copy_propagation.cpp b/src/glsl/opt_copy_propagation.cpp index 5d4cb4fe613..310708db868 100644 --- a/src/glsl/opt_copy_propagation.cpp +++ b/src/glsl/opt_copy_propagation.cpp @@ -36,7 +36,7 @@ #include "ir_visitor.h" #include "ir_basic_block.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_copy_propagation_elements.cpp b/src/glsl/opt_copy_propagation_elements.cpp index 353a5c66841..a6791801943 100644 --- a/src/glsl/opt_copy_propagation_elements.cpp +++ b/src/glsl/opt_copy_propagation_elements.cpp @@ -45,7 +45,7 @@ #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; diff --git a/src/glsl/opt_dead_builtin_varyings.cpp b/src/glsl/opt_dead_builtin_varyings.cpp index 53871130e12..37bcbccf0c5 100644 --- a/src/glsl/opt_dead_builtin_varyings.cpp +++ b/src/glsl/opt_dead_builtin_varyings.cpp @@ -51,7 +51,7 @@ #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 { diff --git a/src/glsl/opt_dead_code.cpp b/src/glsl/opt_dead_code.cpp index c2ce0b94ece..dbdb7de8bb8 100644 --- a/src/glsl/opt_dead_code.cpp +++ b/src/glsl/opt_dead_code.cpp @@ -30,7 +30,7 @@ #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; diff --git a/src/glsl/opt_dead_code_local.cpp b/src/glsl/opt_dead_code_local.cpp index ee9f22c0373..d38fd2bf638 100644 --- a/src/glsl/opt_dead_code_local.cpp +++ b/src/glsl/opt_dead_code_local.cpp @@ -36,7 +36,7 @@ #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; diff --git a/src/glsl/opt_dead_functions.cpp b/src/glsl/opt_dead_functions.cpp index 5dff165215a..2e90b650fa8 100644 --- a/src/glsl/opt_dead_functions.cpp +++ b/src/glsl/opt_dead_functions.cpp @@ -30,7 +30,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_expression_flattening.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_function_inlining.cpp b/src/glsl/opt_function_inlining.cpp index 84a9e4fa093..19f5fae0a17 100644 --- a/src/glsl/opt_function_inlining.cpp +++ b/src/glsl/opt_function_inlining.cpp @@ -31,7 +31,7 @@ #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 diff --git a/src/glsl/opt_minmax.cpp b/src/glsl/opt_minmax.cpp index 23d0b109d8b..29482ee69de 100644 --- a/src/glsl/opt_minmax.cpp +++ b/src/glsl/opt_minmax.cpp @@ -36,7 +36,7 @@ #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; diff --git a/src/glsl/opt_noop_swizzle.cpp b/src/glsl/opt_noop_swizzle.cpp index 586ad5e6107..41890ab2b15 100644 --- a/src/glsl/opt_noop_swizzle.cpp +++ b/src/glsl/opt_noop_swizzle.cpp @@ -32,7 +32,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_rvalue_visitor.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_structure_splitting.cpp b/src/glsl/opt_structure_splitting.cpp index abf4310feb3..0d18a2f7584 100644 --- a/src/glsl/opt_structure_splitting.cpp +++ b/src/glsl/opt_structure_splitting.cpp @@ -35,7 +35,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_rvalue_visitor.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_swizzle_swizzle.cpp b/src/glsl/opt_swizzle_swizzle.cpp index 7564c6b3b10..7285474b089 100644 --- a/src/glsl/opt_swizzle_swizzle.cpp +++ b/src/glsl/opt_swizzle_swizzle.cpp @@ -30,7 +30,7 @@ #include "ir.h" #include "ir_visitor.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_tree_grafting.cpp b/src/glsl/opt_tree_grafting.cpp index cd58213c019..83effb7424c 100644 --- a/src/glsl/opt_tree_grafting.cpp +++ b/src/glsl/opt_tree_grafting.cpp @@ -52,7 +52,7 @@ #include "ir_variable_refcount.h" #include "ir_basic_block.h" #include "ir_optimization.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" namespace { diff --git a/src/glsl/opt_vectorize.cpp b/src/glsl/opt_vectorize.cpp index 2f71a83583b..88318cd8a6e 100644 --- a/src/glsl/opt_vectorize.cpp +++ b/src/glsl/opt_vectorize.cpp @@ -55,7 +55,7 @@ #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 { diff --git a/src/mesa/SConscript b/src/mesa/SConscript index c986326d2bf..5b80a216fef 100644 --- a/src/mesa/SConscript +++ b/src/mesa/SConscript @@ -16,7 +16,6 @@ env.Append(CPPPATH = [ '#/src', '#/src/mapi', '#/src/glsl', - '#/src/glsl/nir', '#/src/mesa', '#/src/gallium/include', '#/src/gallium/auxiliary', diff --git a/src/mesa/drivers/dri/i965/brw_cubemap_normalize.cpp b/src/mesa/drivers/dri/i965/brw_cubemap_normalize.cpp index 33d2048e657..3d6aa74d830 100644 --- a/src/mesa/drivers/dri/i965/brw_cubemap_normalize.cpp +++ b/src/mesa/drivers/dri/i965/brw_cubemap_normalize.cpp @@ -30,7 +30,7 @@ * \author Eric Anholt */ -#include "glsl/nir/glsl_types.h" +#include "compiler/glsl_types.h" #include "glsl/ir.h" #include "program/prog_instruction.h" /* For WRITEMASK_* */ diff --git a/src/mesa/drivers/dri/i965/brw_fs.cpp b/src/mesa/drivers/dri/i965/brw_fs.cpp index cbeab6f616c..41a3f81b9d8 100644 --- a/src/mesa/drivers/dri/i965/brw_fs.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs.cpp @@ -38,7 +38,7 @@ #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; diff --git a/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp b/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp index 21f0b703d00..22877797522 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_channel_expressions.cpp @@ -43,7 +43,7 @@ #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: diff --git a/src/mesa/drivers/dri/i965/brw_fs_vector_splitting.cpp b/src/mesa/drivers/dri/i965/brw_fs_vector_splitting.cpp index 0c8ad76aa50..0970959bbd6 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_vector_splitting.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_vector_splitting.cpp @@ -40,7 +40,7 @@ #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; diff --git a/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp b/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp index 25240ad65fa..aad512f4be6 100644 --- a/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp +++ b/src/mesa/drivers/dri/i965/brw_fs_visitor.cpp @@ -28,7 +28,7 @@ * 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; diff --git a/src/mesa/drivers/dri/i965/brw_lower_unnormalized_offset.cpp b/src/mesa/drivers/dri/i965/brw_lower_unnormalized_offset.cpp index 4219d471def..eafbdf68ea0 100644 --- a/src/mesa/drivers/dri/i965/brw_lower_unnormalized_offset.cpp +++ b/src/mesa/drivers/dri/i965/brw_lower_unnormalized_offset.cpp @@ -31,7 +31,7 @@ * \author Chris Forbes */ -#include "glsl/nir/glsl_types.h" +#include "compiler/glsl_types.h" #include "glsl/ir.h" #include "glsl/ir_builder.h" diff --git a/src/mesa/main/ff_fragment_shader.cpp b/src/mesa/main/ff_fragment_shader.cpp index e63d0f1ec55..b2b1ee9ba44 100644 --- a/src/mesa/main/ff_fragment_shader.cpp +++ b/src/mesa/main/ff_fragment_shader.cpp @@ -40,7 +40,7 @@ #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" diff --git a/src/mesa/main/uniforms.c b/src/mesa/main/uniforms.c index 47f80ce2001..47010badbc6 100644 --- a/src/mesa/main/uniforms.c +++ b/src/mesa/main/uniforms.c @@ -44,7 +44,7 @@ #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" /** diff --git a/src/mesa/main/uniforms.h b/src/mesa/main/uniforms.h index 2f88b65043d..baf49a752b1 100644 --- a/src/mesa/main/uniforms.h +++ b/src/mesa/main/uniforms.h @@ -27,7 +27,7 @@ #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" diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp index 9cde28dfc0a..70c477ec4fd 100644 --- a/src/mesa/program/ir_to_mesa.cpp +++ b/src/mesa/program/ir_to_mesa.cpp @@ -42,7 +42,7 @@ #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" diff --git a/src/mesa/program/sampler.cpp b/src/mesa/program/sampler.cpp index 84e2504baba..9137d1858e9 100644 --- a/src/mesa/program/sampler.cpp +++ b/src/mesa/program/sampler.cpp @@ -24,7 +24,7 @@ */ #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"