glsl_type_singleton_decref()
{
mtx_lock(&glsl_type::hash_mutex);
-
assert(glsl_type_users > 0);
/* Do not release glsl_types if they are still used. */
char *const n = (char *) ralloc_size(this->mem_ctx, name_length);
if (length == 0)
- util_snprintf(n, name_length, "%s[]", array->name);
+ 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;
- util_snprintf(n, idx+1, "%s", array->name);
- util_snprintf(n + idx, name_length - idx, "[%u]%s",
+ snprintf(n, idx+1, "%s", array->name);
+ snprintf(n + idx, name_length - idx, "[%u]%s",
length, array->name + idx);
} else {
- util_snprintf(n, name_length, "%s[%u]", array->name, length);
+ snprintf(n, name_length, "%s[%u]", array->name, length);
}
}
assert(columns > 1 || !row_major);
char name[128];
- util_snprintf(name, sizeof(name), "%sx%uB%s", bare_type->name,
- explicit_stride, row_major ? "RM" : "");
+ snprintf(name, sizeof(name), "%sx%uB%s", bare_type->name,
+ explicit_stride, row_major ? "RM" : "");
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (explicit_matrix_types == NULL) {
explicit_matrix_types =
* named 'foo'.
*/
char key[128];
- util_snprintf(key, sizeof(key), "%p[%u]x%uB", (void *) base, array_size,
- explicit_stride);
+ snprintf(key, sizeof(key), "%p[%u]x%uB", (void *) base, array_size,
+ explicit_stride);
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (array_types == NULL) {
array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
const glsl_type key(fields, num_fields, name, packed);
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (struct_types == NULL) {
struct_types = _mesa_hash_table_create(NULL, record_key_hash,
const glsl_type key(fields, num_fields, packing, row_major, block_name);
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (interface_types == NULL) {
interface_types = _mesa_hash_table_create(NULL, record_key_hash,
const glsl_type key(subroutine_name);
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (subroutine_types == NULL) {
subroutine_types = _mesa_hash_table_create(NULL, record_key_hash,
const glsl_type key(return_type, params, num_params);
mtx_lock(&glsl_type::hash_mutex);
+ assert(glsl_type_users > 0);
if (function_types == NULL) {
function_types = _mesa_hash_table_create(NULL, function_key_hash,
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()) {
+ 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
return type;
}
+ } else if (type_a == type_b) {
+ return type_a;
} 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
}
}
+/* This differs from get_explicit_std430_type() in that it:
+ * - can size arrays slightly smaller ("stride * (len - 1) + elem_size" instead
+ * of "stride * len")
+ * - consumes a glsl_type_size_align_func which allows 8 and 16-bit values to be
+ * packed more tightly
+ * - overrides any struct field offsets but get_explicit_std430_type() tries to
+ * respect any existing ones
+ */
+const glsl_type *
+glsl_type::get_explicit_type_for_size_align(glsl_type_size_align_func type_info,
+ unsigned *size, unsigned *alignment) const
+{
+ if (this->is_scalar() || this->is_vector()) {
+ type_info(this, size, alignment);
+ return this;
+ } else if (this->is_array()) {
+ unsigned elem_size, elem_align;
+ const struct glsl_type *explicit_element =
+ this->fields.array->get_explicit_type_for_size_align(type_info, &elem_size, &elem_align);
+
+ unsigned stride = align(elem_size, elem_align);
+
+ *size = stride * (this->length - 1) + elem_size;
+ *alignment = elem_align;
+ return glsl_type::get_array_instance(explicit_element, this->length, stride);
+ } else if (this->is_struct()) {
+ struct glsl_struct_field *fields = (struct glsl_struct_field *)
+ malloc(sizeof(struct glsl_struct_field) * this->length);
+
+ *size = 0;
+ *alignment = 0;
+ for (unsigned i = 0; i < this->length; i++) {
+ fields[i] = this->fields.structure[i];
+ assert(fields[i].matrix_layout != GLSL_MATRIX_LAYOUT_ROW_MAJOR);
+
+ unsigned field_size, field_align;
+ fields[i].type =
+ fields[i].type->get_explicit_type_for_size_align(type_info, &field_size, &field_align);
+ fields[i].offset = align(*size, field_align);
+
+ *size = fields[i].offset + field_size;
+ *alignment = MAX2(*alignment, field_align);
+ }
+
+ const glsl_type *type = glsl_type::get_struct_instance(fields, this->length, this->name, false);
+ free(fields);
+ return type;
+ } else if (this->is_matrix()) {
+ unsigned col_size, col_align;
+ type_info(this->column_type(), &col_size, &col_align);
+ unsigned stride = align(col_size, col_align);
+
+ *size = this->matrix_columns * stride;
+ *alignment = col_align;
+ return glsl_type::get_instance(this->base_type, this->vector_elements,
+ this->matrix_columns, stride, false);
+ } else {
+ unreachable("Unhandled type.");
+ }
+}
+
unsigned
glsl_type::count_attribute_slots(bool is_gl_vertex_input) const
{
sizeof(((glsl_struct_field *)0)->name);
}
+union packed_type {
+ uint32_t u32;
+ struct {
+ unsigned base_type:5;
+ unsigned interface_row_major:1;
+ unsigned vector_elements:3;
+ unsigned matrix_columns:3;
+ unsigned explicit_stride:20;
+ } basic;
+ struct {
+ unsigned base_type:5;
+ unsigned dimensionality:4;
+ unsigned shadow:1;
+ unsigned array:1;
+ unsigned sampled_type:2;
+ unsigned _pad:19;
+ } sampler;
+ struct {
+ unsigned base_type:5;
+ unsigned length:13;
+ unsigned explicit_stride:14;
+ } array;
+ struct {
+ unsigned base_type:5;
+ unsigned interface_packing_or_packed:2;
+ unsigned interface_row_major:1;
+ unsigned length:24;
+ } strct;
+};
+
void
encode_type_to_blob(struct blob *blob, const glsl_type *type)
{
- uint32_t encoding;
-
if (!type) {
blob_write_uint32(blob, 0);
return;
}
+ STATIC_ASSERT(sizeof(union packed_type) == 4);
+ union packed_type encoded;
+ encoded.u32 = 0;
+ encoded.basic.base_type = type->base_type;
+
switch (type->base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
case GLSL_TYPE_UINT64:
case GLSL_TYPE_INT64:
case GLSL_TYPE_BOOL:
- encoding = (type->base_type << 24) |
- (type->interface_row_major << 10) |
- (type->vector_elements << 4) |
- (type->matrix_columns);
- blob_write_uint32(blob, encoding);
- blob_write_uint32(blob, type->explicit_stride);
+ encoded.basic.interface_row_major = type->interface_row_major;
+ assert(type->vector_elements < 8);
+ assert(type->matrix_columns < 8);
+ encoded.basic.vector_elements = type->vector_elements;
+ encoded.basic.matrix_columns = type->matrix_columns;
+ encoded.basic.explicit_stride = MIN2(type->explicit_stride, 0xfffff);
+ blob_write_uint32(blob, encoded.u32);
+ /* If we don't have enough bits for explicit_stride, store it
+ * separately.
+ */
+ if (encoded.basic.explicit_stride == 0xfffff)
+ blob_write_uint32(blob, type->explicit_stride);
return;
case GLSL_TYPE_SAMPLER:
- encoding = (type->base_type) << 24 |
- (type->sampler_dimensionality << 4) |
- (type->sampler_shadow << 3) |
- (type->sampler_array << 2) |
- (type->sampled_type);
+ encoded.sampler.dimensionality = type->sampler_dimensionality;
+ encoded.sampler.shadow = type->sampler_shadow;
+ encoded.sampler.array = type->sampler_array;
+ encoded.sampler.sampled_type = type->sampled_type;
break;
case GLSL_TYPE_SUBROUTINE:
- encoding = type->base_type << 24;
- blob_write_uint32(blob, encoding);
+ blob_write_uint32(blob, encoded.u32);
blob_write_string(blob, type->name);
return;
case GLSL_TYPE_IMAGE:
- encoding = (type->base_type) << 24 |
- (type->sampler_dimensionality << 3) |
- (type->sampler_array << 2) |
- (type->sampled_type);
+ encoded.sampler.dimensionality = type->sampler_dimensionality;
+ encoded.sampler.array = type->sampler_array;
+ encoded.sampler.sampled_type = type->sampled_type;
break;
case GLSL_TYPE_ATOMIC_UINT:
- encoding = (type->base_type << 24);
break;
case GLSL_TYPE_ARRAY:
- blob_write_uint32(blob, (type->base_type) << 24);
- blob_write_uint32(blob, type->length);
- blob_write_uint32(blob, type->explicit_stride);
+ encoded.array.length = MIN2(type->length, 0x1fff);
+ encoded.array.explicit_stride = MIN2(type->explicit_stride, 0x3fff);
+ blob_write_uint32(blob, encoded.u32);
+ /* If we don't have enough bits for length or explicit_stride, store it
+ * separately.
+ */
+ if (encoded.array.length == 0x1fff)
+ blob_write_uint32(blob, type->length);
+ if (encoded.array.explicit_stride == 0x3fff)
+ blob_write_uint32(blob, type->explicit_stride);
encode_type_to_blob(blob, type->fields.array);
return;
case GLSL_TYPE_STRUCT:
case GLSL_TYPE_INTERFACE:
- blob_write_uint32(blob, (type->base_type) << 24);
+ encoded.strct.length = MIN2(type->length, 0xffffff);
+ if (type->is_interface()) {
+ encoded.strct.interface_packing_or_packed = type->interface_packing;
+ encoded.strct.interface_row_major = type->interface_row_major;
+ } else {
+ encoded.strct.interface_packing_or_packed = type->packed;
+ }
+ blob_write_uint32(blob, encoded.u32);
blob_write_string(blob, type->name);
- blob_write_uint32(blob, type->length);
+
+ /* If we don't have enough bits for length, store it separately. */
+ if (encoded.strct.length == 0xffffff)
+ blob_write_uint32(blob, type->length);
size_t s_field_size, s_field_ptrs;
get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
((char *)&type->fields.structure[i]) + s_field_ptrs,
s_field_size - s_field_ptrs);
}
-
- if (type->is_interface()) {
- blob_write_uint32(blob, type->interface_packing);
- blob_write_uint32(blob, type->interface_row_major);
- } else {
- blob_write_uint32(blob, type->packed);
- }
return;
case GLSL_TYPE_VOID:
- encoding = (type->base_type << 24);
break;
case GLSL_TYPE_ERROR:
default:
assert(!"Cannot encode type!");
- encoding = 0;
+ encoded.u32 = 0;
break;
}
- blob_write_uint32(blob, encoding);
+ blob_write_uint32(blob, encoded.u32);
}
const glsl_type *
decode_type_from_blob(struct blob_reader *blob)
{
- uint32_t u = blob_read_uint32(blob);
+ union packed_type encoded;
+ encoded.u32 = blob_read_uint32(blob);
- if (u == 0) {
+ if (encoded.u32 == 0) {
return NULL;
}
- glsl_base_type base_type = (glsl_base_type) (u >> 24);
+ glsl_base_type base_type = (glsl_base_type)encoded.basic.base_type;
switch (base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_UINT64:
case GLSL_TYPE_INT64:
case GLSL_TYPE_BOOL: {
- unsigned explicit_stride = blob_read_uint32(blob);
- return glsl_type::get_instance(base_type, (u >> 4) & 0x0f, u & 0x0f,
- explicit_stride, (u >> 10) & 0x1);
+ unsigned explicit_stride = encoded.basic.explicit_stride;
+ if (explicit_stride == 0xfffff)
+ explicit_stride = blob_read_uint32(blob);
+ return glsl_type::get_instance(base_type, encoded.basic.vector_elements,
+ encoded.basic.matrix_columns,
+ explicit_stride,
+ encoded.basic.interface_row_major);
}
case GLSL_TYPE_SAMPLER:
- return glsl_type::get_sampler_instance((enum glsl_sampler_dim) ((u >> 4) & 0x0f),
- (u >> 3) & 0x01,
- (u >> 2) & 0x01,
- (glsl_base_type) ((u >> 0) & 0x03));
+ return glsl_type::get_sampler_instance((enum glsl_sampler_dim)encoded.sampler.dimensionality,
+ encoded.sampler.shadow,
+ encoded.sampler.array,
+ (glsl_base_type) encoded.sampler.sampled_type);
case GLSL_TYPE_SUBROUTINE:
return glsl_type::get_subroutine_instance(blob_read_string(blob));
case GLSL_TYPE_IMAGE:
- return glsl_type::get_image_instance((enum glsl_sampler_dim) ((u >> 3) & 0x0f),
- (u >> 2) & 0x01,
- (glsl_base_type) ((u >> 0) & 0x03));
+ return glsl_type::get_image_instance((enum glsl_sampler_dim)encoded.sampler.dimensionality,
+ encoded.sampler.array,
+ (glsl_base_type) encoded.sampler.sampled_type);
case GLSL_TYPE_ATOMIC_UINT:
return glsl_type::atomic_uint_type;
case GLSL_TYPE_ARRAY: {
- unsigned length = blob_read_uint32(blob);
- unsigned explicit_stride = blob_read_uint32(blob);
+ unsigned length = encoded.array.length;
+ if (length == 0x1fff)
+ length = blob_read_uint32(blob);
+ unsigned explicit_stride = encoded.array.explicit_stride;
+ if (explicit_stride == 0x3fff)
+ explicit_stride = blob_read_uint32(blob);
return glsl_type::get_array_instance(decode_type_from_blob(blob),
length, explicit_stride);
}
case GLSL_TYPE_STRUCT:
case GLSL_TYPE_INTERFACE: {
char *name = blob_read_string(blob);
- unsigned num_fields = blob_read_uint32(blob);
+ unsigned num_fields = encoded.strct.length;
+ if (num_fields == 0xffffff)
+ num_fields = blob_read_uint32(blob);
size_t s_field_size, s_field_ptrs;
get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs);
const glsl_type *t;
if (base_type == GLSL_TYPE_INTERFACE) {
enum glsl_interface_packing packing =
- (glsl_interface_packing) blob_read_uint32(blob);
- bool row_major = blob_read_uint32(blob);
+ (glsl_interface_packing) encoded.strct.interface_packing_or_packed;
+ bool row_major = encoded.strct.interface_row_major;
t = glsl_type::get_interface_instance(fields, num_fields, packing,
row_major, name);
} else {
- unsigned packed = blob_read_uint32(blob);
+ unsigned packed = encoded.strct.interface_packing_or_packed;
t = glsl_type::get_struct_instance(fields, num_fields, name, packed);
}