From: Caio Oliveira Date: Sat, 2 Sep 2023 19:53:32 +0000 (-0700) Subject: compiler/types: Flip wrapping of layout related functions X-Git-Tag: upstream/23.3.3~404 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e486384540eba0ca20f798769e1d68d8fc352251;p=platform%2Fupstream%2Fmesa.git compiler/types: Flip wrapping of layout related functions Reviewed-by: Kenneth Graunke Part-of: --- diff --git a/src/compiler/glsl_types.cpp b/src/compiler/glsl_types.cpp index 88f8dec..288c7ed 100644 --- a/src/compiler/glsl_types.cpp +++ b/src/compiler/glsl_types.cpp @@ -1959,10 +1959,10 @@ glsl_varying_count(const struct glsl_type *t) } } -unsigned -glsl_type::std140_base_alignment(bool row_major) const +extern "C" unsigned +glsl_get_std140_base_alignment(const struct glsl_type *t, bool row_major) { - unsigned N = is_64bit() ? 8 : 4; + unsigned N = t->is_64bit() ? 8 : 4; /* (1) If the member is a scalar consuming basic machine units, the * base alignment is . @@ -1974,8 +1974,8 @@ glsl_type::std140_base_alignment(bool row_major) const * (3) If the member is a three-component vector with components consuming * basic machine units, the base alignment is 4. */ - if (this->is_scalar() || this->is_vector()) { - switch (this->vector_elements) { + if (t->is_scalar() || t->is_vector()) { + switch (t->vector_elements) { case 1: return N; case 2: @@ -2005,15 +2005,15 @@ glsl_type::std140_base_alignment(bool row_major) const * (10) If the member is an array of structures, the 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); + if (t->is_array()) { + if (t->fields.array->is_scalar() || + t->fields.array->is_vector() || + t->fields.array->is_matrix()) { + return MAX2(t->fields.array->std140_base_alignment(row_major), 16); } else { - assert(this->fields.array->is_struct() || - this->fields.array->is_array()); - return this->fields.array->std140_base_alignment(row_major); + assert(t->fields.array->is_struct() || + t->fields.array->is_array()); + return t->fields.array->std140_base_alignment(row_major); } } @@ -2026,16 +2026,16 @@ glsl_type::std140_base_alignment(bool row_major) const * rows, the matrix is stored identically to an array of * row vectors with components each, according to rule (4). */ - if (this->is_matrix()) { + if (t->is_matrix()) { const struct glsl_type *vec_type, *array_type; - int c = this->matrix_columns; - int r = this->vector_elements; + int c = t->matrix_columns; + int r = t->vector_elements; if (row_major) { - vec_type = get_instance(base_type, c, 1); + vec_type = glsl_type::get_instance(t->base_type, c, 1); array_type = glsl_type::get_array_instance(vec_type, r); } else { - vec_type = get_instance(base_type, r, 1); + vec_type = glsl_type::get_instance(t->base_type, r, 1); array_type = glsl_type::get_array_instance(vec_type, c); } @@ -2054,19 +2054,19 @@ glsl_type::std140_base_alignment(bool row_major) const * rounded up to the next multiple of the base alignment of the * structure. */ - if (this->is_struct()) { + if (t->is_struct()) { unsigned base_alignment = 16; - for (unsigned i = 0; i < this->length; i++) { + for (unsigned i = 0; i < t->length; i++) { bool field_row_major = row_major; const enum glsl_matrix_layout matrix_layout = - (enum glsl_matrix_layout)this->fields.structure[i].matrix_layout; + (enum glsl_matrix_layout)t->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; + const struct glsl_type *field_type = t->fields.structure[i].type; base_alignment = MAX2(base_alignment, field_type->std140_base_alignment(field_row_major)); } @@ -2077,10 +2077,10 @@ glsl_type::std140_base_alignment(bool row_major) const return -1; } -unsigned -glsl_type::std140_size(bool row_major) const +extern "C" unsigned +glsl_get_std140_size(const struct glsl_type *t, bool row_major) { - unsigned N = is_64bit() ? 8 : 4; + unsigned N = t->is_64bit() ? 8 : 4; /* (1) If the member is a scalar consuming basic machine units, the * base alignment is . @@ -2092,9 +2092,9 @@ glsl_type::std140_size(bool row_major) const * (3) If the member is a three-component vector with components consuming * basic machine units, the base alignment is 4. */ - if (this->is_scalar() || this->is_vector()) { - assert(this->explicit_stride == 0); - return this->vector_elements * N; + if (t->is_scalar() || t->is_vector()) { + assert(t->explicit_stride == 0); + return t->vector_elements * N; } /* (5) If the member is a column-major matrix with columns and @@ -2115,27 +2115,27 @@ glsl_type::std140_size(bool row_major) const * and rows, the matrix is stored identically to a row of * * row vectors with components each, according to rule (4). */ - if (this->without_array()->is_matrix()) { + if (t->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(); + if (t->is_array()) { + element_type = t->without_array(); + array_len = t->arrays_of_arrays_size(); } else { - element_type = this; + element_type = t; array_len = 1; } if (row_major) { - vec_type = get_instance(element_type->base_type, - element_type->matrix_columns, 1); + vec_type = glsl_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); + vec_type = glsl_type::get_instance(element_type->base_type, + element_type->vector_elements, 1); array_len *= element_type->matrix_columns; } const struct glsl_type *array_type = @@ -2154,19 +2154,19 @@ glsl_type::std140_size(bool row_major) const * (10) If the member is an array of structures, the elements of * the array are laid out in order, according to rule (9). */ - if (this->is_array()) { + if (t->is_array()) { unsigned stride; - if (this->without_array()->is_struct()) { - stride = this->without_array()->std140_size(row_major); + if (t->without_array()->is_struct()) { + stride = t->without_array()->std140_size(row_major); } else { unsigned element_base_align = - this->without_array()->std140_base_alignment(row_major); + t->without_array()->std140_base_alignment(row_major); stride = MAX2(element_base_align, 16); } - unsigned size = this->arrays_of_arrays_size() * stride; - assert(this->explicit_stride == 0 || - size == this->length * this->explicit_stride); + unsigned size = t->arrays_of_arrays_size() * stride; + assert(t->explicit_stride == 0 || + size == t->length * t->explicit_stride); return size; } @@ -2182,21 +2182,21 @@ glsl_type::std140_size(bool row_major) const * rounded up to the next multiple of the base alignment of the * structure. */ - if (this->is_struct() || this->is_interface()) { + if (t->is_struct() || t->is_interface()) { unsigned size = 0; unsigned max_align = 0; - for (unsigned i = 0; i < this->length; i++) { + for (unsigned i = 0; i < t->length; i++) { bool field_row_major = row_major; const enum glsl_matrix_layout matrix_layout = - (enum glsl_matrix_layout)this->fields.structure[i].matrix_layout; + (enum glsl_matrix_layout)t->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; + const struct glsl_type *field_type = t->fields.structure[i].type; unsigned base_alignment = field_type->std140_base_alignment(field_row_major); /* Ignore unsized arrays when calculating size */ @@ -2208,7 +2208,7 @@ glsl_type::std140_size(bool row_major) const max_align = MAX2(base_alignment, max_align); - if (field_type->is_struct() && (i + 1 < this->length)) + if (field_type->is_struct() && (i + 1 < t->length)) size = align(size, 16); } size = align(size, MAX2(max_align, 16)); @@ -2293,11 +2293,11 @@ glsl_type::get_explicit_std140_type(bool row_major) const } } -unsigned -glsl_type::std430_base_alignment(bool row_major) const +extern "C" unsigned +glsl_get_std430_base_alignment(const struct glsl_type *t, bool row_major) { - unsigned N = is_64bit() ? 8 : 4; + unsigned N = t->is_64bit() ? 8 : 4; /* (1) If the member is a scalar consuming basic machine units, the * base alignment is . @@ -2309,8 +2309,8 @@ glsl_type::std430_base_alignment(bool row_major) const * (3) If the member is a three-component vector with components consuming * basic machine units, the base alignment is 4. */ - if (this->is_scalar() || this->is_vector()) { - switch (this->vector_elements) { + if (t->is_scalar() || t->is_vector()) { + switch (t->vector_elements) { case 1: return N; case 2: @@ -2340,8 +2340,8 @@ glsl_type::std430_base_alignment(bool row_major) const * (3) If the member is a three-component vector with components consuming * basic machine units, the base alignment is 4. */ - if (this->is_array()) - return this->fields.array->std430_base_alignment(row_major); + if (t->is_array()) + return t->fields.array->std430_base_alignment(row_major); /* (5) If the member is a column-major matrix with columns and * rows, the matrix is stored identically to an array of @@ -2352,16 +2352,16 @@ glsl_type::std430_base_alignment(bool row_major) const * rows, the matrix is stored identically to an array of * row vectors with components each, according to rule (4). */ - if (this->is_matrix()) { + if (t->is_matrix()) { const struct glsl_type *vec_type, *array_type; - int c = this->matrix_columns; - int r = this->vector_elements; + int c = t->matrix_columns; + int r = t->vector_elements; if (row_major) { - vec_type = get_instance(base_type, c, 1); + vec_type = glsl_type::get_instance(t->base_type, c, 1); array_type = glsl_type::get_array_instance(vec_type, r); } else { - vec_type = get_instance(base_type, r, 1); + vec_type = glsl_type::get_instance(t->base_type, r, 1); array_type = glsl_type::get_array_instance(vec_type, c); } @@ -2380,19 +2380,19 @@ glsl_type::std430_base_alignment(bool row_major) const * rounded up to the next multiple of the base alignment of the * structure. */ - if (this->is_struct()) { + if (t->is_struct()) { unsigned base_alignment = 0; - for (unsigned i = 0; i < this->length; i++) { + for (unsigned i = 0; i < t->length; i++) { bool field_row_major = row_major; const enum glsl_matrix_layout matrix_layout = - (enum glsl_matrix_layout)this->fields.structure[i].matrix_layout; + (enum glsl_matrix_layout)t->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; + const struct glsl_type *field_type = t->fields.structure[i].type; base_alignment = MAX2(base_alignment, field_type->std430_base_alignment(field_row_major)); } @@ -2428,17 +2428,17 @@ glsl_type::std430_array_stride(bool row_major) const * Should not be used with GLSL shaders. */ -unsigned -glsl_type::explicit_size(bool align_to_stride) const +extern "C" unsigned +glsl_get_explicit_size(const struct glsl_type *t, bool align_to_stride) { - if (this->is_struct() || this->is_interface()) { - if (this->length > 0) { + if (t->is_struct() || t->is_interface()) { + if (t->length > 0) { unsigned size = 0; - for (unsigned i = 0; i < this->length; i++) { - assert(this->fields.structure[i].offset >= 0); - unsigned last_byte = this->fields.structure[i].offset + - this->fields.structure[i].type->explicit_size(); + for (unsigned i = 0; i < t->length; i++) { + assert(t->fields.structure[i].offset >= 0); + unsigned last_byte = t->fields.structure[i].offset + + t->fields.structure[i].type->explicit_size(); size = MAX2(size, last_byte); } @@ -2446,7 +2446,7 @@ glsl_type::explicit_size(bool align_to_stride) const } else { return 0; } - } else if (this->is_array()) { + } else if (t->is_array()) { /* From ARB_program_interface_query spec: * * "For the property of BUFFER_DATA_SIZE, then the implementation-dependent @@ -2458,43 +2458,43 @@ glsl_type::explicit_size(bool align_to_stride) const * as an array with one element." * */ - if (this->is_unsized_array()) - return this->explicit_stride; + if (t->is_unsized_array()) + return t->explicit_stride; - assert(this->length > 0); - unsigned elem_size = align_to_stride ? this->explicit_stride : this->fields.array->explicit_size(); - assert(this->explicit_stride == 0 || this->explicit_stride >= elem_size); + assert(t->length > 0); + unsigned elem_size = align_to_stride ? t->explicit_stride : t->fields.array->explicit_size(); + assert(t->explicit_stride == 0 || t->explicit_stride >= elem_size); - return this->explicit_stride * (this->length - 1) + elem_size; - } else if (this->is_matrix()) { + return t->explicit_stride * (t->length - 1) + elem_size; + } else if (t->is_matrix()) { const struct glsl_type *elem_type; unsigned length; - if (this->interface_row_major) { - elem_type = get_instance(this->base_type, - this->matrix_columns, 1); - length = this->vector_elements; + if (t->interface_row_major) { + elem_type = glsl_type::get_instance(t->base_type, + t->matrix_columns, 1); + length = t->vector_elements; } else { - elem_type = get_instance(this->base_type, - this->vector_elements, 1); - length = this->matrix_columns; + elem_type = glsl_type::get_instance(t->base_type, + t->vector_elements, 1); + length = t->matrix_columns; } - unsigned elem_size = align_to_stride ? this->explicit_stride : elem_type->explicit_size(); + unsigned elem_size = align_to_stride ? t->explicit_stride : elem_type->explicit_size(); - assert(this->explicit_stride); - return this->explicit_stride * (length - 1) + elem_size; + assert(t->explicit_stride); + return t->explicit_stride * (length - 1) + elem_size; } - unsigned N = this->bit_size() / 8; + unsigned N = t->bit_size() / 8; - return this->vector_elements * N; + return t->vector_elements * N; } -unsigned -glsl_type::std430_size(bool row_major) const +extern "C" unsigned +glsl_get_std430_size(const struct glsl_type *t, bool row_major) { - unsigned N = is_64bit() ? 8 : 4; + unsigned N = t->is_64bit() ? 8 : 4; /* OpenGL 4.30 spec, section 7.6.2.2 "Standard Uniform Block Layout": * @@ -2504,32 +2504,32 @@ glsl_type::std430_size(bool row_major) const * 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()) { - assert(this->explicit_stride == 0); - return this->vector_elements * N; + if (t->is_scalar() || t->is_vector()) { + assert(t->explicit_stride == 0); + return t->vector_elements * N; } - if (this->without_array()->is_matrix()) { + if (t->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(); + if (t->is_array()) { + element_type = t->without_array(); + array_len = t->arrays_of_arrays_size(); } else { - element_type = this; + element_type = t; array_len = 1; } if (row_major) { - vec_type = get_instance(element_type->base_type, - element_type->matrix_columns, 1); + vec_type = glsl_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); + vec_type = glsl_type::get_instance(element_type->base_type, + element_type->vector_elements, 1); array_len *= element_type->matrix_columns; } const struct glsl_type *array_type = @@ -2538,34 +2538,34 @@ glsl_type::std430_size(bool row_major) const return array_type->std430_size(false); } - if (this->is_array()) { + if (t->is_array()) { unsigned stride; - if (this->without_array()->is_struct()) - stride = this->without_array()->std430_size(row_major); + if (t->without_array()->is_struct()) + stride = t->without_array()->std430_size(row_major); else - stride = this->without_array()->std430_base_alignment(row_major); + stride = t->without_array()->std430_base_alignment(row_major); - unsigned size = this->arrays_of_arrays_size() * stride; - assert(this->explicit_stride == 0 || - size == this->length * this->explicit_stride); + unsigned size = t->arrays_of_arrays_size() * stride; + assert(t->explicit_stride == 0 || + size == t->length * t->explicit_stride); return size; } - if (this->is_struct() || this->is_interface()) { + if (t->is_struct() || t->is_interface()) { unsigned size = 0; unsigned max_align = 0; - for (unsigned i = 0; i < this->length; i++) { + for (unsigned i = 0; i < t->length; i++) { bool field_row_major = row_major; const enum glsl_matrix_layout matrix_layout = - (enum glsl_matrix_layout)this->fields.structure[i].matrix_layout; + (enum glsl_matrix_layout)t->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; + const struct glsl_type *field_type = t->fields.structure[i].type; unsigned base_alignment = field_type->std430_base_alignment(field_row_major); size = align(size, base_alignment); size += field_type->std430_size(field_row_major); diff --git a/src/compiler/glsl_types.h b/src/compiler/glsl_types.h index 92b7c43..3610bc6 100644 --- a/src/compiler/glsl_types.h +++ b/src/compiler/glsl_types.h @@ -1508,7 +1508,11 @@ glsl_get_explicit_stride(const struct glsl_type *t) return t->explicit_stride; } -unsigned glsl_get_explicit_alignment(const struct glsl_type *t); +static inline unsigned +glsl_get_explicit_alignment(const struct glsl_type *t) +{ + return t->explicit_alignment; +} void glsl_get_natural_size_align_bytes(const struct glsl_type *t, unsigned *size, unsigned *align); void glsl_get_vec4_size_align_bytes(const struct glsl_type *type, unsigned *size, unsigned *align); diff --git a/src/compiler/glsl_types_impl.h b/src/compiler/glsl_types_impl.h index 882674c..765ebfd 100644 --- a/src/compiler/glsl_types_impl.h +++ b/src/compiler/glsl_types_impl.h @@ -65,6 +65,12 @@ inline unsigned glsl_type::varying_count() const { return glsl_varying_count(thi inline unsigned glsl_type::cl_size() const { return glsl_get_cl_size(this); } inline unsigned glsl_type::cl_alignment() const { return glsl_get_cl_alignment(this); } +inline unsigned glsl_type::std140_base_alignment(bool row_major) const { return glsl_get_std140_base_alignment(this, row_major); } +inline unsigned glsl_type::std140_size(bool row_major) const { return glsl_get_std140_size(this, row_major); } +inline unsigned glsl_type::std430_base_alignment(bool row_major) const { return glsl_get_std430_base_alignment(this, row_major); } +inline unsigned glsl_type::std430_size(bool row_major) const { return glsl_get_std430_size(this, row_major); } +inline unsigned glsl_type::explicit_size(bool align_to_stride) const { return glsl_get_explicit_size(this, align_to_stride); } + inline const glsl_type *glsl_type::get_bare_type() const { return glsl_get_bare_type(this); } inline const glsl_type *glsl_type::vec(unsigned components) { return glsl_vec_type(components); } diff --git a/src/compiler/nir_types.cpp b/src/compiler/nir_types.cpp index dc89855..d972669 100644 --- a/src/compiler/nir_types.cpp +++ b/src/compiler/nir_types.cpp @@ -482,42 +482,6 @@ glsl_type_get_image_count(const struct glsl_type *type) return glsl_type_count(type, GLSL_TYPE_IMAGE); } -unsigned -glsl_get_std140_base_alignment(const struct glsl_type *type, bool row_major) -{ - return type->std140_base_alignment(row_major); -} - -unsigned -glsl_get_std140_size(const struct glsl_type *type, bool row_major) -{ - return type->std140_size(row_major); -} - -unsigned -glsl_get_std430_base_alignment(const struct glsl_type *type, bool row_major) -{ - return type->std430_base_alignment(row_major); -} - -unsigned -glsl_get_std430_size(const struct glsl_type *type, bool row_major) -{ - return type->std430_size(row_major); -} - -unsigned -glsl_get_explicit_size(const struct glsl_type *type, bool align_to_stride) -{ - return type->explicit_size(align_to_stride); -} - -unsigned -glsl_get_explicit_alignment(const struct glsl_type *type) -{ - return type->explicit_alignment; -} - const struct glsl_type * glsl_get_explicit_type_for_size_align(const struct glsl_type *type, glsl_type_size_align_func type_info,