diff options
Diffstat (limited to 'src/glsl')
57 files changed, 54 insertions, 2708 deletions
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 <string.h> #include "main/core.h" /* for MAX2 */ #include "ir.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" ir_rvalue::ir_rvalue(enum ir_node_type t) : ir_instruction(t) 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 <stdlib.h> #include "util/ralloc.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "list.h" #include "ir_visitor.h" #include "ir_hierarchical_visitor.h" 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 <string.h> #include "main/compiler.h" #include "ir.h" -#include "glsl_types.h" +#include "compiler/glsl_types.h" #include "program/hash_table.h" ir_rvalue * 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 <limits.h> #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 <string.h> #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 <[email protected]> */ -#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 <stdio.h> -#include "main/macros.h" -#include "glsl_parser_extras.h" -#include "glsl_types.h" -#include "util/hash_table.h" - - -mtx_t glsl_type::mutex = _MTX_INITIALIZER_NP; -hash_table *glsl_type::array_types = NULL; -hash_table *glsl_type::record_types = NULL; -hash_table *glsl_type::interface_types = NULL; -hash_table *glsl_type::subroutine_types = NULL; -void *glsl_type::mem_ctx = NULL; - -void -glsl_type::init_ralloc_type_ctx(void) -{ - if (glsl_type::mem_ctx == NULL) { - glsl_type::mem_ctx = ralloc_autofree_context(); - assert(glsl_type::mem_ctx != NULL); - } -} - -glsl_type::glsl_type(GLenum gl_type, - glsl_base_type base_type, unsigned vector_elements, - unsigned matrix_columns, const char *name) : - gl_type(gl_type), - base_type(base_type), - sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), - sampler_type(0), interface_packing(0), - vector_elements(vector_elements), matrix_columns(matrix_columns), - length(0) -{ - mtx_lock(&glsl_type::mutex); - - init_ralloc_type_ctx(); - assert(name != NULL); - this->name = ralloc_strdup(this->mem_ctx, name); - - mtx_unlock(&glsl_type::mutex); - - /* Neither dimension is zero or both dimensions are zero. - */ - assert((vector_elements == 0) == (matrix_columns == 0)); - memset(& fields, 0, sizeof(fields)); -} - -glsl_type::glsl_type(GLenum gl_type, glsl_base_type base_type, - enum glsl_sampler_dim dim, bool shadow, bool array, - unsigned type, const char *name) : - gl_type(gl_type), - base_type(base_type), - sampler_dimensionality(dim), sampler_shadow(shadow), - sampler_array(array), sampler_type(type), interface_packing(0), - length(0) -{ - mtx_lock(&glsl_type::mutex); - - init_ralloc_type_ctx(); - assert(name != NULL); - this->name = ralloc_strdup(this->mem_ctx, name); - - mtx_unlock(&glsl_type::mutex); - - memset(& fields, 0, sizeof(fields)); - - if (base_type == GLSL_TYPE_SAMPLER) { - /* Samplers take no storage whatsoever. */ - matrix_columns = vector_elements = 0; - } else { - matrix_columns = vector_elements = 1; - } -} - -glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields, - const char *name) : - gl_type(0), - base_type(GLSL_TYPE_STRUCT), - sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), - sampler_type(0), interface_packing(0), - vector_elements(0), matrix_columns(0), - length(num_fields) -{ - unsigned int i; - - mtx_lock(&glsl_type::mutex); - - init_ralloc_type_ctx(); - assert(name != NULL); - this->name = ralloc_strdup(this->mem_ctx, name); - this->fields.structure = ralloc_array(this->mem_ctx, - glsl_struct_field, length); - - for (i = 0; i < length; i++) { - this->fields.structure[i].type = fields[i].type; - this->fields.structure[i].name = ralloc_strdup(this->fields.structure, - fields[i].name); - this->fields.structure[i].location = fields[i].location; - this->fields.structure[i].interpolation = fields[i].interpolation; - this->fields.structure[i].centroid = fields[i].centroid; - this->fields.structure[i].sample = fields[i].sample; - this->fields.structure[i].matrix_layout = fields[i].matrix_layout; - this->fields.structure[i].patch = fields[i].patch; - this->fields.structure[i].image_read_only = fields[i].image_read_only; - this->fields.structure[i].image_write_only = fields[i].image_write_only; - this->fields.structure[i].image_coherent = fields[i].image_coherent; - this->fields.structure[i].image_volatile = fields[i].image_volatile; - this->fields.structure[i].image_restrict = fields[i].image_restrict; - this->fields.structure[i].precision = fields[i].precision; - } - - mtx_unlock(&glsl_type::mutex); -} - -glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields, - enum glsl_interface_packing packing, const char *name) : - gl_type(0), - base_type(GLSL_TYPE_INTERFACE), - sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), - sampler_type(0), interface_packing((unsigned) packing), - vector_elements(0), matrix_columns(0), - length(num_fields) -{ - unsigned int i; - - mtx_lock(&glsl_type::mutex); - - init_ralloc_type_ctx(); - assert(name != NULL); - this->name = ralloc_strdup(this->mem_ctx, name); - this->fields.structure = ralloc_array(this->mem_ctx, - glsl_struct_field, length); - for (i = 0; i < length; i++) { - this->fields.structure[i].type = fields[i].type; - this->fields.structure[i].name = ralloc_strdup(this->fields.structure, - fields[i].name); - this->fields.structure[i].location = fields[i].location; - this->fields.structure[i].interpolation = fields[i].interpolation; - this->fields.structure[i].centroid = fields[i].centroid; - this->fields.structure[i].sample = fields[i].sample; - this->fields.structure[i].matrix_layout = fields[i].matrix_layout; - this->fields.structure[i].patch = fields[i].patch; - this->fields.structure[i].precision = fields[i].precision; - } - - mtx_unlock(&glsl_type::mutex); -} - -glsl_type::glsl_type(const char *subroutine_name) : - gl_type(0), - base_type(GLSL_TYPE_SUBROUTINE), - sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), - sampler_type(0), interface_packing(0), - vector_elements(1), matrix_columns(1), - length(0) -{ - mtx_lock(&glsl_type::mutex); - - init_ralloc_type_ctx(); - assert(subroutine_name != NULL); - this->name = ralloc_strdup(this->mem_ctx, subroutine_name); - mtx_unlock(&glsl_type::mutex); -} - -bool -glsl_type::contains_sampler() const -{ - if (this->is_array()) { - return this->fields.array->contains_sampler(); - } else if (this->is_record()) { - for (unsigned int i = 0; i < this->length; i++) { - if (this->fields.structure[i].type->contains_sampler()) - return true; - } - return false; - } else { - return this->is_sampler(); - } -} - - -bool -glsl_type::contains_integer() const -{ - if (this->is_array()) { - return this->fields.array->contains_integer(); - } else if (this->is_record()) { - for (unsigned int i = 0; i < this->length; i++) { - if (this->fields.structure[i].type->contains_integer()) - return true; - } - return false; - } else { - return this->is_integer(); - } -} - -bool -glsl_type::contains_double() const -{ - if (this->is_array()) { - return this->fields.array->contains_double(); - } else if (this->is_record()) { - for (unsigned int i = 0; i < this->length; i++) { - if (this->fields.structure[i].type->contains_double()) - return true; - } - return false; - } else { - return this->is_double(); - } -} - -bool -glsl_type::contains_opaque() const { - switch (base_type) { - case GLSL_TYPE_SAMPLER: - case GLSL_TYPE_IMAGE: - case GLSL_TYPE_ATOMIC_UINT: - return true; - case GLSL_TYPE_ARRAY: - return fields.array->contains_opaque(); - case GLSL_TYPE_STRUCT: - for (unsigned int i = 0; i < length; i++) { - if (fields.structure[i].type->contains_opaque()) - return true; - } - return false; - default: - return false; - } -} - -bool -glsl_type::contains_subroutine() const -{ - if (this->is_array()) { - return this->fields.array->contains_subroutine(); - } else if (this->is_record()) { - for (unsigned int i = 0; i < this->length; i++) { - if (this->fields.structure[i].type->contains_subroutine()) - return true; - } - return false; - } else { - return this->is_subroutine(); - } -} - -gl_texture_index -glsl_type::sampler_index() const -{ - const glsl_type *const t = (this->is_array()) ? this->fields.array : this; - - assert(t->is_sampler()); - - switch (t->sampler_dimensionality) { - case GLSL_SAMPLER_DIM_1D: - return (t->sampler_array) ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX; - case GLSL_SAMPLER_DIM_2D: - return (t->sampler_array) ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX; - case GLSL_SAMPLER_DIM_3D: - return TEXTURE_3D_INDEX; - case GLSL_SAMPLER_DIM_CUBE: - return (t->sampler_array) ? TEXTURE_CUBE_ARRAY_INDEX : TEXTURE_CUBE_INDEX; - case GLSL_SAMPLER_DIM_RECT: - return TEXTURE_RECT_INDEX; - case GLSL_SAMPLER_DIM_BUF: - return TEXTURE_BUFFER_INDEX; - case GLSL_SAMPLER_DIM_EXTERNAL: - return TEXTURE_EXTERNAL_INDEX; - case GLSL_SAMPLER_DIM_MS: - return (t->sampler_array) ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : TEXTURE_2D_MULTISAMPLE_INDEX; - default: - assert(!"Should not get here."); - return TEXTURE_BUFFER_INDEX; - } -} - -bool -glsl_type::contains_image() const -{ - if (this->is_array()) { - return this->fields.array->contains_image(); - } else if (this->is_record()) { - for (unsigned int i = 0; i < this->length; i++) { - if (this->fields.structure[i].type->contains_image()) - return true; - } - return false; - } else { - return this->is_image(); - } -} - -const glsl_type *glsl_type::get_base_type() const -{ - switch (base_type) { - case GLSL_TYPE_UINT: - return uint_type; - case GLSL_TYPE_INT: - return int_type; - case GLSL_TYPE_FLOAT: - return float_type; - case GLSL_TYPE_DOUBLE: - return double_type; - case GLSL_TYPE_BOOL: - return bool_type; - default: - return error_type; - } -} - - -const glsl_type *glsl_type::get_scalar_type() const -{ - const glsl_type *type = this; - - /* Handle arrays */ - while (type->base_type == GLSL_TYPE_ARRAY) - type = type->fields.array; - - /* Handle vectors and matrices */ - switch (type->base_type) { - case GLSL_TYPE_UINT: - return uint_type; - case GLSL_TYPE_INT: - return int_type; - case GLSL_TYPE_FLOAT: - return float_type; - case GLSL_TYPE_DOUBLE: - return double_type; - case GLSL_TYPE_BOOL: - return bool_type; - default: - /* Handle everything else */ - return type; - } -} - - -void -_mesa_glsl_release_types(void) -{ - /* Should only be called during atexit (either when unloading shared - * object, or if process terminates), so no mutex-locking should be - * necessary. - */ - if (glsl_type::array_types != NULL) { - _mesa_hash_table_destroy(glsl_type::array_types, NULL); - glsl_type::array_types = NULL; - } - - if (glsl_type::record_types != NULL) { - _mesa_hash_table_destroy(glsl_type::record_types, NULL); - glsl_type::record_types = NULL; - } - - if (glsl_type::interface_types != NULL) { - _mesa_hash_table_destroy(glsl_type::interface_types, NULL); - glsl_type::interface_types = NULL; - } -} - - -glsl_type::glsl_type(const glsl_type *array, unsigned length) : - base_type(GLSL_TYPE_ARRAY), - sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), - sampler_type(0), interface_packing(0), - vector_elements(0), matrix_columns(0), - length(length), name(NULL) -{ - this->fields.array = array; - /* Inherit the gl type of the base. The GL type is used for - * uniform/statevar handling in Mesa and the arrayness of the type - * is represented by the size rather than the type. - */ - this->gl_type = array->gl_type; - - /* Allow a maximum of 10 characters for the array size. This is enough - * for 32-bits of ~0. The extra 3 are for the '[', ']', and terminating - * NUL. - */ - const unsigned name_length = strlen(array->name) + 10 + 3; - - mtx_lock(&glsl_type::mutex); - char *const n = (char *) ralloc_size(this->mem_ctx, name_length); - mtx_unlock(&glsl_type::mutex); - - if (length == 0) - snprintf(n, name_length, "%s[]", array->name); - else { - /* insert outermost dimensions in the correct spot - * otherwise the dimension order will be backwards - */ - const char *pos = strchr(array->name, '['); - if (pos) { - int idx = pos - array->name; - snprintf(n, idx+1, "%s", array->name); - snprintf(n + idx, name_length - idx, "[%u]%s", - length, array->name + idx); - } else { - snprintf(n, name_length, "%s[%u]", array->name, length); - } - } - - this->name = n; -} - - -const glsl_type * -glsl_type::vec(unsigned components) -{ - if (components == 0 || components > 4) - return error_type; - - static const glsl_type *const ts[] = { - float_type, vec2_type, vec3_type, vec4_type - }; - return ts[components - 1]; -} - -const glsl_type * -glsl_type::dvec(unsigned components) -{ - if (components == 0 || components > 4) - return error_type; - - static const glsl_type *const ts[] = { - double_type, dvec2_type, dvec3_type, dvec4_type - }; - return ts[components - 1]; -} - -const glsl_type * -glsl_type::ivec(unsigned components) -{ - if (components == 0 || components > 4) - return error_type; - - static const glsl_type *const ts[] = { - int_type, ivec2_type, ivec3_type, ivec4_type - }; - return ts[components - 1]; -} - - -const glsl_type * -glsl_type::uvec(unsigned components) -{ - if (components == 0 || components > 4) - return error_type; - - static const glsl_type *const ts[] = { - uint_type, uvec2_type, uvec3_type, uvec4_type - }; - return ts[components - 1]; -} - - -const glsl_type * -glsl_type::bvec(unsigned components) -{ - if (components == 0 || components > 4) - return error_type; - - static const glsl_type *const ts[] = { - bool_type, bvec2_type, bvec3_type, bvec4_type - }; - return ts[components - 1]; -} - - -const glsl_type * -glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns) -{ - if (base_type == GLSL_TYPE_VOID) - return void_type; - - if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4)) - return error_type; - - /* Treat GLSL vectors as Nx1 matrices. - */ - if (columns == 1) { - switch (base_type) { - case GLSL_TYPE_UINT: - return uvec(rows); - case GLSL_TYPE_INT: - return ivec(rows); - case GLSL_TYPE_FLOAT: - return vec(rows); - case GLSL_TYPE_DOUBLE: - return dvec(rows); - case GLSL_TYPE_BOOL: - return bvec(rows); - default: - return error_type; - } - } else { - if ((base_type != GLSL_TYPE_FLOAT && base_type != GLSL_TYPE_DOUBLE) || (rows == 1)) - return error_type; - - /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following - * combinations are valid: - * - * 1 2 3 4 - * 1 - * 2 x x x - * 3 x x x - * 4 x x x - */ -#define IDX(c,r) (((c-1)*3) + (r-1)) - - if (base_type == GLSL_TYPE_DOUBLE) { - switch (IDX(columns, rows)) { - case IDX(2,2): return dmat2_type; - case IDX(2,3): return dmat2x3_type; - case IDX(2,4): return dmat2x4_type; - case IDX(3,2): return dmat3x2_type; - case IDX(3,3): return dmat3_type; - case IDX(3,4): return dmat3x4_type; - case IDX(4,2): return dmat4x2_type; - case IDX(4,3): return dmat4x3_type; - case IDX(4,4): return dmat4_type; - default: return error_type; - } - } else { - switch (IDX(columns, rows)) { - case IDX(2,2): return mat2_type; - case IDX(2,3): return mat2x3_type; - case IDX(2,4): return mat2x4_type; - case IDX(3,2): return mat3x2_type; - case IDX(3,3): return mat3_type; - case IDX(3,4): return mat3x4_type; - case IDX(4,2): return mat4x2_type; - case IDX(4,3): return mat4x3_type; - case IDX(4,4): return mat4_type; - default: return error_type; - } - } - } - - assert(!"Should not get here."); - return error_type; -} - -const glsl_type * -glsl_type::get_sampler_instance(enum glsl_sampler_dim dim, - bool shadow, - bool array, - glsl_base_type type) -{ - switch (type) { - case GLSL_TYPE_FLOAT: - switch (dim) { - case GLSL_SAMPLER_DIM_1D: - if (shadow) - return (array ? sampler1DArrayShadow_type : sampler1DShadow_type); - else - return (array ? sampler1DArray_type : sampler1D_type); - case GLSL_SAMPLER_DIM_2D: - if (shadow) - return (array ? sampler2DArrayShadow_type : sampler2DShadow_type); - else - return (array ? sampler2DArray_type : sampler2D_type); - case GLSL_SAMPLER_DIM_3D: - if (shadow || array) - return error_type; - else - return sampler3D_type; - case GLSL_SAMPLER_DIM_CUBE: - if (shadow) - return (array ? samplerCubeArrayShadow_type : samplerCubeShadow_type); - else - return (array ? samplerCubeArray_type : samplerCube_type); - case GLSL_SAMPLER_DIM_RECT: - if (array) - return error_type; - if (shadow) - return sampler2DRectShadow_type; - else - return sampler2DRect_type; - case GLSL_SAMPLER_DIM_BUF: - if (shadow || array) - return error_type; - else - return samplerBuffer_type; - case GLSL_SAMPLER_DIM_MS: - if (shadow) - return error_type; - return (array ? sampler2DMSArray_type : sampler2DMS_type); - case GLSL_SAMPLER_DIM_EXTERNAL: - if (shadow || array) - return error_type; - else - return samplerExternalOES_type; - } - case GLSL_TYPE_INT: - if (shadow) - return error_type; - switch (dim) { - case GLSL_SAMPLER_DIM_1D: - return (array ? isampler1DArray_type : isampler1D_type); - case GLSL_SAMPLER_DIM_2D: - return (array ? isampler2DArray_type : isampler2D_type); - case GLSL_SAMPLER_DIM_3D: - if (array) - return error_type; - return isampler3D_type; - case GLSL_SAMPLER_DIM_CUBE: - return (array ? isamplerCubeArray_type : isamplerCube_type); - case GLSL_SAMPLER_DIM_RECT: - if (array) - return error_type; - return isampler2DRect_type; - case GLSL_SAMPLER_DIM_BUF: - if (array) - return error_type; - return isamplerBuffer_type; - case GLSL_SAMPLER_DIM_MS: - return (array ? isampler2DMSArray_type : isampler2DMS_type); - case GLSL_SAMPLER_DIM_EXTERNAL: - return error_type; - } - case GLSL_TYPE_UINT: - if (shadow) - return error_type; - switch (dim) { - case GLSL_SAMPLER_DIM_1D: - return (array ? usampler1DArray_type : usampler1D_type); - case GLSL_SAMPLER_DIM_2D: - return (array ? usampler2DArray_type : usampler2D_type); - case GLSL_SAMPLER_DIM_3D: - if (array) - return error_type; - return usampler3D_type; - case GLSL_SAMPLER_DIM_CUBE: - return (array ? usamplerCubeArray_type : usamplerCube_type); - case GLSL_SAMPLER_DIM_RECT: - if (array) - return error_type; - return usampler2DRect_type; - case GLSL_SAMPLER_DIM_BUF: - if (array) - return error_type; - return usamplerBuffer_type; - case GLSL_SAMPLER_DIM_MS: - return (array ? usampler2DMSArray_type : usampler2DMS_type); - case GLSL_SAMPLER_DIM_EXTERNAL: - return error_type; - } - default: - return error_type; - } - - unreachable("switch statement above should be complete"); -} - -const glsl_type * -glsl_type::get_array_instance(const glsl_type *base, unsigned array_size) -{ - /* Generate a name using the base type pointer in the key. This is - * done because the name of the base type may not be unique across - * shaders. For example, two shaders may have different record types - * named 'foo'. - */ - char key[128]; - snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size); - - mtx_lock(&glsl_type::mutex); - - if (array_types == NULL) { - array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string, - _mesa_key_string_equal); - } - - const struct hash_entry *entry = _mesa_hash_table_search(array_types, key); - if (entry == NULL) { - mtx_unlock(&glsl_type::mutex); - const glsl_type *t = new glsl_type(base, array_size); - mtx_lock(&glsl_type::mutex); - - entry = _mesa_hash_table_insert(array_types, - ralloc_strdup(mem_ctx, key), - (void *) t); - } - - assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_ARRAY); - assert(((glsl_type *) entry->data)->length == array_size); - assert(((glsl_type *) entry->data)->fields.array == base); - - mtx_unlock(&glsl_type::mutex); - - return (glsl_type *) entry->data; -} - - -bool -glsl_type::record_compare(const glsl_type *b) const -{ - if (this->length != b->length) - return false; - - if (this->interface_packing != b->interface_packing) - return false; - - /* From the GLSL 4.20 specification (Sec 4.2): - * - * "Structures must have the same name, sequence of type names, and - * type definitions, and field names to be considered the same type." - * - * GLSL ES behaves the same (Ver 1.00 Sec 4.2.4, Ver 3.00 Sec 4.2.5). - * - * Note that we cannot force type name check when comparing unnamed - * structure types, these have a unique name assigned during parsing. - */ - if (!this->is_anonymous() && !b->is_anonymous()) - if (strcmp(this->name, b->name) != 0) - return false; - - for (unsigned i = 0; i < this->length; i++) { - if (this->fields.structure[i].type != b->fields.structure[i].type) - return false; - if (strcmp(this->fields.structure[i].name, - b->fields.structure[i].name) != 0) - return false; - if (this->fields.structure[i].matrix_layout - != b->fields.structure[i].matrix_layout) - return false; - if (this->fields.structure[i].location - != b->fields.structure[i].location) - return false; - if (this->fields.structure[i].interpolation - != b->fields.structure[i].interpolation) - return false; - if (this->fields.structure[i].centroid - != b->fields.structure[i].centroid) - return false; - if (this->fields.structure[i].sample - != b->fields.structure[i].sample) - return false; - if (this->fields.structure[i].patch - != b->fields.structure[i].patch) - return false; - if (this->fields.structure[i].image_read_only - != b->fields.structure[i].image_read_only) - return false; - if (this->fields.structure[i].image_write_only - != b->fields.structure[i].image_write_only) - return false; - if (this->fields.structure[i].image_coherent - != b->fields.structure[i].image_coherent) - return false; - if (this->fields.structure[i].image_volatile - != b->fields.structure[i].image_volatile) - return false; - if (this->fields.structure[i].image_restrict - != b->fields.structure[i].image_restrict) - return false; - if (this->fields.structure[i].precision - != b->fields.structure[i].precision) - return false; - } - - return true; -} - - -bool -glsl_type::record_key_compare(const void *a, const void *b) -{ - const glsl_type *const key1 = (glsl_type *) a; - const glsl_type *const key2 = (glsl_type *) b; - - return strcmp(key1->name, key2->name) == 0 && key1->record_compare(key2); -} - - -/** - * Generate an integer hash value for a glsl_type structure type. - */ -unsigned -glsl_type::record_key_hash(const void *a) -{ - const glsl_type *const key = (glsl_type *) a; - uintptr_t hash = key->length; - unsigned retval; - - for (unsigned i = 0; i < key->length; i++) { - /* casting pointer to uintptr_t */ - hash = (hash * 13 ) + (uintptr_t) key->fields.structure[i].type; - } - - if (sizeof(hash) == 8) - retval = (hash & 0xffffffff) ^ ((uint64_t) hash >> 32); - else - retval = hash; - - return retval; -} - - -const glsl_type * -glsl_type::get_record_instance(const glsl_struct_field *fields, - unsigned num_fields, - const char *name) -{ - const glsl_type key(fields, num_fields, name); - - mtx_lock(&glsl_type::mutex); - - if (record_types == NULL) { - record_types = _mesa_hash_table_create(NULL, record_key_hash, - record_key_compare); - } - - const struct hash_entry *entry = _mesa_hash_table_search(record_types, - &key); - if (entry == NULL) { - mtx_unlock(&glsl_type::mutex); - const glsl_type *t = new glsl_type(fields, num_fields, name); - mtx_lock(&glsl_type::mutex); - - entry = _mesa_hash_table_insert(record_types, t, (void *) t); - } - - assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_STRUCT); - assert(((glsl_type *) entry->data)->length == num_fields); - assert(strcmp(((glsl_type *) entry->data)->name, name) == 0); - - mtx_unlock(&glsl_type::mutex); - - return (glsl_type *) entry->data; -} - - -const glsl_type * -glsl_type::get_interface_instance(const glsl_struct_field *fields, - unsigned num_fields, - enum glsl_interface_packing packing, - const char *block_name) -{ - const glsl_type key(fields, num_fields, packing, block_name); - - mtx_lock(&glsl_type::mutex); - - if (interface_types == NULL) { - interface_types = _mesa_hash_table_create(NULL, record_key_hash, - record_key_compare); - } - - const struct hash_entry *entry = _mesa_hash_table_search(interface_types, - &key); - if (entry == NULL) { - mtx_unlock(&glsl_type::mutex); - const glsl_type *t = new glsl_type(fields, num_fields, - packing, block_name); - mtx_lock(&glsl_type::mutex); - - entry = _mesa_hash_table_insert(interface_types, t, (void *) t); - } - - assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_INTERFACE); - assert(((glsl_type *) entry->data)->length == num_fields); - assert(strcmp(((glsl_type *) entry->data)->name, block_name) == 0); - - mtx_unlock(&glsl_type::mutex); - - return (glsl_type *) entry->data; -} - -const glsl_type * -glsl_type::get_subroutine_instance(const char *subroutine_name) -{ - const glsl_type key(subroutine_name); - - mtx_lock(&glsl_type::mutex); - - if (subroutine_types == NULL) { - subroutine_types = _mesa_hash_table_create(NULL, record_key_hash, - record_key_compare); - } - - const struct hash_entry *entry = _mesa_hash_table_search(subroutine_types, - &key); - if (entry == NULL) { - mtx_unlock(&glsl_type::mutex); - const glsl_type *t = new glsl_type(subroutine_name); - mtx_lock(&glsl_type::mutex); - - entry = _mesa_hash_table_insert(subroutine_types, t, (void *) t); - } - - assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_SUBROUTINE); - assert(strcmp(((glsl_type *) entry->data)->name, subroutine_name) == 0); - - mtx_unlock(&glsl_type::mutex); - - return (glsl_type *) entry->data; -} - - -const glsl_type * -glsl_type::get_mul_type(const glsl_type *type_a, const glsl_type *type_b) -{ - if (type_a == type_b) { - return type_a; - } else if (type_a->is_matrix() && type_b->is_matrix()) { - /* Matrix multiply. The columns of A must match the rows of B. Given - * the other previously tested constraints, this means the vector type - * of a row from A must be the same as the vector type of a column from - * B. - */ - if (type_a->row_type() == type_b->column_type()) { - /* The resulting matrix has the number of columns of matrix B and - * the number of rows of matrix A. We get the row count of A by - * looking at the size of a vector that makes up a column. The - * transpose (size of a row) is done for B. - */ - const glsl_type *const type = - get_instance(type_a->base_type, - type_a->column_type()->vector_elements, - type_b->row_type()->vector_elements); - assert(type != error_type); - - return type; - } - } else if (type_a->is_matrix()) { - /* A is a matrix and B is a column vector. Columns of A must match - * rows of B. Given the other previously tested constraints, this - * means the vector type of a row from A must be the same as the - * vector the type of B. - */ - if (type_a->row_type() == type_b) { - /* The resulting vector has a number of elements equal to - * the number of rows of matrix A. */ - const glsl_type *const type = - get_instance(type_a->base_type, - type_a->column_type()->vector_elements, - 1); - assert(type != error_type); - - return type; - } - } else { - assert(type_b->is_matrix()); - - /* A is a row vector and B is a matrix. Columns of A must match rows - * of B. Given the other previously tested constraints, this means - * the type of A must be the same as the vector type of a column from - * B. - */ - if (type_a == type_b->column_type()) { - /* The resulting vector has a number of elements equal to - * the number of columns of matrix B. */ - const glsl_type *const type = - get_instance(type_a->base_type, - type_b->row_type()->vector_elements, - 1); - assert(type != error_type); - - return type; - } - } - - return error_type; -} - - -const glsl_type * -glsl_type::field_type(const char *name) const -{ - if (this->base_type != GLSL_TYPE_STRUCT - && this->base_type != GLSL_TYPE_INTERFACE) - return error_type; - - for (unsigned i = 0; i < this->length; i++) { - if (strcmp(name, this->fields.structure[i].name) == 0) - return this->fields.structure[i].type; - } - - return error_type; -} - - -int -glsl_type::field_index(const char *name) const -{ - if (this->base_type != GLSL_TYPE_STRUCT - && this->base_type != GLSL_TYPE_INTERFACE) - return -1; - - for (unsigned i = 0; i < this->length; i++) { - if (strcmp(name, this->fields.structure[i].name) == 0) - return i; - } - - return -1; -} - - -unsigned -glsl_type::component_slots() const -{ - switch (this->base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - case GLSL_TYPE_FLOAT: - case GLSL_TYPE_BOOL: - return this->components(); - - case GLSL_TYPE_DOUBLE: - return 2 * this->components(); - - case GLSL_TYPE_STRUCT: - case GLSL_TYPE_INTERFACE: { - unsigned size = 0; - - for (unsigned i = 0; i < this->length; i++) - size += this->fields.structure[i].type->component_slots(); - - return size; - } - - case GLSL_TYPE_ARRAY: - return this->length * this->fields.array->component_slots(); - - case GLSL_TYPE_IMAGE: - return 1; - case GLSL_TYPE_SUBROUTINE: - return 1; - case GLSL_TYPE_SAMPLER: - case GLSL_TYPE_ATOMIC_UINT: - case GLSL_TYPE_VOID: - case GLSL_TYPE_ERROR: - break; - } - - return 0; -} - -unsigned -glsl_type::record_location_offset(unsigned length) const -{ - unsigned offset = 0; - const glsl_type *t = this->without_array(); - if (t->is_record()) { - assert(length <= t->length); - - for (unsigned i = 0; i < length; i++) { - const glsl_type *st = t->fields.structure[i].type; - const glsl_type *wa = st->without_array(); - if (wa->is_record()) { - unsigned r_offset = wa->record_location_offset(wa->length); - offset += st->is_array() ? - st->arrays_of_arrays_size() * r_offset : r_offset; - } else if (st->is_array() && st->fields.array->is_array()) { - unsigned outer_array_size = st->length; - const glsl_type *base_type = st->fields.array; - - /* For arrays of arrays the outer arrays take up a uniform - * slot for each element. The innermost array elements share a - * single slot so we ignore the innermost array when calculating - * the offset. - */ - while (base_type->fields.array->is_array()) { - outer_array_size = outer_array_size * base_type->length; - base_type = base_type->fields.array; - } - offset += outer_array_size; - } else { - /* We dont worry about arrays here because unless the array - * contains a structure or another array it only takes up a single - * uniform slot. - */ - offset += 1; - } - } - } - return offset; -} - -unsigned -glsl_type::uniform_locations() const -{ - unsigned size = 0; - - switch (this->base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - case GLSL_TYPE_FLOAT: - case GLSL_TYPE_DOUBLE: - case GLSL_TYPE_BOOL: - case GLSL_TYPE_SAMPLER: - case GLSL_TYPE_IMAGE: - case GLSL_TYPE_SUBROUTINE: - return 1; - - case GLSL_TYPE_STRUCT: - case GLSL_TYPE_INTERFACE: - for (unsigned i = 0; i < this->length; i++) - size += this->fields.structure[i].type->uniform_locations(); - return size; - case GLSL_TYPE_ARRAY: - return this->length * this->fields.array->uniform_locations(); - default: - return 0; - } -} - -bool -glsl_type::can_implicitly_convert_to(const glsl_type *desired, - _mesa_glsl_parse_state *state) const -{ - if (this == desired) - return true; - - /* There is no conversion among matrix types. */ - if (this->matrix_columns > 1 || desired->matrix_columns > 1) - return false; - - /* Vector size must match. */ - if (this->vector_elements != desired->vector_elements) - return false; - - /* int and uint can be converted to float. */ - if (desired->is_float() && this->is_integer()) - return true; - - /* With GLSL 4.0 / ARB_gpu_shader5, int can be converted to uint. - * Note that state may be NULL here, when resolving function calls in the - * linker. By this time, all the state-dependent checks have already - * happened though, so allow anything that's allowed in any shader version. */ - if ((!state || state->is_version(400, 0) || state->ARB_gpu_shader5_enable) && - desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT) - return true; - - /* No implicit conversions from double. */ - if ((!state || state->has_double()) && this->is_double()) - return false; - - /* Conversions from different types to double. */ - if ((!state || state->has_double()) && desired->is_double()) { - if (this->is_float()) - return true; - if (this->is_integer()) - return true; - } - - return false; -} - -unsigned -glsl_type::std140_base_alignment(bool row_major) const -{ - unsigned N = is_double() ? 8 : 4; - - /* (1) If the member is a scalar consuming <N> basic machine units, the - * base alignment is <N>. - * - * (2) If the member is a two- or four-component vector with components - * consuming <N> basic machine units, the base alignment is 2<N> or - * 4<N>, respectively. - * - * (3) If the member is a three-component vector with components consuming - * <N> basic machine units, the base alignment is 4<N>. - */ - if (this->is_scalar() || this->is_vector()) { - switch (this->vector_elements) { - case 1: - return N; - case 2: - return 2 * N; - case 3: - case 4: - return 4 * N; - } - } - - /* (4) If the member is an array of scalars or vectors, the base alignment - * and array stride are set to match the base alignment of a single - * array element, according to rules (1), (2), and (3), and rounded up - * to the base alignment of a vec4. The array may have padding at the - * end; the base offset of the member following the array is rounded up - * to the next multiple of the base alignment. - * - * (6) If the member is an array of <S> column-major matrices with <C> - * columns and <R> rows, the matrix is stored identically to a row of - * <S>*<C> column vectors with <R> components each, according to rule - * (4). - * - * (8) If the member is an array of <S> row-major matrices with <C> columns - * and <R> rows, the matrix is stored identically to a row of <S>*<R> - * row vectors with <C> components each, according to rule (4). - * - * (10) If the member is an array of <S> structures, the <S> elements of - * the array are laid out in order, according to rule (9). - */ - if (this->is_array()) { - if (this->fields.array->is_scalar() || - this->fields.array->is_vector() || - this->fields.array->is_matrix()) { - return MAX2(this->fields.array->std140_base_alignment(row_major), 16); - } else { - assert(this->fields.array->is_record() || - this->fields.array->is_array()); - return this->fields.array->std140_base_alignment(row_major); - } - } - - /* (5) If the member is a column-major matrix with <C> columns and - * <R> rows, the matrix is stored identically to an array of - * <C> column vectors with <R> components each, according to - * rule (4). - * - * (7) If the member is a row-major matrix with <C> columns and <R> - * rows, the matrix is stored identically to an array of <R> - * row vectors with <C> components each, according to rule (4). - */ - if (this->is_matrix()) { - const struct glsl_type *vec_type, *array_type; - int c = this->matrix_columns; - int r = this->vector_elements; - - if (row_major) { - vec_type = get_instance(base_type, c, 1); - array_type = glsl_type::get_array_instance(vec_type, r); - } else { - vec_type = get_instance(base_type, r, 1); - array_type = glsl_type::get_array_instance(vec_type, c); - } - - return array_type->std140_base_alignment(false); - } - - /* (9) If the member is a structure, the base alignment of the - * structure is <N>, where <N> is the largest base alignment - * value of any of its members, and rounded up to the base - * alignment of a vec4. The individual members of this - * sub-structure are then assigned offsets by applying this set - * of rules recursively, where the base offset of the first - * member of the sub-structure is equal to the aligned offset - * of the structure. The structure may have padding at the end; - * the base offset of the member following the sub-structure is - * rounded up to the next multiple of the base alignment of the - * structure. - */ - if (this->is_record()) { - unsigned base_alignment = 16; - for (unsigned i = 0; i < this->length; i++) { - bool field_row_major = row_major; - const enum glsl_matrix_layout matrix_layout = - glsl_matrix_layout(this->fields.structure[i].matrix_layout); - if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { - field_row_major = true; - } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { - field_row_major = false; - } - - const struct glsl_type *field_type = this->fields.structure[i].type; - base_alignment = MAX2(base_alignment, - field_type->std140_base_alignment(field_row_major)); - } - return base_alignment; - } - - assert(!"not reached"); - return -1; -} - -unsigned -glsl_type::std140_size(bool row_major) const -{ - unsigned N = is_double() ? 8 : 4; - - /* (1) If the member is a scalar consuming <N> basic machine units, the - * base alignment is <N>. - * - * (2) If the member is a two- or four-component vector with components - * consuming <N> basic machine units, the base alignment is 2<N> or - * 4<N>, respectively. - * - * (3) If the member is a three-component vector with components consuming - * <N> basic machine units, the base alignment is 4<N>. - */ - if (this->is_scalar() || this->is_vector()) { - return this->vector_elements * N; - } - - /* (5) If the member is a column-major matrix with <C> columns and - * <R> rows, the matrix is stored identically to an array of - * <C> column vectors with <R> components each, according to - * rule (4). - * - * (6) If the member is an array of <S> column-major matrices with <C> - * columns and <R> rows, the matrix is stored identically to a row of - * <S>*<C> column vectors with <R> components each, according to rule - * (4). - * - * (7) If the member is a row-major matrix with <C> columns and <R> - * rows, the matrix is stored identically to an array of <R> - * row vectors with <C> components each, according to rule (4). - * - * (8) If the member is an array of <S> row-major matrices with <C> columns - * and <R> rows, the matrix is stored identically to a row of <S>*<R> - * row vectors with <C> components each, according to rule (4). - */ - if (this->without_array()->is_matrix()) { - const struct glsl_type *element_type; - const struct glsl_type *vec_type; - unsigned int array_len; - - if (this->is_array()) { - element_type = this->without_array(); - array_len = this->arrays_of_arrays_size(); - } else { - element_type = this; - array_len = 1; - } - - if (row_major) { - vec_type = get_instance(element_type->base_type, - element_type->matrix_columns, 1); - - array_len *= element_type->vector_elements; - } else { - vec_type = get_instance(element_type->base_type, - element_type->vector_elements, 1); - array_len *= element_type->matrix_columns; - } - const glsl_type *array_type = glsl_type::get_array_instance(vec_type, - array_len); - - return array_type->std140_size(false); - } - - /* (4) If the member is an array of scalars or vectors, the base alignment - * and array stride are set to match the base alignment of a single - * array element, according to rules (1), (2), and (3), and rounded up - * to the base alignment of a vec4. The array may have padding at the - * end; the base offset of the member following the array is rounded up - * to the next multiple of the base alignment. - * - * (10) If the member is an array of <S> structures, the <S> elements of - * the array are laid out in order, according to rule (9). - */ - if (this->is_array()) { - if (this->without_array()->is_record()) { - return this->arrays_of_arrays_size() * - this->without_array()->std140_size(row_major); - } else { - unsigned element_base_align = - this->without_array()->std140_base_alignment(row_major); - return this->arrays_of_arrays_size() * MAX2(element_base_align, 16); - } - } - - /* (9) If the member is a structure, the base alignment of the - * structure is <N>, where <N> is the largest base alignment - * value of any of its members, and rounded up to the base - * alignment of a vec4. The individual members of this - * sub-structure are then assigned offsets by applying this set - * of rules recursively, where the base offset of the first - * member of the sub-structure is equal to the aligned offset - * of the structure. The structure may have padding at the end; - * the base offset of the member following the sub-structure is - * rounded up to the next multiple of the base alignment of the - * structure. - */ - if (this->is_record() || this->is_interface()) { - unsigned size = 0; - unsigned max_align = 0; - - for (unsigned i = 0; i < this->length; i++) { - bool field_row_major = row_major; - const enum glsl_matrix_layout matrix_layout = - glsl_matrix_layout(this->fields.structure[i].matrix_layout); - if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { - field_row_major = true; - } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { - field_row_major = false; - } - - const struct glsl_type *field_type = this->fields.structure[i].type; - unsigned align = field_type->std140_base_alignment(field_row_major); - - /* Ignore unsized arrays when calculating size */ - if (field_type->is_unsized_array()) - continue; - - size = glsl_align(size, align); - size += field_type->std140_size(field_row_major); - - max_align = MAX2(align, max_align); - - if (field_type->is_record() && (i + 1 < this->length)) - size = glsl_align(size, 16); - } - size = glsl_align(size, MAX2(max_align, 16)); - return size; - } - - assert(!"not reached"); - return -1; -} - -unsigned -glsl_type::std430_base_alignment(bool row_major) const -{ - - unsigned N = is_double() ? 8 : 4; - - /* (1) If the member is a scalar consuming <N> basic machine units, the - * base alignment is <N>. - * - * (2) If the member is a two- or four-component vector with components - * consuming <N> basic machine units, the base alignment is 2<N> or - * 4<N>, respectively. - * - * (3) If the member is a three-component vector with components consuming - * <N> basic machine units, the base alignment is 4<N>. - */ - if (this->is_scalar() || this->is_vector()) { - switch (this->vector_elements) { - case 1: - return N; - case 2: - return 2 * N; - case 3: - case 4: - return 4 * N; - } - } - - /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout": - * - * "When using the std430 storage layout, shader storage blocks will be - * laid out in buffer storage identically to uniform and shader storage - * blocks using the std140 layout, except that the base alignment and - * stride of arrays of scalars and vectors in rule 4 and of structures - * in rule 9 are not rounded up a multiple of the base alignment of a vec4. - */ - - /* (1) If the member is a scalar consuming <N> basic machine units, the - * base alignment is <N>. - * - * (2) If the member is a two- or four-component vector with components - * consuming <N> basic machine units, the base alignment is 2<N> or - * 4<N>, respectively. - * - * (3) If the member is a three-component vector with components consuming - * <N> basic machine units, the base alignment is 4<N>. - */ - if (this->is_array()) - return this->fields.array->std430_base_alignment(row_major); - - /* (5) If the member is a column-major matrix with <C> columns and - * <R> rows, the matrix is stored identically to an array of - * <C> column vectors with <R> components each, according to - * rule (4). - * - * (7) If the member is a row-major matrix with <C> columns and <R> - * rows, the matrix is stored identically to an array of <R> - * row vectors with <C> components each, according to rule (4). - */ - if (this->is_matrix()) { - const struct glsl_type *vec_type, *array_type; - int c = this->matrix_columns; - int r = this->vector_elements; - - if (row_major) { - vec_type = get_instance(base_type, c, 1); - array_type = glsl_type::get_array_instance(vec_type, r); - } else { - vec_type = get_instance(base_type, r, 1); - array_type = glsl_type::get_array_instance(vec_type, c); - } - - return array_type->std430_base_alignment(false); - } - - /* (9) If the member is a structure, the base alignment of the - * structure is <N>, where <N> is the largest base alignment - * value of any of its members, and rounded up to the base - * alignment of a vec4. The individual members of this - * sub-structure are then assigned offsets by applying this set - * of rules recursively, where the base offset of the first - * member of the sub-structure is equal to the aligned offset - * of the structure. The structure may have padding at the end; - * the base offset of the member following the sub-structure is - * rounded up to the next multiple of the base alignment of the - * structure. - */ - if (this->is_record()) { - unsigned base_alignment = 0; - for (unsigned i = 0; i < this->length; i++) { - bool field_row_major = row_major; - const enum glsl_matrix_layout matrix_layout = - glsl_matrix_layout(this->fields.structure[i].matrix_layout); - if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { - field_row_major = true; - } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { - field_row_major = false; - } - - const struct glsl_type *field_type = this->fields.structure[i].type; - base_alignment = MAX2(base_alignment, - field_type->std430_base_alignment(field_row_major)); - } - assert(base_alignment > 0); - return base_alignment; - } - assert(!"not reached"); - return -1; -} - -unsigned -glsl_type::std430_array_stride(bool row_major) const -{ - unsigned N = is_double() ? 8 : 4; - - /* Notice that the array stride of a vec3 is not 3 * N but 4 * N. - * See OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout" - * - * (3) If the member is a three-component vector with components consuming - * <N> basic machine units, the base alignment is 4<N>. - */ - if (this->is_vector() && this->vector_elements == 3) - return 4 * N; - - /* By default use std430_size(row_major) */ - return this->std430_size(row_major); -} - -unsigned -glsl_type::std430_size(bool row_major) const -{ - unsigned N = is_double() ? 8 : 4; - - /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout": - * - * "When using the std430 storage layout, shader storage blocks will be - * laid out in buffer storage identically to uniform and shader storage - * blocks using the std140 layout, except that the base alignment and - * stride of arrays of scalars and vectors in rule 4 and of structures - * in rule 9 are not rounded up a multiple of the base alignment of a vec4. - */ - if (this->is_scalar() || this->is_vector()) - return this->vector_elements * N; - - if (this->without_array()->is_matrix()) { - const struct glsl_type *element_type; - const struct glsl_type *vec_type; - unsigned int array_len; - - if (this->is_array()) { - element_type = this->without_array(); - array_len = this->arrays_of_arrays_size(); - } else { - element_type = this; - array_len = 1; - } - - if (row_major) { - vec_type = get_instance(element_type->base_type, - element_type->matrix_columns, 1); - - array_len *= element_type->vector_elements; - } else { - vec_type = get_instance(element_type->base_type, - element_type->vector_elements, 1); - array_len *= element_type->matrix_columns; - } - const glsl_type *array_type = glsl_type::get_array_instance(vec_type, - array_len); - - return array_type->std430_size(false); - } - - if (this->is_array()) { - if (this->without_array()->is_record()) - return this->arrays_of_arrays_size() * - this->without_array()->std430_size(row_major); - else - return this->arrays_of_arrays_size() * - this->without_array()->std430_base_alignment(row_major); - } - - if (this->is_record() || this->is_interface()) { - unsigned size = 0; - unsigned max_align = 0; - - for (unsigned i = 0; i < this->length; i++) { - bool field_row_major = row_major; - const enum glsl_matrix_layout matrix_layout = - glsl_matrix_layout(this->fields.structure[i].matrix_layout); - if (matrix_layout == GLSL_MATRIX_LAYOUT_ROW_MAJOR) { - field_row_major = true; - } else if (matrix_layout == GLSL_MATRIX_LAYOUT_COLUMN_MAJOR) { - field_row_major = false; - } - - const struct glsl_type *field_type = this->fields.structure[i].type; - unsigned align = field_type->std430_base_alignment(field_row_major); - size = glsl_align(size, align); - size += field_type->std430_size(field_row_major); - - max_align = MAX2(align, max_align); - } - size = glsl_align(size, max_align); - return size; - } - - assert(!"not reached"); - return -1; -} - -unsigned -glsl_type::count_attribute_slots(bool vertex_input_slots) const -{ - /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: - * - * "A scalar input counts the same amount against this limit as a vec4, - * so applications may want to consider packing groups of four - * unrelated float inputs together into a vector to better utilize the - * capabilities of the underlying hardware. A matrix input will use up - * multiple locations. The number of locations used will equal the - * number of columns in the matrix." - * - * The spec does not explicitly say how arrays are counted. However, it - * should be safe to assume the total number of slots consumed by an array - * is the number of entries in the array multiplied by the number of slots - * consumed by a single element of the array. - * - * The spec says nothing about how structs are counted, because vertex - * attributes are not allowed to be (or contain) structs. However, Mesa - * allows varying structs, the number of varying slots taken up by a - * varying struct is simply equal to the sum of the number of slots taken - * up by each element. - * - * Doubles are counted different depending on whether they are vertex - * inputs or everything else. Vertex inputs from ARB_vertex_attrib_64bit - * take one location no matter what size they are, otherwise dvec3/4 - * take two locations. - */ - switch (this->base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - case GLSL_TYPE_FLOAT: - case GLSL_TYPE_BOOL: - return this->matrix_columns; - case GLSL_TYPE_DOUBLE: - if (this->vector_elements > 2 && !vertex_input_slots) - return this->matrix_columns * 2; - else - return this->matrix_columns; - case GLSL_TYPE_STRUCT: - case GLSL_TYPE_INTERFACE: { - unsigned size = 0; - - for (unsigned i = 0; i < this->length; i++) - size += this->fields.structure[i].type->count_attribute_slots(vertex_input_slots); - - return size; - } - - case GLSL_TYPE_ARRAY: - return this->length * this->fields.array->count_attribute_slots(vertex_input_slots); - - case GLSL_TYPE_SAMPLER: - case GLSL_TYPE_IMAGE: - case GLSL_TYPE_ATOMIC_UINT: - case GLSL_TYPE_VOID: - case GLSL_TYPE_SUBROUTINE: - case GLSL_TYPE_ERROR: - break; - } - - assert(!"Unexpected type in count_attribute_slots()"); - - return 0; -} - -int -glsl_type::coordinate_components() const -{ - int size; - - switch (sampler_dimensionality) { - case GLSL_SAMPLER_DIM_1D: - case GLSL_SAMPLER_DIM_BUF: - size = 1; - break; - case GLSL_SAMPLER_DIM_2D: - case GLSL_SAMPLER_DIM_RECT: - case GLSL_SAMPLER_DIM_MS: - case GLSL_SAMPLER_DIM_EXTERNAL: - size = 2; - break; - case GLSL_SAMPLER_DIM_3D: - case GLSL_SAMPLER_DIM_CUBE: - size = 3; - break; - default: - assert(!"Should not get here."); - size = 1; - break; - } - - /* Array textures need an additional component for the array index, except - * for cubemap array images that behave like a 2D array of interleaved - * cubemap faces. - */ - if (sampler_array && - !(base_type == GLSL_TYPE_IMAGE && - sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE)) - size += 1; - - return size; -} - -/** - * Declarations of type flyweights (glsl_type::_foo_type) and - * convenience pointers (glsl_type::foo_type). - * @{ - */ -#define DECL_TYPE(NAME, ...) \ - const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \ - const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type; - -#define STRUCT_TYPE(NAME) - -#include "compiler/builtin_type_macros.h" -/** @} */ 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 <string.h> -#include <assert.h> - -#ifdef __cplusplus -extern "C" { -#endif - -struct _mesa_glsl_parse_state; -struct glsl_symbol_table; - -extern void -_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state); - -extern void -_mesa_glsl_release_types(void); - -#ifdef __cplusplus -} -#endif - -enum glsl_base_type { - GLSL_TYPE_UINT = 0, - GLSL_TYPE_INT, - GLSL_TYPE_FLOAT, - GLSL_TYPE_DOUBLE, - GLSL_TYPE_BOOL, - GLSL_TYPE_SAMPLER, - GLSL_TYPE_IMAGE, - GLSL_TYPE_ATOMIC_UINT, - GLSL_TYPE_STRUCT, - GLSL_TYPE_INTERFACE, - GLSL_TYPE_ARRAY, - GLSL_TYPE_VOID, - GLSL_TYPE_SUBROUTINE, - GLSL_TYPE_ERROR -}; - -enum glsl_sampler_dim { - GLSL_SAMPLER_DIM_1D = 0, - GLSL_SAMPLER_DIM_2D, - GLSL_SAMPLER_DIM_3D, - GLSL_SAMPLER_DIM_CUBE, - GLSL_SAMPLER_DIM_RECT, - GLSL_SAMPLER_DIM_BUF, - GLSL_SAMPLER_DIM_EXTERNAL, - GLSL_SAMPLER_DIM_MS -}; - -enum glsl_interface_packing { - GLSL_INTERFACE_PACKING_STD140, - GLSL_INTERFACE_PACKING_SHARED, - GLSL_INTERFACE_PACKING_PACKED, - GLSL_INTERFACE_PACKING_STD430 -}; - -enum glsl_matrix_layout { - /** - * The layout of the matrix is inherited from the object containing the - * matrix (the top level structure or the uniform block). - */ - GLSL_MATRIX_LAYOUT_INHERITED, - - /** - * Explicit column-major layout - * - * If a uniform block doesn't have an explicit layout set, it will default - * to this layout. - */ - GLSL_MATRIX_LAYOUT_COLUMN_MAJOR, - - /** - * Row-major layout - */ - GLSL_MATRIX_LAYOUT_ROW_MAJOR -}; - -enum { - GLSL_PRECISION_NONE = 0, - GLSL_PRECISION_HIGH, - GLSL_PRECISION_MEDIUM, - GLSL_PRECISION_LOW -}; - -#ifdef __cplusplus -#include "GL/gl.h" -#include "util/ralloc.h" -#include "main/mtypes.h" /* for gl_texture_index, C++'s enum rules are broken */ - -struct glsl_type { - GLenum gl_type; - glsl_base_type base_type; - - unsigned sampler_dimensionality:3; /**< \see glsl_sampler_dim */ - unsigned sampler_shadow:1; - unsigned sampler_array:1; - unsigned sampler_type:2; /**< Type of data returned using this - * sampler or image. Only \c - * GLSL_TYPE_FLOAT, \c GLSL_TYPE_INT, - * and \c GLSL_TYPE_UINT are valid. - */ - unsigned interface_packing:2; - - /* Callers of this ralloc-based new need not call delete. It's - * easier to just ralloc_free 'mem_ctx' (or any of its ancestors). */ - static void* operator new(size_t size) - { - mtx_lock(&glsl_type::mutex); - - /* mem_ctx should have been created by the static members */ - assert(glsl_type::mem_ctx != NULL); - - void *type; - - type = ralloc_size(glsl_type::mem_ctx, size); - assert(type != NULL); - - mtx_unlock(&glsl_type::mutex); - - return type; - } - - /* If the user *does* call delete, that's OK, we will just - * ralloc_free in that case. */ - static void operator delete(void *type) - { - mtx_lock(&glsl_type::mutex); - ralloc_free(type); - mtx_unlock(&glsl_type::mutex); - } - - /** - * \name Vector and matrix element counts - * - * For scalars, each of these values will be 1. For non-numeric types - * these will be 0. - */ - /*@{*/ - uint8_t vector_elements; /**< 1, 2, 3, or 4 vector elements. */ - uint8_t matrix_columns; /**< 1, 2, 3, or 4 matrix columns. */ - /*@}*/ - - /** - * For \c GLSL_TYPE_ARRAY, this is the length of the array. For - * \c GLSL_TYPE_STRUCT or \c GLSL_TYPE_INTERFACE, it is the number of - * elements in the structure and the number of values pointed to by - * \c fields.structure (below). - */ - unsigned length; - - /** - * Name of the data type - * - * Will never be \c NULL. - */ - const char *name; - - /** - * Subtype of composite data types. - */ - union { - const struct glsl_type *array; /**< Type of array elements. */ - const struct glsl_type *parameters; /**< Parameters to function. */ - struct glsl_struct_field *structure; /**< List of struct fields. */ - } fields; - - /** - * \name Pointers to various public type singletons - */ - /*@{*/ -#undef DECL_TYPE -#define DECL_TYPE(NAME, ...) \ - static const glsl_type *const NAME##_type; -#undef STRUCT_TYPE -#define STRUCT_TYPE(NAME) \ - static const glsl_type *const struct_##NAME##_type; -#include "compiler/builtin_type_macros.h" - /*@}*/ - - /** - * Convenience accessors for vector types (shorter than get_instance()). - * @{ - */ - static const glsl_type *vec(unsigned components); - static const glsl_type *dvec(unsigned components); - static const glsl_type *ivec(unsigned components); - static const glsl_type *uvec(unsigned components); - static const glsl_type *bvec(unsigned components); - /**@}*/ - - /** - * For numeric and boolean derived types returns the basic scalar type - * - * If the type is a numeric or boolean scalar, vector, or matrix type, - * this function gets the scalar type of the individual components. For - * all other types, including arrays of numeric or boolean types, the - * error type is returned. - */ - const glsl_type *get_base_type() const; - - /** - * Get the basic scalar type which this type aggregates. - * - * If the type is a numeric or boolean scalar, vector, or matrix, or an - * array of any of those, this function gets the scalar type of the - * individual components. For structs and arrays of structs, this function - * returns the struct type. For samplers and arrays of samplers, this - * function returns the sampler type. - */ - const glsl_type *get_scalar_type() const; - - /** - * Get the instance of a built-in scalar, vector, or matrix type - */ - static const glsl_type *get_instance(unsigned base_type, unsigned rows, - unsigned columns); - - /** - * Get the instance of a sampler type - */ - static const glsl_type *get_sampler_instance(enum glsl_sampler_dim dim, - bool shadow, - bool array, - glsl_base_type type); - - - /** - * Get the instance of an array type - */ - static const glsl_type *get_array_instance(const glsl_type *base, - unsigned elements); - - /** - * Get the instance of a record type - */ - static const glsl_type *get_record_instance(const glsl_struct_field *fields, - unsigned num_fields, - const char *name); - - /** - * Get the instance of an interface block type - */ - static const glsl_type *get_interface_instance(const glsl_struct_field *fields, - unsigned num_fields, - enum glsl_interface_packing packing, - const char *block_name); - - /** - * Get the instance of an subroutine type - */ - static const glsl_type *get_subroutine_instance(const char *subroutine_name); - - /** - * Get the type resulting from a multiplication of \p type_a * \p type_b - */ - static const glsl_type *get_mul_type(const glsl_type *type_a, - const glsl_type *type_b); - - /** - * Query the total number of scalars that make up a scalar, vector or matrix - */ - unsigned components() const - { - return vector_elements * matrix_columns; - } - - /** - * Calculate the number of components slots required to hold this type - * - * This is used to determine how many uniform or varying locations a type - * might occupy. - */ - unsigned component_slots() const; - - /** - * Calculate offset between the base location of the struct in - * uniform storage and a struct member. - * For the initial call, length is the index of the member to find the - * offset for. - */ - unsigned record_location_offset(unsigned length) const; - - /** - * Calculate the number of unique values from glGetUniformLocation for the - * elements of the type. - * - * This is used to allocate slots in the UniformRemapTable, the amount of - * locations may not match with actual used storage space by the driver. - */ - unsigned uniform_locations() const; - - /** - * Calculate the number of attribute slots required to hold this type - * - * This implements the language rules of GLSL 1.50 for counting the number - * of slots used by a vertex attribute. It also determines the number of - * varying slots the type will use up in the absence of varying packing - * (and thus, it can be used to measure the number of varying slots used by - * the varyings that are generated by lower_packed_varyings). - * - * For vertex shader attributes - doubles only take one slot. - * For inter-shader varyings - dvec3/dvec4 take two slots. - */ - unsigned count_attribute_slots(bool vertex_input_slots) const; - - /** - * Alignment in bytes of the start of this type in a std140 uniform - * block. - */ - unsigned std140_base_alignment(bool row_major) const; - - /** Size in bytes of this type in a std140 uniform block. - * - * Note that this is not GL_UNIFORM_SIZE (which is the number of - * elements in the array) - */ - unsigned std140_size(bool row_major) const; - - /** - * Alignment in bytes of the start of this type in a std430 shader - * storage block. - */ - unsigned std430_base_alignment(bool row_major) const; - - /** - * Calculate array stride in bytes of this type in a std430 shader storage - * block. - */ - unsigned std430_array_stride(bool row_major) const; - - /** - * Size in bytes of this type in a std430 shader storage block. - * - * Note that this is not GL_BUFFER_SIZE - */ - unsigned std430_size(bool row_major) const; - - /** - * \brief Can this type be implicitly converted to another? - * - * \return True if the types are identical or if this type can be converted - * to \c desired according to Section 4.1.10 of the GLSL spec. - * - * \verbatim - * From page 25 (31 of the pdf) of the GLSL 1.50 spec, Section 4.1.10 - * Implicit Conversions: - * - * In some situations, an expression and its type will be implicitly - * converted to a different type. The following table shows all allowed - * implicit conversions: - * - * Type of expression | Can be implicitly converted to - * -------------------------------------------------- - * int float - * uint - * - * ivec2 vec2 - * uvec2 - * - * ivec3 vec3 - * uvec3 - * - * ivec4 vec4 - * uvec4 - * - * There are no implicit array or structure conversions. For example, - * an array of int cannot be implicitly converted to an array of float. - * There are no implicit conversions between signed and unsigned - * integers. - * \endverbatim - */ - bool can_implicitly_convert_to(const glsl_type *desired, - _mesa_glsl_parse_state *state) const; - - /** - * Query whether or not a type is a scalar (non-vector and non-matrix). - */ - bool is_scalar() const - { - return (vector_elements == 1) - && (base_type >= GLSL_TYPE_UINT) - && (base_type <= GLSL_TYPE_BOOL); - } - - /** - * Query whether or not a type is a vector - */ - bool is_vector() const - { - return (vector_elements > 1) - && (matrix_columns == 1) - && (base_type >= GLSL_TYPE_UINT) - && (base_type <= GLSL_TYPE_BOOL); - } - - /** - * Query whether or not a type is a matrix - */ - bool is_matrix() const - { - /* GLSL only has float matrices. */ - return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT || base_type == GLSL_TYPE_DOUBLE); - } - - /** - * Query whether or not a type is a non-array numeric type - */ - bool is_numeric() const - { - return (base_type >= GLSL_TYPE_UINT) && (base_type <= GLSL_TYPE_DOUBLE); - } - - /** - * Query whether or not a type is an integral type - */ - bool is_integer() const - { - return (base_type == GLSL_TYPE_UINT) || (base_type == GLSL_TYPE_INT); - } - - /** - * Query whether or not type is an integral type, or for struct and array - * types, contains an integral type. - */ - bool contains_integer() const; - - /** - * Query whether or not type is a double type, or for struct and array - * types, contains a double type. - */ - bool contains_double() const; - - /** - * Query whether or not a type is a float type - */ - bool is_float() const - { - return base_type == GLSL_TYPE_FLOAT; - } - - /** - * Query whether or not a type is a double type - */ - bool is_double() const - { - return base_type == GLSL_TYPE_DOUBLE; - } - - /** - * Query whether a double takes two slots. - */ - bool is_dual_slot_double() const - { - return base_type == GLSL_TYPE_DOUBLE && vector_elements > 2; - } - - /** - * Query whether or not a type is a non-array boolean type - */ - bool is_boolean() const - { - return base_type == GLSL_TYPE_BOOL; - } - - /** - * Query whether or not a type is a sampler - */ - bool is_sampler() const - { - return base_type == GLSL_TYPE_SAMPLER; - } - - /** - * Query whether or not type is a sampler, or for struct and array - * types, contains a sampler. - */ - bool contains_sampler() const; - - /** - * Get the Mesa texture target index for a sampler type. - */ - gl_texture_index sampler_index() const; - - /** - * Query whether or not type is an image, or for struct and array - * types, contains an image. - */ - bool contains_image() const; - - /** - * Query whether or not a type is an image - */ - bool is_image() const - { - return base_type == GLSL_TYPE_IMAGE; - } - - /** - * Query whether or not a type is an array - */ - bool is_array() const - { - return base_type == GLSL_TYPE_ARRAY; - } - - bool is_array_of_arrays() const - { - return is_array() && fields.array->is_array(); - } - - /** - * Query whether or not a type is a record - */ - bool is_record() const - { - return base_type == GLSL_TYPE_STRUCT; - } - - /** - * Query whether or not a type is an interface - */ - bool is_interface() const - { - return base_type == GLSL_TYPE_INTERFACE; - } - - /** - * Query whether or not a type is the void type singleton. - */ - bool is_void() const - { - return base_type == GLSL_TYPE_VOID; - } - - /** - * Query whether or not a type is the error type singleton. - */ - bool is_error() const - { - return base_type == GLSL_TYPE_ERROR; - } - - /** - * Query if a type is unnamed/anonymous (named by the parser) - */ - - bool is_subroutine() const - { - return base_type == GLSL_TYPE_SUBROUTINE; - } - bool contains_subroutine() const; - - bool is_anonymous() const - { - return !strncmp(name, "#anon", 5); - } - - /** - * Get the type stripped of any arrays - * - * \return - * Pointer to the type of elements of the first non-array type for array - * types, or pointer to itself for non-array types. - */ - const glsl_type *without_array() const - { - const glsl_type *t = this; - - while (t->is_array()) - t = t->fields.array; - - return t; - } - - /** - * Return the total number of elements in an array including the elements - * in arrays of arrays. - */ - unsigned arrays_of_arrays_size() const - { - if (!is_array()) - return 0; - - unsigned size = length; - const glsl_type *base_type = fields.array; - - while (base_type->is_array()) { - size = size * base_type->length; - base_type = base_type->fields.array; - } - return size; - } - - /** - * Return the amount of atomic counter storage required for a type. - */ - unsigned atomic_size() const - { - if (base_type == GLSL_TYPE_ATOMIC_UINT) - return ATOMIC_COUNTER_SIZE; - else if (is_array()) - return length * fields.array->atomic_size(); - else - return 0; - } - - /** - * Return whether a type contains any atomic counters. - */ - bool contains_atomic() const - { - return atomic_size() > 0; - } - - /** - * Return whether a type contains any opaque types. - */ - bool contains_opaque() const; - - /** - * Query the full type of a matrix row - * - * \return - * If the type is not a matrix, \c glsl_type::error_type is returned. - * Otherwise a type matching the rows of the matrix is returned. - */ - const glsl_type *row_type() const - { - return is_matrix() - ? get_instance(base_type, matrix_columns, 1) - : error_type; - } - - /** - * Query the full type of a matrix column - * - * \return - * If the type is not a matrix, \c glsl_type::error_type is returned. - * Otherwise a type matching the columns of the matrix is returned. - */ - const glsl_type *column_type() const - { - return is_matrix() - ? get_instance(base_type, vector_elements, 1) - : error_type; - } - - /** - * Get the type of a structure field - * - * \return - * Pointer to the type of the named field. If the type is not a structure - * or the named field does not exist, \c glsl_type::error_type is returned. - */ - const glsl_type *field_type(const char *name) const; - - /** - * Get the location of a field within a record type - */ - int field_index(const char *name) const; - - /** - * Query the number of elements in an array type - * - * \return - * The number of elements in the array for array types or -1 for non-array - * types. If the number of elements in the array has not yet been declared, - * zero is returned. - */ - int array_size() const - { - return is_array() ? length : -1; - } - - /** - * Query whether the array size for all dimensions has been declared. - */ - bool is_unsized_array() const - { - return is_array() && length == 0; - } - - /** - * Return the number of coordinate components needed for this - * sampler or image type. - * - * This is based purely on the sampler's dimensionality. For example, this - * returns 1 for sampler1D, and 3 for sampler2DArray. - * - * Note that this is often different than actual coordinate type used in - * a texturing built-in function, since those pack additional values (such - * as the shadow comparitor or projector) into the coordinate type. - */ - int coordinate_components() const; - - /** - * Compare a record type against another record type. - * - * This is useful for matching record types declared across shader stages. - */ - bool record_compare(const glsl_type *b) const; - -private: - - static mtx_t mutex; - - /** - * ralloc context for all glsl_type allocations - * - * Set on the first call to \c glsl_type::new. - */ - static void *mem_ctx; - - void init_ralloc_type_ctx(void); - - /** Constructor for vector and matrix types */ - glsl_type(GLenum gl_type, - glsl_base_type base_type, unsigned vector_elements, - unsigned matrix_columns, const char *name); - - /** Constructor for sampler or image types */ - glsl_type(GLenum gl_type, glsl_base_type base_type, - enum glsl_sampler_dim dim, bool shadow, bool array, - unsigned type, const char *name); - - /** Constructor for record types */ - glsl_type(const glsl_struct_field *fields, unsigned num_fields, - const char *name); - - /** Constructor for interface types */ - glsl_type(const glsl_struct_field *fields, unsigned num_fields, - enum glsl_interface_packing packing, const char *name); - - /** Constructor for array types */ - glsl_type(const glsl_type *array, unsigned length); - - /** Constructor for subroutine types */ - glsl_type(const char *name); - - /** Hash table containing the known array types. */ - static struct hash_table *array_types; - - /** Hash table containing the known record types. */ - static struct hash_table *record_types; - - /** Hash table containing the known interface types. */ - static struct hash_table *interface_types; - - /** Hash table containing the known subroutine types. */ - static struct hash_table *subroutine_types; - - static bool record_key_compare(const void *a, const void *b); - static unsigned record_key_hash(const void *key); - - /** - * \name Built-in type flyweights - */ - /*@{*/ -#undef DECL_TYPE -#define DECL_TYPE(NAME, ...) static const glsl_type _##NAME##_type; -#undef STRUCT_TYPE -#define STRUCT_TYPE(NAME) static const glsl_type _struct_##NAME##_type; -#include "compiler/builtin_type_macros.h" - /*@}*/ - - /** - * \name Friend functions. - * - * These functions are friends because they must have C linkage and the - * need to call various private methods or access various private static - * data. - */ - /*@{*/ - friend void _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *); - friend void _mesa_glsl_release_types(void); - /*@}*/ -}; - -struct glsl_struct_field { - const struct glsl_type *type; - const char *name; - - /** - * For interface blocks, gl_varying_slot corresponding to the input/output - * if this is a built-in input/output (i.e. a member of the built-in - * gl_PerVertex interface block); -1 otherwise. - * - * Ignored for structs. - */ - int location; - - /** - * For interface blocks, the interpolation mode (as in - * ir_variable::interpolation). 0 otherwise. - */ - unsigned interpolation:2; - - /** - * For interface blocks, 1 if this variable uses centroid interpolation (as - * in ir_variable::centroid). 0 otherwise. - */ - unsigned centroid:1; - - /** - * For interface blocks, 1 if this variable uses sample interpolation (as - * in ir_variable::sample). 0 otherwise. - */ - unsigned sample:1; - - /** - * Layout of the matrix. Uses glsl_matrix_layout values. - */ - unsigned matrix_layout:2; - - /** - * For interface blocks, 1 if this variable is a per-patch input or output - * (as in ir_variable::patch). 0 otherwise. - */ - unsigned patch:1; - - /** - * Precision qualifier - */ - unsigned precision:2; - - /** - * Image qualifiers, applicable to buffer variables defined in shader - * storage buffer objects (SSBOs) - */ - unsigned image_read_only:1; - unsigned image_write_only:1; - unsigned image_coherent:1; - unsigned image_volatile:1; - unsigned image_restrict:1; - - glsl_struct_field(const struct glsl_type *_type, const char *_name) - : type(_type), name(_name), location(-1), interpolation(0), centroid(0), - sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0), - precision(GLSL_PRECISION_NONE) - { - /* empty */ - } - - glsl_struct_field() - { - /* empty */ - } -}; - -static inline unsigned int -glsl_align(unsigned int a, unsigned int align) -{ - return (a + align - 1) / align * align; -} - -#undef DECL_TYPE -#undef STRUCT_TYPE -#endif /* __cplusplus */ - -#endif /* GLSL_TYPES_H */ 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 <stdio.h> -/* C wrapper around glsl_types.h */ +/* C wrapper around compiler/glsl_types.h */ -#include "glsl_types.h" +#include "compiler/glsl_types.h" #ifdef __cplusplus extern "C" { 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 <condition>) */ -#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 { |