#include "compiler/glsl/glsl_parser_extras.h"
#include "glsl_types.h"
#include "util/hash_table.h"
+#include "util/u_string.h"
-mtx_t glsl_type::mem_mutex = _MTX_INITIALIZER_NP;
mtx_t glsl_type::hash_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::function_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_context(NULL);
- 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),
+ base_type(base_type), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing(0), interface_row_major(0),
+ interface_packing(0), interface_row_major(0),
vector_elements(vector_elements), matrix_columns(matrix_columns),
length(0)
{
STATIC_ASSERT((unsigned(GLSL_TYPE_INT) & 3) == unsigned(GLSL_TYPE_INT));
STATIC_ASSERT((unsigned(GLSL_TYPE_FLOAT) & 3) == unsigned(GLSL_TYPE_FLOAT));
- mtx_lock(&glsl_type::mem_mutex);
+ 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);
+
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
- init_ralloc_type_ctx();
assert(name != NULL);
this->name = ralloc_strdup(this->mem_ctx, name);
- mtx_unlock(&glsl_type::mem_mutex);
-
/* Neither dimension is zero or both dimensions are zero.
*/
assert((vector_elements == 0) == (matrix_columns == 0));
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) :
+ glsl_base_type type, const char *name) :
gl_type(gl_type),
- base_type(base_type),
+ base_type(base_type), sampled_type(type),
sampler_dimensionality(dim), sampler_shadow(shadow),
- sampler_array(array), sampled_type(type), interface_packing(0),
+ sampler_array(array), interface_packing(0),
interface_row_major(0), length(0)
{
- mtx_lock(&glsl_type::mem_mutex);
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
- init_ralloc_type_ctx();
assert(name != NULL);
this->name = ralloc_strdup(this->mem_ctx, name);
- mtx_unlock(&glsl_type::mem_mutex);
-
memset(& fields, 0, sizeof(fields));
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),
+ base_type(GLSL_TYPE_STRUCT), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing(0), interface_row_major(0),
+ interface_packing(0), interface_row_major(0),
vector_elements(0), matrix_columns(0),
length(num_fields)
{
unsigned int i;
- mtx_lock(&glsl_type::mem_mutex);
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
- 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);
+ /* Zero-fill to prevent spurious Valgrind errors when serializing NIR
+ * due to uninitialized unused bits in bit fields. */
+ this->fields.structure = rzalloc_array(this->mem_ctx,
+ glsl_struct_field, length);
for (i = 0; i < length; i++) {
this->fields.structure[i] = fields[i];
this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
fields[i].name);
}
-
- mtx_unlock(&glsl_type::mem_mutex);
}
glsl_type::glsl_type(const glsl_struct_field *fields, unsigned num_fields,
enum glsl_interface_packing packing,
bool row_major, const char *name) :
gl_type(0),
- base_type(GLSL_TYPE_INTERFACE),
+ base_type(GLSL_TYPE_INTERFACE), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing((unsigned) packing),
+ interface_packing((unsigned) packing),
interface_row_major((unsigned) row_major),
vector_elements(0), matrix_columns(0),
length(num_fields)
{
unsigned int i;
- mtx_lock(&glsl_type::mem_mutex);
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
- init_ralloc_type_ctx();
assert(name != NULL);
this->name = ralloc_strdup(this->mem_ctx, name);
this->fields.structure = rzalloc_array(this->mem_ctx,
this->fields.structure[i].name = ralloc_strdup(this->fields.structure,
fields[i].name);
}
-
- mtx_unlock(&glsl_type::mem_mutex);
}
glsl_type::glsl_type(const glsl_type *return_type,
const glsl_function_param *params, unsigned num_params) :
gl_type(0),
- base_type(GLSL_TYPE_FUNCTION),
+ base_type(GLSL_TYPE_FUNCTION), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing(0), interface_row_major(0),
+ interface_packing(0), interface_row_major(0),
vector_elements(0), matrix_columns(0),
length(num_params)
{
unsigned int i;
- mtx_lock(&glsl_type::mem_mutex);
-
- init_ralloc_type_ctx();
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
this->fields.parameters = rzalloc_array(this->mem_ctx,
glsl_function_param, num_params + 1);
this->fields.parameters[i + 1].in = params[i].in;
this->fields.parameters[i + 1].out = params[i].out;
}
-
- mtx_unlock(&glsl_type::mem_mutex);
}
glsl_type::glsl_type(const char *subroutine_name) :
gl_type(0),
- base_type(GLSL_TYPE_SUBROUTINE),
+ base_type(GLSL_TYPE_SUBROUTINE), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing(0), interface_row_major(0),
+ interface_packing(0), interface_row_major(0),
vector_elements(1), matrix_columns(1),
length(0)
{
- mtx_lock(&glsl_type::mem_mutex);
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
- init_ralloc_type_ctx();
assert(subroutine_name != NULL);
this->name = ralloc_strdup(this->mem_ctx, subroutine_name);
- mtx_unlock(&glsl_type::mem_mutex);
+}
+
+glsl_type::~glsl_type()
+{
+ ralloc_free(this->mem_ctx);
}
bool
switch (base_type) {
case GLSL_TYPE_UINT:
return uint_type;
+ case GLSL_TYPE_UINT16:
+ return uint16_t_type;
+ case GLSL_TYPE_UINT8:
+ return uint8_t_type;
case GLSL_TYPE_INT:
return int_type;
+ case GLSL_TYPE_INT16:
+ return int16_t_type;
+ case GLSL_TYPE_INT8:
+ return int8_t_type;
case GLSL_TYPE_FLOAT:
return float_type;
+ case GLSL_TYPE_FLOAT16:
+ return float16_t_type;
case GLSL_TYPE_DOUBLE:
return double_type;
case GLSL_TYPE_BOOL:
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;
- case GLSL_TYPE_UINT64:
- return uint64_t_type;
- case GLSL_TYPE_INT64:
- return int64_t_type;
- default:
- /* Handle everything else */
+ const glsl_type *scalar_type = type->get_base_type();
+ if (scalar_type == error_type)
return type;
- }
+
+ return scalar_type;
}
+static void
+hash_free_type_function(struct hash_entry *entry)
+{
+ glsl_type *type = (glsl_type *) entry->data;
+
+ if (type->is_array())
+ free((void*)entry->key);
+
+ delete type;
+}
+
void
_mesa_glsl_release_types(void)
{
* necessary.
*/
if (glsl_type::array_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::array_types, NULL);
+ _mesa_hash_table_destroy(glsl_type::array_types, hash_free_type_function);
glsl_type::array_types = NULL;
}
if (glsl_type::record_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::record_types, NULL);
+ _mesa_hash_table_destroy(glsl_type::record_types, hash_free_type_function);
glsl_type::record_types = NULL;
}
if (glsl_type::interface_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::interface_types, NULL);
+ _mesa_hash_table_destroy(glsl_type::interface_types, hash_free_type_function);
glsl_type::interface_types = NULL;
}
if (glsl_type::function_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::function_types, NULL);
+ _mesa_hash_table_destroy(glsl_type::function_types, hash_free_type_function);
glsl_type::function_types = NULL;
}
if (glsl_type::subroutine_types != NULL) {
- _mesa_hash_table_destroy(glsl_type::subroutine_types, NULL);
+ _mesa_hash_table_destroy(glsl_type::subroutine_types, hash_free_type_function);
glsl_type::subroutine_types = NULL;
}
-
- ralloc_free(glsl_type::mem_ctx);
- glsl_type::mem_ctx = NULL;
}
glsl_type::glsl_type(const glsl_type *array, unsigned length) :
- base_type(GLSL_TYPE_ARRAY),
+ base_type(GLSL_TYPE_ARRAY), sampled_type(GLSL_TYPE_VOID),
sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),
- sampled_type(0), interface_packing(0), interface_row_major(0),
+ interface_packing(0), interface_row_major(0),
vector_elements(0), matrix_columns(0),
length(length), name(NULL)
{
*/
const unsigned name_length = strlen(array->name) + 10 + 3;
- mtx_lock(&glsl_type::mem_mutex);
+ this->mem_ctx = ralloc_context(NULL);
+ assert(this->mem_ctx != NULL);
+
char *const n = (char *) ralloc_size(this->mem_ctx, name_length);
- mtx_unlock(&glsl_type::mem_mutex);
if (length == 0)
- snprintf(n, name_length, "%s[]", array->name);
+ util_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);
+ util_snprintf(n, idx+1, "%s", array->name);
+ util_snprintf(n + idx, name_length - idx, "[%u]%s",
+ length, array->name + idx);
} else {
- snprintf(n, name_length, "%s[%u]", array->name, length);
+ util_snprintf(n, name_length, "%s[%u]", array->name, length);
}
}
this->name = n;
}
-
const glsl_type *
-glsl_type::vec(unsigned components)
+glsl_type::vec(unsigned components, const glsl_type *const ts[])
{
- if (components == 0 || components > 4)
- return error_type;
+ unsigned n = components;
- static const glsl_type *const ts[] = {
- float_type, vec2_type, vec3_type, vec4_type
- };
- return ts[components - 1];
-}
+ if (components == 8)
+ n = 5;
+ else if (components == 16)
+ n = 6;
-const glsl_type *
-glsl_type::dvec(unsigned components)
-{
- if (components == 0 || components > 4)
+ if (n == 0 || n > 6)
return error_type;
- static const glsl_type *const ts[] = {
- double_type, dvec2_type, dvec3_type, dvec4_type
- };
- return ts[components - 1];
+ return ts[n - 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];
+#define VECN(components, sname, vname) \
+const glsl_type * \
+glsl_type:: vname (unsigned components) \
+{ \
+ static const glsl_type *const ts[] = { \
+ sname ## _type, vname ## 2_type, \
+ vname ## 3_type, vname ## 4_type, \
+ vname ## 8_type, vname ## 16_type, \
+ }; \
+ return glsl_type::vec(components, ts); \
}
-
-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::i64vec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- int64_t_type, i64vec2_type, i64vec3_type, i64vec4_type
- };
- return ts[components - 1];
-}
-
-
-const glsl_type *
-glsl_type::u64vec(unsigned components)
-{
- if (components == 0 || components > 4)
- return error_type;
-
- static const glsl_type *const ts[] = {
- uint64_t_type, u64vec2_type, u64vec3_type, u64vec4_type
- };
- return ts[components - 1];
-}
+VECN(components, float, vec)
+VECN(components, float16_t, f16vec)
+VECN(components, double, dvec)
+VECN(components, int, ivec)
+VECN(components, uint, uvec)
+VECN(components, bool, bvec)
+VECN(components, int64_t, i64vec)
+VECN(components, uint64_t, u64vec)
+VECN(components, int16_t, i16vec)
+VECN(components, uint16_t, u16vec)
+VECN(components, int8_t, i8vec)
+VECN(components, uint8_t, u8vec)
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) {
return ivec(rows);
case GLSL_TYPE_FLOAT:
return vec(rows);
+ case GLSL_TYPE_FLOAT16:
+ return f16vec(rows);
case GLSL_TYPE_DOUBLE:
return dvec(rows);
case GLSL_TYPE_BOOL:
return u64vec(rows);
case GLSL_TYPE_INT64:
return i64vec(rows);
+ case GLSL_TYPE_UINT16:
+ return u16vec(rows);
+ case GLSL_TYPE_INT16:
+ return i16vec(rows);
+ case GLSL_TYPE_UINT8:
+ return u8vec(rows);
+ case GLSL_TYPE_INT8:
+ return i8vec(rows);
default:
return error_type;
}
} else {
- if ((base_type != GLSL_TYPE_FLOAT && base_type != GLSL_TYPE_DOUBLE) || (rows == 1))
+ if ((base_type != GLSL_TYPE_FLOAT &&
+ base_type != GLSL_TYPE_DOUBLE &&
+ base_type != GLSL_TYPE_FLOAT16) || (rows == 1))
return error_type;
/* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
*/
#define IDX(c,r) (((c-1)*3) + (r-1))
- if (base_type == GLSL_TYPE_DOUBLE) {
+ switch (base_type) {
+ case GLSL_TYPE_DOUBLE: {
switch (IDX(columns, rows)) {
case IDX(2,2): return dmat2_type;
case IDX(2,3): return dmat2x3_type;
case IDX(4,4): return dmat4_type;
default: return error_type;
}
- } else {
+ }
+ case GLSL_TYPE_FLOAT: {
switch (IDX(columns, rows)) {
case IDX(2,2): return mat2_type;
case IDX(2,3): return mat2x3_type;
default: return error_type;
}
}
+ case GLSL_TYPE_FLOAT16: {
+ switch (IDX(columns, rows)) {
+ case IDX(2,2): return f16mat2_type;
+ case IDX(2,3): return f16mat2x3_type;
+ case IDX(2,4): return f16mat2x4_type;
+ case IDX(3,2): return f16mat3x2_type;
+ case IDX(3,3): return f16mat3_type;
+ case IDX(3,4): return f16mat3x4_type;
+ case IDX(4,2): return f16mat4x2_type;
+ case IDX(4,3): return f16mat4x3_type;
+ case IDX(4,4): return f16mat4_type;
+ default: return error_type;
+ }
+ }
+ default: return error_type;
+ }
}
assert(!"Should not get here.");
* named 'foo'.
*/
char key[128];
- snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
+ util_snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
mtx_lock(&glsl_type::hash_mutex);
const glsl_type *t = new glsl_type(base, array_size);
entry = _mesa_hash_table_insert(array_types,
- ralloc_strdup(mem_ctx, key),
+ strdup(key),
(void *) t);
}
switch (this->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT8:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16:
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_BOOL:
return this->components();
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_DOUBLE:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT16:
+ case GLSL_TYPE_INT8:
case GLSL_TYPE_UINT64:
case GLSL_TYPE_INT64:
case GLSL_TYPE_BOOL:
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_DOUBLE:
case GLSL_TYPE_BOOL:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT16:
+ case GLSL_TYPE_INT8:
case GLSL_TYPE_UINT64:
case GLSL_TYPE_INT64:
return 1;
* state, we're doing intra-stage function linking where these checks have
* already been done.
*/
- if (state && (state->es_shader || !state->is_version(120, 0)))
+ if (state && !state->has_implicit_conversions())
return false;
/* There is no conversion among matrix types. */
* 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 ||
- state->MESA_shader_integer_functions_enable) &&
+ if ((!state || state->has_implicit_uint_to_int_conversion()) &&
desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT)
return true;
switch (this->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
+ case GLSL_TYPE_UINT8:
+ case GLSL_TYPE_INT8:
+ case GLSL_TYPE_UINT16:
+ case GLSL_TYPE_INT16:
case GLSL_TYPE_FLOAT:
+ case GLSL_TYPE_FLOAT16:
case GLSL_TYPE_BOOL:
case GLSL_TYPE_SAMPLER:
case GLSL_TYPE_IMAGE:
}
return;
case GLSL_TYPE_VOID:
+ encoding = (type->base_type << 24);
+ break;
case GLSL_TYPE_ERROR:
default:
assert(!"Cannot encode type!");
return t;
}
case GLSL_TYPE_VOID:
+ return glsl_type::void_type;
case GLSL_TYPE_ERROR:
default:
assert(!"Cannot decode type!");