X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcompiler%2Fglsl_types.h;h=9e8b093c9de78b470c76bdf54aa8f36e746d67ba;hb=1acffb56718c46c443822c01a4c20bebd502063b;hp=0cb0f9ee8aef8b192fbc7940cbc8d6bd587a3aad;hpb=92c1290dc57b493690ffe754b1b7724e93d41900;p=mesa.git diff --git a/src/compiler/glsl_types.h b/src/compiler/glsl_types.h index 0cb0f9ee8ae..9e8b093c9de 100644 --- a/src/compiler/glsl_types.h +++ b/src/compiler/glsl_types.h @@ -30,6 +30,12 @@ #include "shader_enums.h" #include "blob.h" +#include "c11/threads.h" +#include "util/macros.h" + +#ifdef __cplusplus +#include "main/config.h" +#endif struct glsl_type; @@ -41,10 +47,13 @@ struct _mesa_glsl_parse_state; struct glsl_symbol_table; extern void -_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state); +glsl_type_singleton_init_or_ref(); + +extern void +glsl_type_singleton_decref(); extern void -_mesa_glsl_release_types(void); +_mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state); void encode_type_to_blob(struct blob *blob, const struct glsl_type *type); @@ -61,7 +70,12 @@ enum glsl_base_type { GLSL_TYPE_UINT = 0, GLSL_TYPE_INT, GLSL_TYPE_FLOAT, + GLSL_TYPE_FLOAT16, GLSL_TYPE_DOUBLE, + GLSL_TYPE_UINT8, + GLSL_TYPE_INT8, + GLSL_TYPE_UINT16, + GLSL_TYPE_INT16, GLSL_TYPE_UINT64, GLSL_TYPE_INT64, GLSL_TYPE_BOOL, @@ -77,6 +91,13 @@ enum glsl_base_type { GLSL_TYPE_ERROR }; +static inline bool glsl_base_type_is_16bit(enum glsl_base_type type) +{ + return type == GLSL_TYPE_FLOAT16 || + type == GLSL_TYPE_UINT16 || + type == GLSL_TYPE_INT16; +} + static inline bool glsl_base_type_is_64bit(enum glsl_base_type type) { return type == GLSL_TYPE_DOUBLE || @@ -88,7 +109,11 @@ static inline bool glsl_base_type_is_64bit(enum glsl_base_type type) static inline bool glsl_base_type_is_integer(enum glsl_base_type type) { - return type == GLSL_TYPE_UINT || + return type == GLSL_TYPE_UINT8 || + type == GLSL_TYPE_INT8 || + type == GLSL_TYPE_UINT16 || + type == GLSL_TYPE_INT16 || + type == GLSL_TYPE_UINT || type == GLSL_TYPE_INT || type == GLSL_TYPE_UINT64 || type == GLSL_TYPE_INT64 || @@ -97,6 +122,42 @@ static inline bool glsl_base_type_is_integer(enum glsl_base_type type) type == GLSL_TYPE_IMAGE; } +static inline unsigned int +glsl_base_type_get_bit_size(const enum glsl_base_type base_type) +{ + switch (base_type) { + case GLSL_TYPE_BOOL: + return 1; + + case GLSL_TYPE_INT: + case GLSL_TYPE_UINT: + case GLSL_TYPE_FLOAT: /* TODO handle mediump */ + case GLSL_TYPE_SUBROUTINE: + return 32; + + case GLSL_TYPE_FLOAT16: + case GLSL_TYPE_UINT16: + case GLSL_TYPE_INT16: + return 16; + + case GLSL_TYPE_UINT8: + case GLSL_TYPE_INT8: + return 8; + + case GLSL_TYPE_DOUBLE: + case GLSL_TYPE_INT64: + case GLSL_TYPE_UINT64: + case GLSL_TYPE_IMAGE: + case GLSL_TYPE_SAMPLER: + return 64; + + default: + unreachable("unknown base type"); + } + + return 0; +} + enum glsl_sampler_dim { GLSL_SAMPLER_DIM_1D = 0, GLSL_SAMPLER_DIM_2D, @@ -141,7 +202,7 @@ enum { #ifdef __cplusplus #include "GL/gl.h" #include "util/ralloc.h" -#include "main/mtypes.h" /* for gl_texture_index, C++'s enum rules are broken */ +#include "main/menums.h" /* for gl_texture_index, C++'s enum rules are broken */ struct glsl_type { GLenum gl_type; @@ -159,46 +220,20 @@ struct glsl_type { unsigned interface_packing:2; unsigned interface_row_major:1; + /** + * For \c GLSL_TYPE_STRUCT this specifies if the struct is packed or not. + * + * Only used for Compute kernels + */ + unsigned packed:1; + private: - glsl_type() + glsl_type() : mem_ctx(NULL) { // Dummy constructor, just for the sake of ASSERT_BITFIELD_SIZE. } public: - /* 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) - { - ASSERT_BITFIELD_SIZE(glsl_type, base_type, GLSL_TYPE_ERROR); - ASSERT_BITFIELD_SIZE(glsl_type, sampled_type, GLSL_TYPE_ERROR); - ASSERT_BITFIELD_SIZE(glsl_type, sampler_dimensionality, - GLSL_SAMPLER_DIM_SUBPASS_MS); - - mtx_lock(&glsl_type::mem_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::mem_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::mem_mutex); - ralloc_free(type); - mtx_unlock(&glsl_type::mem_mutex); - } - /** * \name Vector and matrix element counts * @@ -225,6 +260,13 @@ public: */ const char *name; + /** + * Explicit array, matrix, or vector stride. This is used to communicate + * explicit array layouts from SPIR-V. Should be 0 if the type has no + * explicit stride. + */ + unsigned explicit_stride; + /** * Subtype of composite data types. */ @@ -251,13 +293,19 @@ public: * Convenience accessors for vector types (shorter than get_instance()). * @{ */ + static const glsl_type *vec(unsigned components, const glsl_type *const ts[]); static const glsl_type *vec(unsigned components); + static const glsl_type *f16vec(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); static const glsl_type *i64vec(unsigned components); static const glsl_type *u64vec(unsigned components); + static const glsl_type *i16vec(unsigned components); + static const glsl_type *u16vec(unsigned components); + static const glsl_type *i8vec(unsigned components); + static const glsl_type *u8vec(unsigned components); /**@}*/ /** @@ -281,11 +329,18 @@ public: */ const glsl_type *get_scalar_type() const; + /** + * Gets the "bare" type without any decorations or layout information. + */ + const glsl_type *get_bare_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); + unsigned columns, + unsigned explicit_stride = 0, + bool row_major = false); /** * Get the instance of a sampler type @@ -302,14 +357,16 @@ public: * Get the instance of an array type */ static const glsl_type *get_array_instance(const glsl_type *base, - unsigned elements); + unsigned elements, + unsigned explicit_stride = 0); /** * Get the instance of a record type */ - static const glsl_type *get_record_instance(const glsl_struct_field *fields, + static const glsl_type *get_struct_instance(const glsl_struct_field *fields, unsigned num_fields, - const char *name); + const char *name, + bool packed = false); /** * Get the instance of an interface block type @@ -360,7 +417,7 @@ public: * For the initial call, length is the index of the member to find the * offset for. */ - unsigned record_location_offset(unsigned length) const; + unsigned struct_location_offset(unsigned length) const; /** * Calculate the number of unique values from glGetUniformLocation for the @@ -388,8 +445,11 @@ public: * * For vertex shader attributes - doubles only take one slot. * For inter-shader varyings - dvec3/dvec4 take two slots. + * + * Vulkan doesn’t make this distinction so the argument should always be + * false. */ - unsigned count_attribute_slots(bool is_vertex_input) const; + unsigned count_attribute_slots(bool is_gl_vertex_input) const; /** * Alignment in bytes of the start of this type in a std140 uniform @@ -404,6 +464,11 @@ public: */ unsigned std140_size(bool row_major) const; + /** + * Gets an explicitly laid out type with the std140 layout. + */ + const glsl_type *get_explicit_std140_type(bool row_major) const; + /** * Alignment in bytes of the start of this type in a std430 shader * storage block. @@ -423,6 +488,26 @@ public: */ unsigned std430_size(bool row_major) const; + /** + * Gets an explicitly laid out type with the std430 layout. + */ + const glsl_type *get_explicit_std430_type(bool row_major) const; + + /** + * Gets an explicitly laid out interface type. + */ + const glsl_type *get_explicit_interface_type(bool supports_std430) const; + + /** + * Alignment in bytes of the start of this type in OpenCL memory. + */ + unsigned cl_alignment() const; + + /** + * Size in bytes of this type in OpenCL memory + */ + unsigned cl_size() const; + /** * \brief Can this type be implicitly converted to another? * @@ -487,7 +572,9 @@ public: bool is_matrix() const { /* GLSL only has float matrices. */ - return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT || base_type == GLSL_TYPE_DOUBLE); + return (matrix_columns > 1) && (base_type == GLSL_TYPE_FLOAT || + base_type == GLSL_TYPE_DOUBLE || + base_type == GLSL_TYPE_FLOAT16); } /** @@ -534,6 +621,12 @@ public: */ bool contains_double() const; + /** + * Query whether or not type is a 64-bit type, or for struct, interface and + * array types, contains a double type. + */ + bool contains_64bit() const; + /** * Query whether or not a type is a float type */ @@ -566,6 +659,24 @@ public: return glsl_base_type_is_64bit(base_type); } + /** + * Query whether or not a type is 16-bit + */ + bool is_16bit() const + { + return glsl_base_type_is_16bit(base_type); + } + + /** + * Query whether or not a type is 32-bit + */ + bool is_32bit() const + { + return base_type == GLSL_TYPE_UINT || + base_type == GLSL_TYPE_INT || + base_type == GLSL_TYPE_FLOAT; + } + /** * Query whether or not a type is a non-array boolean type */ @@ -629,7 +740,7 @@ public: /** * Query whether or not a type is a record */ - bool is_record() const + bool is_struct() const { return base_type == GLSL_TYPE_STRUCT; } @@ -752,9 +863,13 @@ public: */ const glsl_type *row_type() const { - return is_matrix() - ? get_instance(base_type, matrix_columns, 1) - : error_type; + if (!is_matrix()) + return error_type; + + if (explicit_stride && !interface_row_major) + return get_instance(base_type, matrix_columns, 1, explicit_stride); + else + return get_instance(base_type, matrix_columns, 1); } /** @@ -766,9 +881,13 @@ public: */ const glsl_type *column_type() const { - return is_matrix() - ? get_instance(base_type, vector_elements, 1) - : error_type; + if (!is_matrix()) + return error_type; + + if (explicit_stride && interface_row_major) + return get_instance(base_type, vector_elements, 1, explicit_stride); + else + return get_instance(base_type, vector_elements, 1); } /** @@ -822,11 +941,15 @@ public: /** * Compare a record type against another record type. * - * This is useful for matching record types declared across shader stages. + * This is useful for matching record types declared on the same shader + * stage as well as across different shader stages. + * The option to not match name is needed for matching record types + * declared across different shader stages. * The option to not match locations is to deal with places where the * same struct is defined in a block which has a location set on it. */ - bool record_compare(const glsl_type *b, bool match_locations = true) const; + bool record_compare(const glsl_type *b, bool match_name, + bool match_locations = true) const; /** * Get the type interface packing. @@ -865,24 +988,22 @@ public: return (bool) interface_row_major; } + ~glsl_type(); + private: - static mtx_t mem_mutex; static mtx_t hash_mutex; /** - * ralloc context for all glsl_type allocations - * - * Set on the first call to \c glsl_type::new. + * ralloc context for the type itself. */ - static void *mem_ctx; - - void init_ralloc_type_ctx(void); + void *mem_ctx; /** 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); + glsl_base_type base_type, unsigned vector_elements, + unsigned matrix_columns, const char *name, + unsigned explicit_stride = 0, bool row_major = false); /** Constructor for sampler or image types */ glsl_type(GLenum gl_type, glsl_base_type base_type, @@ -891,7 +1012,7 @@ private: /** Constructor for record types */ glsl_type(const glsl_struct_field *fields, unsigned num_fields, - const char *name); + const char *name, bool packed = false); /** Constructor for interface types */ glsl_type(const glsl_struct_field *fields, unsigned num_fields, @@ -902,17 +1023,20 @@ private: glsl_type(const glsl_type *return_type, const glsl_function_param *params, unsigned num_params); - /** Constructor for array types */ - glsl_type(const glsl_type *array, unsigned length); + /** Constructors for array types */ + glsl_type(const glsl_type *array, unsigned length, unsigned explicit_stride); /** Constructor for subroutine types */ glsl_type(const char *name); + /** Hash table containing the known explicit matrix and vector types. */ + static struct hash_table *explicit_matrix_types; + /** 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 struct types. */ + static struct hash_table *struct_types; /** Hash table containing the known interface types. */ static struct hash_table *interface_types; @@ -945,8 +1069,9 @@ private: * data. */ /*@{*/ + friend void glsl_type_singleton_init_or_ref(void); + friend void glsl_type_singleton_decref(void); friend void _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *); - friend void _mesa_glsl_release_types(void); /*@}*/ }; @@ -1046,7 +1171,7 @@ struct glsl_struct_field { unsigned implicit_sized_array:1; #ifdef __cplusplus glsl_struct_field(const struct glsl_type *_type, const char *_name) - : type(_type), name(_name), location(-1), offset(0), xfb_buffer(0), + : type(_type), name(_name), location(-1), offset(-1), xfb_buffer(0), xfb_stride(0), interpolation(0), centroid(0), sample(0), matrix_layout(GLSL_MATRIX_LAYOUT_INHERITED), patch(0), precision(GLSL_PRECISION_NONE), memory_read_only(0), @@ -1058,7 +1183,7 @@ struct glsl_struct_field { } glsl_struct_field() - : type(NULL), name(NULL), location(0), offset(0), xfb_buffer(0), + : type(NULL), name(NULL), location(-1), offset(-1), xfb_buffer(0), xfb_stride(0), interpolation(0), centroid(0), sample(0), matrix_layout(0), patch(0), precision(0), memory_read_only(0),