On Oct 10, 2015 11:48 AM, "Rob Clark" <<a href="mailto:robdclark@gmail.com">robdclark@gmail.com</a>> wrote: > > From: Rob Clark <<a href="mailto:robclark@freedesktop.org">robclark@freedesktop.org</a>> > > Move glsl_types into NIR, now that the dependency on glsl_symbol_table > has been split out. > > Possibly makes sense to rename things at this point, but if we do that > I'd like to keep it split out into a separate patch to make git history > easier to follow (IMHO). Agreed. That said, I'm not sure that renaming glsl_type is really needed. It is still heavily based on glsl at least for now. And the type names are taken from glsl. I'm not going to stand in the way of a rename though. > Signed-off-by: Rob Clark <<a href="mailto:robclark@freedesktop.org">robclark@freedesktop.org</a>> > --- > src/glsl/Makefile.am | 3 - > src/glsl/Makefile.sources | 4 +- > src/glsl/builtin_type_macros.h | 172 -- > src/glsl/glsl_types.cpp | 1729 -------------------- > src/glsl/glsl_types.h | 867 ---------- > src/glsl/nir/builtin_type_macros.h | 172 ++ > src/glsl/nir/glsl_types.cpp | 1729 ++++++++++++++++++++ > src/glsl/nir/glsl_types.h | 867 ++++++++++ > src/glsl/nir/nir_types.h | 2 +- > .../drivers/dri/i965/brw_cubemap_normalize.cpp | 2 +- > src/mesa/drivers/dri/i965/brw_fs.cpp | 2 +- > src/mesa/drivers/dri/i965/brw_fs.h | 2 +- > .../dri/i965/brw_fs_channel_expressions.cpp | 2 +- > src/mesa/drivers/dri/i965/brw_fs_reg_allocate.cpp | 2 +- > .../drivers/dri/i965/brw_fs_vector_splitting.cpp | 2 +- > src/mesa/drivers/dri/i965/brw_fs_visitor.cpp | 2 +- > .../dri/i965/brw_lower_unnormalized_offset.cpp | 2 +- > .../drivers/dri/i965/brw_schedule_instructions.cpp | 2 +- > src/mesa/main/ff_fragment_shader.cpp | 2 +- > src/mesa/main/uniforms.h | 2 +- > src/mesa/program/ir_to_mesa.cpp | 2 +- > src/mesa/program/sampler.cpp | 2 +- > 22 files changed, 2784 insertions(+), 2787 deletions(-) > delete mode 100644 src/glsl/builtin_type_macros.h > delete mode 100644 src/glsl/glsl_types.cpp > delete mode 100644 src/glsl/glsl_types.h > create mode 100644 src/glsl/nir/builtin_type_macros.h > create mode 100644 src/glsl/nir/glsl_types.cpp > create mode 100644 src/glsl/nir/glsl_types.h > > diff --git a/src/glsl/Makefile.am b/src/glsl/Makefile.am > index 347919b..437c6a5 100644 > --- a/src/glsl/Makefile.am > +++ b/src/glsl/Makefile.am > @@ -148,9 +148,6 @@ libglsl_la_SOURCES = \ > > > libnir_la_SOURCES = \ > - glsl_types.cpp \ > - builtin_types.cpp \ > - glsl_symbol_table.cpp \ > $(NIR_FILES) \ > $(NIR_GENERATED_FILES) > > diff --git a/src/glsl/Makefile.sources b/src/glsl/Makefile.sources > index 436949c..6e61f23 100644 > --- a/src/glsl/Makefile.sources > +++ b/src/glsl/Makefile.sources > @@ -20,6 +20,8 @@ NIR_GENERATED_FILES = \ > NIR_FILES = \ > nir/glsl_to_nir.cpp \ > nir/glsl_to_nir.h \ > + nir/glsl_types.cpp \ > + nir/glsl_types.h \ > nir/nir.c \ > nir/nir.h \ > nir/nir_array.h \ > @@ -103,8 +105,6 @@ LIBGLSL_FILES = \ > glsl_parser_extras.h \ > glsl_symbol_table.cpp \ > glsl_symbol_table.h \ > - glsl_types.cpp \ > - glsl_types.h \ > hir_field_selection.cpp \ > ir_basic_block.cpp \ > ir_basic_block.h \ > diff --git a/src/glsl/builtin_type_macros.h b/src/glsl/builtin_type_macros.h > deleted file mode 100644 > index 8e16ae4..0000000 > --- a/src/glsl/builtin_type_macros.h > +++ /dev/null > @@ -1,172 +0,0 @@ > -/* > - * Copyright © 2013 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. > - */ > - > -/** > - * \file builtin_type_macros.h > - * > - * This contains definitions for all GLSL built-in types, regardless of what > - * language version or extension might provide them. > - */ > - > -#include "glsl_types.h" > - > -DECL_TYPE(error, GL_INVALID_ENUM, GLSL_TYPE_ERROR, 0, 0) > -DECL_TYPE(void, GL_INVALID_ENUM, GLSL_TYPE_VOID, 0, 0) > - > -DECL_TYPE(bool, GL_BOOL, GLSL_TYPE_BOOL, 1, 1) > -DECL_TYPE(bvec2, GL_BOOL_VEC2, GLSL_TYPE_BOOL, 2, 1) > -DECL_TYPE(bvec3, GL_BOOL_VEC3, GLSL_TYPE_BOOL, 3, 1) > -DECL_TYPE(bvec4, GL_BOOL_VEC4, GLSL_TYPE_BOOL, 4, 1) > - > -DECL_TYPE(int, GL_INT, GLSL_TYPE_INT, 1, 1) > -DECL_TYPE(ivec2, GL_INT_VEC2, GLSL_TYPE_INT, 2, 1) > -DECL_TYPE(ivec3, GL_INT_VEC3, GLSL_TYPE_INT, 3, 1) > -DECL_TYPE(ivec4, GL_INT_VEC4, GLSL_TYPE_INT, 4, 1) > - > -DECL_TYPE(uint, GL_UNSIGNED_INT, GLSL_TYPE_UINT, 1, 1) > -DECL_TYPE(uvec2, GL_UNSIGNED_INT_VEC2, GLSL_TYPE_UINT, 2, 1) > -DECL_TYPE(uvec3, GL_UNSIGNED_INT_VEC3, GLSL_TYPE_UINT, 3, 1) > -DECL_TYPE(uvec4, GL_UNSIGNED_INT_VEC4, GLSL_TYPE_UINT, 4, 1) > - > -DECL_TYPE(float, GL_FLOAT, GLSL_TYPE_FLOAT, 1, 1) > -DECL_TYPE(vec2, GL_FLOAT_VEC2, GLSL_TYPE_FLOAT, 2, 1) > -DECL_TYPE(vec3, GL_FLOAT_VEC3, GLSL_TYPE_FLOAT, 3, 1) > -DECL_TYPE(vec4, GL_FLOAT_VEC4, GLSL_TYPE_FLOAT, 4, 1) > - > -DECL_TYPE(mat2, GL_FLOAT_MAT2, GLSL_TYPE_FLOAT, 2, 2) > -DECL_TYPE(mat3, GL_FLOAT_MAT3, GLSL_TYPE_FLOAT, 3, 3) > -DECL_TYPE(mat4, GL_FLOAT_MAT4, GLSL_TYPE_FLOAT, 4, 4) > - > -DECL_TYPE(mat2x3, GL_FLOAT_MAT2x3, GLSL_TYPE_FLOAT, 3, 2) > -DECL_TYPE(mat2x4, GL_FLOAT_MAT2x4, GLSL_TYPE_FLOAT, 4, 2) > -DECL_TYPE(mat3x2, GL_FLOAT_MAT3x2, GLSL_TYPE_FLOAT, 2, 3) > -DECL_TYPE(mat3x4, GL_FLOAT_MAT3x4, GLSL_TYPE_FLOAT, 4, 3) > -DECL_TYPE(mat4x2, GL_FLOAT_MAT4x2, GLSL_TYPE_FLOAT, 2, 4) > -DECL_TYPE(mat4x3, GL_FLOAT_MAT4x3, GLSL_TYPE_FLOAT, 3, 4) > - > -DECL_TYPE(double, GL_DOUBLE, GLSL_TYPE_DOUBLE, 1, 1) > -DECL_TYPE(dvec2, GL_DOUBLE_VEC2, GLSL_TYPE_DOUBLE, 2, 1) > -DECL_TYPE(dvec3, GL_DOUBLE_VEC3, GLSL_TYPE_DOUBLE, 3, 1) > -DECL_TYPE(dvec4, GL_DOUBLE_VEC4, GLSL_TYPE_DOUBLE, 4, 1) > - > -DECL_TYPE(dmat2, GL_DOUBLE_MAT2, GLSL_TYPE_DOUBLE, 2, 2) > -DECL_TYPE(dmat3, GL_DOUBLE_MAT3, GLSL_TYPE_DOUBLE, 3, 3) > -DECL_TYPE(dmat4, GL_DOUBLE_MAT4, GLSL_TYPE_DOUBLE, 4, 4) > - > -DECL_TYPE(dmat2x3, GL_DOUBLE_MAT2x3, GLSL_TYPE_DOUBLE, 3, 2) > -DECL_TYPE(dmat2x4, GL_DOUBLE_MAT2x4, GLSL_TYPE_DOUBLE, 4, 2) > -DECL_TYPE(dmat3x2, GL_DOUBLE_MAT3x2, GLSL_TYPE_DOUBLE, 2, 3) > -DECL_TYPE(dmat3x4, GL_DOUBLE_MAT3x4, GLSL_TYPE_DOUBLE, 4, 3) > -DECL_TYPE(dmat4x2, GL_DOUBLE_MAT4x2, GLSL_TYPE_DOUBLE, 2, 4) > -DECL_TYPE(dmat4x3, GL_DOUBLE_MAT4x3, GLSL_TYPE_DOUBLE, 3, 4) > - > -DECL_TYPE(sampler1D, GL_SAMPLER_1D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2D, GL_SAMPLER_2D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler3D, GL_SAMPLER_3D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(samplerCube, GL_SAMPLER_CUBE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler1DArray, GL_SAMPLER_1D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DArray, GL_SAMPLER_2D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(samplerCubeArray, GL_SAMPLER_CUBE_MAP_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DRect, GL_SAMPLER_2D_RECT, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(samplerBuffer, GL_SAMPLER_BUFFER, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DMS, GL_SAMPLER_2D_MULTISAMPLE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DMSArray, GL_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_FLOAT) > - > -DECL_TYPE(isampler1D, GL_INT_SAMPLER_1D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isampler2D, GL_INT_SAMPLER_2D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isampler3D, GL_INT_SAMPLER_3D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isamplerCube, GL_INT_SAMPLER_CUBE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isampler1DArray, GL_INT_SAMPLER_1D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(isampler2DArray, GL_INT_SAMPLER_2D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(isamplerCubeArray, GL_INT_SAMPLER_CUBE_MAP_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(isampler2DRect, GL_INT_SAMPLER_2D_RECT, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isamplerBuffer, GL_INT_SAMPLER_BUFFER, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isampler2DMS, GL_INT_SAMPLER_2D_MULTISAMPLE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(isampler2DMSArray, GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_INT) > - > -DECL_TYPE(usampler1D, GL_UNSIGNED_INT_SAMPLER_1D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usampler2D, GL_UNSIGNED_INT_SAMPLER_2D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usampler3D, GL_UNSIGNED_INT_SAMPLER_3D, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usamplerCube, GL_UNSIGNED_INT_SAMPLER_CUBE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usampler1DArray, GL_UNSIGNED_INT_SAMPLER_1D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(usampler2DArray, GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(usamplerCubeArray, GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(usampler2DRect, GL_UNSIGNED_INT_SAMPLER_2D_RECT, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usamplerBuffer, GL_UNSIGNED_INT_SAMPLER_BUFFER, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usampler2DMS, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(usampler2DMSArray, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_UINT) > - > -DECL_TYPE(sampler1DShadow, GL_SAMPLER_1D_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 1, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DShadow, GL_SAMPLER_2D_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 1, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(samplerCubeShadow, GL_SAMPLER_CUBE_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 1, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler1DArrayShadow, GL_SAMPLER_1D_ARRAY_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_1D, 1, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DArrayShadow, GL_SAMPLER_2D_ARRAY_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_2D, 1, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(samplerCubeArrayShadow, GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_CUBE, 1, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(sampler2DRectShadow, GL_SAMPLER_2D_RECT_SHADOW, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_RECT, 1, 0, GLSL_TYPE_FLOAT) > - > -DECL_TYPE(samplerExternalOES, GL_SAMPLER_EXTERNAL_OES, GLSL_TYPE_SAMPLER, GLSL_SAMPLER_DIM_EXTERNAL, 0, 0, GLSL_TYPE_FLOAT) > - > -DECL_TYPE(image1D, GL_IMAGE_1D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(image2D, GL_IMAGE_2D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(image3D, GL_IMAGE_3D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(image2DRect, GL_IMAGE_2D_RECT, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(imageCube, GL_IMAGE_CUBE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(imageBuffer, GL_IMAGE_BUFFER, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(image1DArray, GL_IMAGE_1D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(image2DArray, GL_IMAGE_2D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(imageCubeArray, GL_IMAGE_CUBE_MAP_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(image2DMS, GL_IMAGE_2D_MULTISAMPLE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_FLOAT) > -DECL_TYPE(image2DMSArray, GL_IMAGE_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_FLOAT) > -DECL_TYPE(iimage1D, GL_INT_IMAGE_1D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimage2D, GL_INT_IMAGE_2D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimage3D, GL_INT_IMAGE_3D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimage2DRect, GL_INT_IMAGE_2D_RECT, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimageCube, GL_INT_IMAGE_CUBE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimageBuffer, GL_INT_IMAGE_BUFFER, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimage1DArray, GL_INT_IMAGE_1D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(iimage2DArray, GL_INT_IMAGE_2D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(iimageCubeArray, GL_INT_IMAGE_CUBE_MAP_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(iimage2DMS, GL_INT_IMAGE_2D_MULTISAMPLE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_INT) > -DECL_TYPE(iimage2DMSArray, GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_INT) > -DECL_TYPE(uimage1D, GL_UNSIGNED_INT_IMAGE_1D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimage2D, GL_UNSIGNED_INT_IMAGE_2D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimage3D, GL_UNSIGNED_INT_IMAGE_3D, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_3D, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimage2DRect, GL_UNSIGNED_INT_IMAGE_2D_RECT, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_RECT, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimageCube, GL_UNSIGNED_INT_IMAGE_CUBE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimageBuffer, GL_UNSIGNED_INT_IMAGE_BUFFER, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_BUF, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimage1DArray, GL_UNSIGNED_INT_IMAGE_1D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_1D, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(uimage2DArray, GL_UNSIGNED_INT_IMAGE_2D_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_2D, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(uimageCubeArray, GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_CUBE, 0, 1, GLSL_TYPE_UINT) > -DECL_TYPE(uimage2DMS, GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 0, GLSL_TYPE_UINT) > -DECL_TYPE(uimage2DMSArray, GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY, GLSL_TYPE_IMAGE, GLSL_SAMPLER_DIM_MS, 0, 1, GLSL_TYPE_UINT) > - > -DECL_TYPE(atomic_uint, GL_UNSIGNED_INT_ATOMIC_COUNTER, GLSL_TYPE_ATOMIC_UINT, 1, 1) > - > -STRUCT_TYPE(gl_DepthRangeParameters) > -STRUCT_TYPE(gl_PointParameters) > -STRUCT_TYPE(gl_MaterialParameters) > -STRUCT_TYPE(gl_LightSourceParameters) > -STRUCT_TYPE(gl_LightModelParameters) > -STRUCT_TYPE(gl_LightModelProducts) > -STRUCT_TYPE(gl_LightProducts) > -STRUCT_TYPE(gl_FogParameters) > diff --git a/src/glsl/glsl_types.cpp b/src/glsl/glsl_types.cpp > deleted file mode 100644 > index b0bb2ff..0000000 > --- a/src/glsl/glsl_types.cpp > +++ /dev/null > @@ -1,1729 +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/core.h" /* for Elements, MAX2 */ > -#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; > - } > - > - 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; > - } > - > - 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; > - } > - > - 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->length * r_offset : r_offset; > - } 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->fields.array; > - array_len = this->length; > - } 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->fields.array->is_record()) { > - return this->length * this->fields.array->std140_size(row_major); > - } else { > - unsigned element_base_align = > - this->fields.array->std140_base_alignment(row_major); > - return this->length * 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() 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. > - */ > - switch (this->base_type) { > - case GLSL_TYPE_UINT: > - case GLSL_TYPE_INT: > - case GLSL_TYPE_FLOAT: > - case GLSL_TYPE_BOOL: > - case GLSL_TYPE_DOUBLE: > - 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(); > - > - return size; > - } > - > - case GLSL_TYPE_ARRAY: > - return this->length * this->fields.array->count_attribute_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 "builtin_type_macros.h" > -/** @} */ > diff --git a/src/glsl/glsl_types.h b/src/glsl/glsl_types.h > deleted file mode 100644 > index 3ec7642..0000000 > --- a/src/glsl/glsl_types.h > +++ /dev/null > @@ -1,867 +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 > -}; > - > -#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 "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). > - */ > - unsigned count_attribute_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 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; > - } > - > - /** > - * 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 "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; > - > - /** > - * For interface blocks, it has a value if this variable uses multiple vertex > - * streams (as in ir_variable::stream). -1 otherwise. > - */ > - int stream; > - > - > - /** > - * 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...