X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcompiler%2Fglsl_types.cpp;h=d6315845e683973afd220071c62864bffd9076f5;hb=789ec95dcd18c155a9578b5d5f56cb0aab74c763;hp=16cc79445e21e7b64fd5070f9b30d3fae6b1f0c6;hpb=86adce4fef170ad13e4dc7e341de241bd673993f;p=mesa.git diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp index 16cc79445e2..d6315845e68 100644 --- a/src/compiler/glsl_types.cpp +++ b/src/compiler/glsl_types.cpp @@ -462,6 +462,38 @@ const glsl_type *glsl_type::get_bare_type() const unreachable("Invalid base type"); } +const glsl_type *glsl_type::get_float16_type() const +{ + assert(this->base_type == GLSL_TYPE_FLOAT); + + return get_instance(GLSL_TYPE_FLOAT16, + this->vector_elements, + this->matrix_columns, + this->explicit_stride, + this->interface_row_major); +} + +const glsl_type *glsl_type::get_int16_type() const +{ + assert(this->base_type == GLSL_TYPE_INT); + + return get_instance(GLSL_TYPE_INT16, + this->vector_elements, + this->matrix_columns, + this->explicit_stride, + this->interface_row_major); +} + +const glsl_type *glsl_type::get_uint16_type() const +{ + assert(this->base_type == GLSL_TYPE_UINT); + + return get_instance(GLSL_TYPE_UINT16, + this->vector_elements, + this->matrix_columns, + this->explicit_stride, + this->interface_row_major); +} static void hash_free_type_function(struct hash_entry *entry) @@ -642,7 +674,7 @@ glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns, if (explicit_matrix_types == NULL) { explicit_matrix_types = - _mesa_hash_table_create(NULL, _mesa_key_hash_string, + _mesa_hash_table_create(NULL, _mesa_hash_string, _mesa_key_string_equal); } @@ -663,9 +695,11 @@ glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns, assert(((glsl_type *) entry->data)->matrix_columns == columns); assert(((glsl_type *) entry->data)->explicit_stride == explicit_stride); + const glsl_type *t = (const glsl_type *) entry->data; + mtx_unlock(&glsl_type::hash_mutex); - return (const glsl_type *) entry->data; + return t; } assert(!row_major); @@ -1007,7 +1041,7 @@ glsl_type::get_array_instance(const glsl_type *base, assert(glsl_type_users > 0); if (array_types == NULL) { - array_types = _mesa_hash_table_create(NULL, _mesa_key_hash_string, + array_types = _mesa_hash_table_create(NULL, _mesa_hash_string, _mesa_key_string_equal); } @@ -1024,9 +1058,11 @@ glsl_type::get_array_instance(const glsl_type *base, assert(((glsl_type *) entry->data)->length == array_size); assert(((glsl_type *) entry->data)->fields.array == base); + glsl_type *t = (glsl_type *) entry->data; + mtx_unlock(&glsl_type::hash_mutex); - return (glsl_type *) entry->data; + return t; } bool @@ -1225,9 +1261,11 @@ glsl_type::get_struct_instance(const glsl_struct_field *fields, assert(strcmp(((glsl_type *) entry->data)->name, name) == 0); assert(((glsl_type *) entry->data)->packed == packed); + glsl_type *t = (glsl_type *) entry->data; + mtx_unlock(&glsl_type::hash_mutex); - return (glsl_type *) entry->data; + return t; } @@ -1261,9 +1299,11 @@ glsl_type::get_interface_instance(const glsl_struct_field *fields, assert(((glsl_type *) entry->data)->length == num_fields); assert(strcmp(((glsl_type *) entry->data)->name, block_name) == 0); + glsl_type *t = (glsl_type *) entry->data; + mtx_unlock(&glsl_type::hash_mutex); - return (glsl_type *) entry->data; + return t; } const glsl_type * @@ -1290,9 +1330,11 @@ glsl_type::get_subroutine_instance(const char *subroutine_name) assert(((glsl_type *) entry->data)->base_type == GLSL_TYPE_SUBROUTINE); assert(strcmp(((glsl_type *) entry->data)->name, subroutine_name) == 0); + glsl_type *t = (glsl_type *) entry->data; + mtx_unlock(&glsl_type::hash_mutex); - return (glsl_type *) entry->data; + return t; } @@ -1647,7 +1689,7 @@ glsl_type::can_implicitly_convert_to(const glsl_type *desired, * state-dependent checks have already happened though, so allow anything * that's allowed in any shader version. */ - if ((!state || state->has_implicit_uint_to_int_conversion()) && + if ((!state || state->has_implicit_int_to_uint_conversion()) && desired->base_type == GLSL_TYPE_UINT && this->base_type == GLSL_TYPE_INT) return true; @@ -2432,7 +2474,7 @@ glsl_type::get_explicit_type_for_size_align(glsl_type_size_align_func type_info, } unsigned -glsl_type::count_attribute_slots(bool is_gl_vertex_input) const +glsl_type::count_vec4_slots(bool is_gl_vertex_input, bool is_bindless) const { /* From page 31 (page 37 of the PDF) of the GLSL 1.50 spec: * @@ -2469,8 +2511,6 @@ glsl_type::count_attribute_slots(bool is_gl_vertex_input) const case GLSL_TYPE_FLOAT: case GLSL_TYPE_FLOAT16: case GLSL_TYPE_BOOL: - case GLSL_TYPE_SAMPLER: - case GLSL_TYPE_IMAGE: return this->matrix_columns; case GLSL_TYPE_DOUBLE: case GLSL_TYPE_UINT64: @@ -2485,7 +2525,7 @@ glsl_type::count_attribute_slots(bool is_gl_vertex_input) const for (unsigned i = 0; i < this->length; i++) { const glsl_type *member_type = this->fields.structure[i].type; - size += member_type->count_attribute_slots(is_gl_vertex_input); + size += member_type->count_vec4_slots(is_gl_vertex_input, is_bindless); } return size; @@ -2493,9 +2533,17 @@ glsl_type::count_attribute_slots(bool is_gl_vertex_input) const case GLSL_TYPE_ARRAY: { const glsl_type *element = this->fields.array; - return this->length * element->count_attribute_slots(is_gl_vertex_input); + return this->length * element->count_vec4_slots(is_gl_vertex_input, + is_bindless); } + case GLSL_TYPE_SAMPLER: + case GLSL_TYPE_IMAGE: + if (!is_bindless) + return 0; + else + return 1; + case GLSL_TYPE_SUBROUTINE: return 1; @@ -2511,33 +2559,64 @@ glsl_type::count_attribute_slots(bool is_gl_vertex_input) const return 0; } -int -glsl_type::coordinate_components() const +unsigned +glsl_type::count_dword_slots(bool is_bindless) const { - int size; + 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_UINT16: + case GLSL_TYPE_INT16: + case GLSL_TYPE_FLOAT16: + return DIV_ROUND_UP(this->components(), 2); + case GLSL_TYPE_UINT8: + case GLSL_TYPE_INT8: + return DIV_ROUND_UP(this->components(), 4); + case GLSL_TYPE_IMAGE: + case GLSL_TYPE_SAMPLER: + if (!is_bindless) + return 0; + /* FALLTHROUGH */ + case GLSL_TYPE_DOUBLE: + case GLSL_TYPE_UINT64: + case GLSL_TYPE_INT64: + return this->components() * 2; + case GLSL_TYPE_ARRAY: + return this->fields.array->count_dword_slots(is_bindless) * + this->length; - 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: - case GLSL_SAMPLER_DIM_SUBPASS: - size = 2; - break; - case GLSL_SAMPLER_DIM_3D: - case GLSL_SAMPLER_DIM_CUBE: - size = 3; - break; + case GLSL_TYPE_INTERFACE: + case GLSL_TYPE_STRUCT: { + unsigned size = 0; + for (unsigned i = 0; i < this->length; i++) { + size += this->fields.structure[i].type->count_dword_slots(is_bindless); + } + return size; + } + + case GLSL_TYPE_ATOMIC_UINT: + return 0; + case GLSL_TYPE_SUBROUTINE: + return 1; + case GLSL_TYPE_VOID: + case GLSL_TYPE_ERROR: + case GLSL_TYPE_FUNCTION: default: - assert(!"Should not get here."); - size = 1; - break; + unreachable("invalid type in st_glsl_type_dword_size()"); } + return 0; +} + +int +glsl_type::coordinate_components() const +{ + enum glsl_sampler_dim dim = (enum glsl_sampler_dim)sampler_dimensionality; + int size = glsl_get_sampler_dim_coordinate_components(dim); + /* 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. @@ -2563,16 +2642,6 @@ glsl_type::coordinate_components() const #include "compiler/builtin_type_macros.h" /** @} */ -static void -get_struct_type_field_and_pointer_sizes(size_t *s_field_size, - size_t *s_field_ptrs) -{ - *s_field_size = sizeof(glsl_struct_field); - *s_field_ptrs = - sizeof(((glsl_struct_field *)0)->type) + - sizeof(((glsl_struct_field *)0)->name); -} - union packed_type { uint32_t u32; struct { @@ -2580,7 +2649,7 @@ union packed_type { unsigned interface_row_major:1; unsigned vector_elements:3; unsigned matrix_columns:3; - unsigned _pad:20; + unsigned explicit_stride:20; } basic; struct { unsigned base_type:5; @@ -2590,8 +2659,45 @@ union packed_type { 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; }; +static void +encode_glsl_struct_field(blob *blob, const glsl_struct_field *struct_field) +{ + encode_type_to_blob(blob, struct_field->type); + blob_write_string(blob, struct_field->name); + blob_write_uint32(blob, struct_field->location); + blob_write_uint32(blob, struct_field->offset); + blob_write_uint32(blob, struct_field->xfb_buffer); + blob_write_uint32(blob, struct_field->xfb_stride); + blob_write_uint32(blob, struct_field->image_format); + blob_write_uint32(blob, struct_field->flags); +} + +static void +decode_glsl_struct_field_from_blob(blob_reader *blob, glsl_struct_field *struct_field) +{ + struct_field->type = decode_type_from_blob(blob); + struct_field->name = blob_read_string(blob); + struct_field->location = blob_read_uint32(blob); + struct_field->offset = blob_read_uint32(blob); + struct_field->xfb_buffer = blob_read_uint32(blob); + struct_field->xfb_stride = blob_read_uint32(blob); + struct_field->image_format = (pipe_format)blob_read_uint32(blob); + struct_field->flags = blob_read_uint32(blob); +} + void encode_type_to_blob(struct blob *blob, const glsl_type *type) { @@ -2619,12 +2725,21 @@ encode_type_to_blob(struct blob *blob, const glsl_type *type) case GLSL_TYPE_INT64: case GLSL_TYPE_BOOL: 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; + if (type->vector_elements <= 4) + encoded.basic.vector_elements = type->vector_elements; + else if (type->vector_elements == 8) + encoded.basic.vector_elements = 5; + else if (type->vector_elements == 16) + encoded.basic.vector_elements = 6; encoded.basic.matrix_columns = type->matrix_columns; + encoded.basic.explicit_stride = MIN2(type->explicit_stride, 0xfffff); blob_write_uint32(blob, encoded.u32); - blob_write_uint32(blob, type->explicit_stride); + /* 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: encoded.sampler.dimensionality = type->sampler_dimensionality; @@ -2644,36 +2759,36 @@ encode_type_to_blob(struct blob *blob, const glsl_type *type) case GLSL_TYPE_ATOMIC_UINT: break; case GLSL_TYPE_ARRAY: + encoded.array.length = MIN2(type->length, 0x1fff); + encoded.array.explicit_stride = MIN2(type->explicit_stride, 0x3fff); blob_write_uint32(blob, encoded.u32); - blob_write_uint32(blob, type->length); - blob_write_uint32(blob, type->explicit_stride); + /* 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: + 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); - size_t s_field_size, s_field_ptrs; - get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs); + /* If we don't have enough bits for length, store it separately. */ + if (encoded.strct.length == 0xffffff) + blob_write_uint32(blob, type->length); - for (unsigned i = 0; i < type->length; i++) { - encode_type_to_blob(blob, type->fields.structure[i].type); - blob_write_string(blob, type->fields.structure[i].name); - - /* Write the struct field skipping the pointers */ - blob_write_bytes(blob, - ((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); - } + for (unsigned i = 0; i < type->length; i++) + encode_glsl_struct_field(blob, &type->fields.structure[i]); return; case GLSL_TYPE_VOID: break; @@ -2712,7 +2827,14 @@ decode_type_from_blob(struct blob_reader *blob) case GLSL_TYPE_UINT64: case GLSL_TYPE_INT64: case GLSL_TYPE_BOOL: { - unsigned explicit_stride = blob_read_uint32(blob); + unsigned explicit_stride = encoded.basic.explicit_stride; + if (explicit_stride == 0xfffff) + explicit_stride = blob_read_uint32(blob); + uint32_t vector_elements = encoded.basic.vector_elements; + if (vector_elements == 5) + vector_elements = 8; + else if (vector_elements == 6) + vector_elements = 16; return glsl_type::get_instance(base_type, encoded.basic.vector_elements, encoded.basic.matrix_columns, explicit_stride, @@ -2732,38 +2854,36 @@ decode_type_from_blob(struct blob_reader *blob) 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); - - size_t s_field_size, s_field_ptrs; - get_struct_type_field_and_pointer_sizes(&s_field_size, &s_field_ptrs); + unsigned num_fields = encoded.strct.length; + if (num_fields == 0xffffff) + num_fields = blob_read_uint32(blob); glsl_struct_field *fields = - (glsl_struct_field *) malloc(s_field_size * num_fields); - for (unsigned i = 0; i < num_fields; i++) { - fields[i].type = decode_type_from_blob(blob); - fields[i].name = blob_read_string(blob); - - blob_copy_bytes(blob, ((uint8_t *) &fields[i]) + s_field_ptrs, - s_field_size - s_field_ptrs); - } + (glsl_struct_field *) malloc(sizeof(glsl_struct_field) * num_fields); + for (unsigned i = 0; i < num_fields; i++) + decode_glsl_struct_field_from_blob(blob, &fields[i]); 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); } @@ -2826,3 +2946,29 @@ glsl_type::cl_size() const } return 1; } + +extern "C" { + +int +glsl_get_sampler_dim_coordinate_components(enum glsl_sampler_dim dim) +{ + switch (dim) { + case GLSL_SAMPLER_DIM_1D: + case GLSL_SAMPLER_DIM_BUF: + return 1; + case GLSL_SAMPLER_DIM_2D: + case GLSL_SAMPLER_DIM_RECT: + case GLSL_SAMPLER_DIM_MS: + case GLSL_SAMPLER_DIM_EXTERNAL: + case GLSL_SAMPLER_DIM_SUBPASS: + case GLSL_SAMPLER_DIM_SUBPASS_MS: + return 2; + case GLSL_SAMPLER_DIM_3D: + case GLSL_SAMPLER_DIM_CUBE: + return 3; + default: + unreachable("Unknown sampler dim"); + } +} + +}