From 90b29e500a3ee0310c4f0df18eda68a2803fb2ac Mon Sep 17 00:00:00 2001 From: Ben Clayton Date: Sat, 17 Sep 2022 01:47:59 +0000 Subject: [PATCH] tint/transform/std140: Correctly handle nested / bare matrices Fixed tint:1673 Fixed tint:1674 Change-Id: Ifa5d2a69131cc1e4679d4d43143f857c7ba46dbd Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/102640 Commit-Queue: Ben Clayton Reviewed-by: David Neto Kokoro: Kokoro --- src/tint/transform/std140.cc | 495 ++++-- src/tint/transform/std140.h | 13 +- src/tint/transform/std140_test.cc | 1391 ++++++++++++++++- src/tint/writer/glsl/generator_impl.cc | 3 +- src/tint/writer/spirv/generator_impl.cc | 3 +- .../dynamic_index_via_ptr.wgsl.expected.glsl | 51 +- ...dynamic_index_via_ptr.wgsl.expected.spvasm | 151 +- .../static_index_via_ptr.wgsl.expected.glsl | 32 +- .../static_index_via_ptr.wgsl.expected.spvasm | 122 +- .../mat2x2/to_builtin.wgsl.expected.glsl | 19 +- .../mat2x2/to_builtin.wgsl.expected.spvasm | 83 +- .../array/mat2x2/to_fn.wgsl.expected.glsl | 31 +- .../array/mat2x2/to_fn.wgsl.expected.spvasm | 161 +- .../mat2x2/to_private.wgsl.expected.glsl | 31 +- .../mat2x2/to_private.wgsl.expected.spvasm | 145 +- .../mat2x2/to_storage.wgsl.expected.glsl | 31 +- .../mat2x2/to_storage.wgsl.expected.spvasm | 143 +- .../mat2x2/to_workgroup.wgsl.expected.glsl | 31 +- .../mat2x2/to_workgroup.wgsl.expected.spvasm | 207 ++- .../dynamic_index_via_ptr.wgsl.expected.glsl | 61 +- ...dynamic_index_via_ptr.wgsl.expected.spvasm | 167 +- .../static_index_via_ptr.wgsl.expected.glsl | 34 +- .../static_index_via_ptr.wgsl.expected.spvasm | 128 +- .../array/mat4x2/to_fn.wgsl.expected.glsl | 33 +- .../array/mat4x2/to_fn.wgsl.expected.spvasm | 167 +- .../mat4x2/to_private.wgsl.expected.glsl | 33 +- .../mat4x2/to_private.wgsl.expected.spvasm | 151 +- .../mat4x2/to_storage.wgsl.expected.glsl | 33 +- .../mat4x2/to_storage.wgsl.expected.spvasm | 149 +- .../mat4x2/to_workgroup.wgsl.expected.glsl | 33 +- .../mat4x2/to_workgroup.wgsl.expected.spvasm | 213 ++- .../dynamic_index_via_ptr.wgsl.expected.glsl | 14 +- ...dynamic_index_via_ptr.wgsl.expected.spvasm | 14 +- .../static_index_via_ptr.wgsl.expected.glsl | 14 +- .../static_index_via_ptr.wgsl.expected.spvasm | 14 +- .../struct/mat2x2/to_fn.wgsl.expected.glsl | 4 +- .../struct/mat2x2/to_fn.wgsl.expected.spvasm | 6 +- .../mat2x2/to_private.wgsl.expected.glsl | 4 +- .../mat2x2/to_private.wgsl.expected.spvasm | 6 +- .../mat2x2/to_storage.wgsl.expected.glsl | 4 +- .../mat2x2/to_storage.wgsl.expected.spvasm | 6 +- .../mat2x2/to_workgroup.wgsl.expected.glsl | 4 +- .../mat2x2/to_workgroup.wgsl.expected.spvasm | 6 +- .../dynamic_index_via_ptr.wgsl.expected.glsl | 14 +- ...dynamic_index_via_ptr.wgsl.expected.spvasm | 14 +- .../static_index_via_ptr.wgsl.expected.glsl | 14 +- .../static_index_via_ptr.wgsl.expected.spvasm | 14 +- .../struct/mat3x2/to_fn.wgsl.expected.glsl | 4 +- .../struct/mat3x2/to_fn.wgsl.expected.spvasm | 6 +- .../mat3x2/to_private.wgsl.expected.glsl | 4 +- .../mat3x2/to_private.wgsl.expected.spvasm | 6 +- .../mat3x2/to_storage.wgsl.expected.glsl | 4 +- .../mat3x2/to_storage.wgsl.expected.spvasm | 6 +- .../mat3x2/to_workgroup.wgsl.expected.glsl | 4 +- .../mat3x2/to_workgroup.wgsl.expected.spvasm | 6 +- .../dynamic_index_via_ptr.wgsl.expected.glsl | 14 +- ...dynamic_index_via_ptr.wgsl.expected.spvasm | 14 +- .../static_index_via_ptr.wgsl.expected.glsl | 14 +- .../static_index_via_ptr.wgsl.expected.spvasm | 14 +- .../struct/mat4x2/to_fn.wgsl.expected.glsl | 4 +- .../struct/mat4x2/to_fn.wgsl.expected.spvasm | 6 +- .../mat4x2/to_private.wgsl.expected.glsl | 4 +- .../mat4x2/to_private.wgsl.expected.spvasm | 6 +- .../mat4x2/to_storage.wgsl.expected.glsl | 4 +- .../mat4x2/to_storage.wgsl.expected.spvasm | 6 +- .../mat4x2/to_workgroup.wgsl.expected.glsl | 4 +- .../mat4x2/to_workgroup.wgsl.expected.spvasm | 6 +- 67 files changed, 3714 insertions(+), 919 deletions(-) diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc index e6f070b255..06b4f5dd36 100644 --- a/src/tint/transform/std140.cc +++ b/src/tint/transform/std140.cc @@ -34,6 +34,14 @@ using namespace tint::number_suffixes; // NOLINT namespace { +/// UniformVariable is used by Std140::State::AccessIndex to indicate the root uniform variable +struct UniformVariable {}; + +/// Inequality operator for UniformVariable +bool operator!=(const UniformVariable&, const UniformVariable&) { + return false; +} + /// DynamicIndex is used by Std140::State::AccessIndex to indicate a runtime-expression index struct DynamicIndex { size_t slot; // The index of the expression in Std140::State::AccessChain::dynamic_indices @@ -48,6 +56,14 @@ bool operator!=(const DynamicIndex& a, const DynamicIndex& b) { namespace tint::utils { +/// Hasher specialization for UniformVariable +template <> +struct Hasher { + /// The hash function for the UniformVariable + /// @return the hash for the given UniformVariable + size_t operator()(const UniformVariable&) const { return 0; } +}; + /// Hasher specialization for DynamicIndex template <> struct Hasher { @@ -69,9 +85,9 @@ struct Std140::State { /// Runs the transform void Run() { - // Begin by creating forked structures for any struct that is used as a uniform buffer, that + // Begin by creating forked types for any type that is used as a uniform buffer, that // either directly or transitively contains a matrix that needs splitting for std140 layout. - ForkStructs(); + ForkTypes(); // Next, replace all the uniform variables to use the forked types. ReplaceUniformVarTypes(); @@ -105,19 +121,43 @@ struct Std140::State { /// @returns true if this transform should be run for the given program /// @param program the program to inspect static bool ShouldRun(const Program* program) { + // Returns true if the type needs to be forked for std140 usage. + auto needs_fork = [&](const sem::Type* ty) { + while (auto* arr = ty->As()) { + ty = arr->ElemType(); + } + if (auto* mat = ty->As()) { + if (MatrixNeedsDecomposing(mat)) { + return true; + } + } + return false; + }; + + // Scan structures for members that need forking for (auto* ty : program->Types()) { if (auto* str = ty->As()) { if (str->UsedAs(ast::StorageClass::kUniform)) { for (auto* member : str->Members()) { - if (auto* mat = member->Type()->As()) { - if (MatrixNeedsDecomposing(mat)) { - return true; - } + if (needs_fork(member->Type())) { + return true; } } } } } + + // Scan uniform variables that have types that need forking + for (auto* decl : program->AST().GlobalVariables()) { + auto* global = program->Sem().Get(decl); + if (global->StorageClass() == ast::StorageClass::kUniform) { + if (needs_fork(global->Type()->UnwrapRef())) { + return true; + } + } + } + + // If we reach here, no uniform variables use a type that needs forking for std140 layout return false; } @@ -127,12 +167,11 @@ struct Std140::State { /// AccessIndex describes a single access in an access chain. /// The access is one of: - /// u32 - a static member index on a struct, static array index, static matrix column - /// index, static vector element index. - /// DynamicIndex - a runtime-expression index on an array, matrix column selection, or vector - /// element index. - /// Swizzle - a static vector swizzle. - using AccessIndex = std::variant; + /// UniformVariable - the root uniform variable. + /// u32 - a static index on a struct, array index, matrix column or vector element. + /// DynamicIndex - a runtime index on an array, matrix column, or vector element. + /// Swizzle - a static vector swizzle. + using AccessIndex = std::variant; /// A vector of AccessIndex. using AccessIndices = utils::Vector; @@ -182,7 +221,19 @@ struct Std140::State { // Map of structure member in ctx.src of a matrix type, to list of decomposed column // members in ctx.dst. utils::Hashmap, 8> - std140_mats; + std140_mat_members; + + /// Describes a matrix that has been forked to a std140-structure holding the decomposed column + /// vectors of the matrix. + struct Std140Matrix { + /// The decomposed structure name (in ctx.dst) + Symbol name; + /// The column vector structure member names (in ctx.dst) + utils::Vector columns; + }; + + // Map of matrix type in ctx.src, to decomposed column structure in ctx.dst. + utils::Hashmap std140_mats; /// AccessChain describes a chain of access expressions to uniform buffer variable. struct AccessChain { @@ -209,11 +260,11 @@ struct Std140::State { /// TODO(crbug.com/tint/1502): This may need adjusting for `f16` matrices. static bool MatrixNeedsDecomposing(const sem::Matrix* mat) { return mat->ColumnStride() == 8; } - /// ForkStructs walks the structures in dependency order, forking structures that are used as - /// uniform buffers which (transitively) use matrices that need std140 decomposition to column - /// vectors. - /// Populates the #std140_mats map and #std140_structs set. - void ForkStructs() { + /// ForkTypes walks the user-declared types in dependency order, forking structures that are + /// used as uniform buffers which (transitively) use matrices that need std140 decomposition to + /// column vectors. Populates the #std140_mat_members map, #std140_structs set and #std140_mats + /// map (via Std140Type()). + void ForkTypes() { // For each module scope declaration... for (auto* global : ctx.src->Sem().Module()->DependencyOrderedDeclarations()) { // Check to see if this is a structure used by a uniform buffer... @@ -229,51 +280,30 @@ struct Std140::State { // Structure member of matrix type needs decomposition. fork_std140 = true; // Replace the member with column vectors. - const auto num_columns = mat->columns(); const auto name_prefix = PrefixForUniqueNames( - str->Declaration(), member->Name(), num_columns); + str->Declaration(), member->Name(), mat->columns()); + // Build a struct member for each column of the matrix - utils::Vector column_members; - for (uint32_t i = 0; i < num_columns; i++) { - utils::Vector attributes; - if ((i == 0) && mat->Align() != member->Align()) { - // The matrix was @align() annotated with a larger alignment - // than the natural alignment for the matrix. This extra padding - // needs to be applied to the first column vector. - attributes.Push(b.MemberAlign(u32(member->Align()))); - } - if ((i == num_columns - 1) && mat->Size() != member->Size()) { - // The matrix was @size() annotated with a larger size than the - // natural size for the matrix. This extra padding needs to be - // applied to the last column vector. - attributes.Push(b.MemberSize( - AInt(member->Size() - - mat->ColumnType()->Size() * (num_columns - 1)))); - } + auto column_members = DecomposedMatrixStructMembers( + mat, name_prefix, member->Align(), member->Size()); - // Build the member - const auto col_name = name_prefix + std::to_string(i); - const auto* col_ty = CreateASTTypeFor(ctx, mat->ColumnType()); - const auto* col_member = - ctx.dst->Member(col_name, col_ty, std::move(attributes)); - // Add the member to the forked structure - members.Push(col_member); - // Record the member for std140_mats - column_members.Push(col_member); + // Add the member to the forked structure + for (auto* column_member : column_members) { + members.Push(column_member); } - std140_mats.Add(member, std::move(column_members)); - continue; - } - } + // Record that this matrix member was replaced with the N column + // members. + std140_mat_members.Add(member, std::move(column_members)); - // Is the member part of a struct that has been forked for std140-layout? - if (auto* std140_ty = Std140Type(member->Type())) { - // Yes - use this type for the forked structure member. + continue; // Next member + } + } else if (auto* std140_ty = Std140Type(member->Type())) { + // Member is of a type that requires forking for std140-layout fork_std140 = true; auto attrs = ctx.Clone(member->Declaration()->attributes); members.Push( b.Member(sym.NameFor(member->Name()), std140_ty, std::move(attrs))); - continue; + continue; // Next member } // Nothing special about this member. @@ -314,6 +344,7 @@ struct Std140::State { if (auto* std140_ty = Std140Type(v->Type()->UnwrapRef())) { ctx.Replace(global->type, std140_ty); std140_uniforms.Add(v); + continue; } } } @@ -355,10 +386,11 @@ struct Std140::State { } } - /// @returns a new, forked std140 AST type for the corresponding non-forked semantic type. If - /// the - /// semantic type is not split for std140-layout, then nullptr is returned. - const ast::Type* Std140Type(const sem::Type* ty) const { + /// @returns a new, forked std140 AST type for the corresponding non-forked semantic type. + /// If the semantic type is not split for std140-layout, then nullptr is returned. + /// @note will construct new std140 structures to hold decomposed matrices, populating + /// #std140_mats. + const ast::Type* Std140Type(const sem::Type* ty) { return Switch( ty, // [&](const sem::Struct* str) -> const ast::Type* { @@ -367,6 +399,24 @@ struct Std140::State { } return nullptr; }, + [&](const sem::Matrix* mat) -> const ast::Type* { + if (MatrixNeedsDecomposing(mat)) { + auto std140_mat = std140_mats.GetOrCreate(mat, [&] { + auto name = b.Symbols().New("mat" + std::to_string(mat->columns()) + "x" + + std::to_string(mat->rows()) + "_" + + ctx.src->FriendlyName(mat->type())); + auto members = + DecomposedMatrixStructMembers(mat, "col", mat->Align(), mat->Size()); + b.Structure(name, members); + return Std140Matrix{ + name, + utils::Transform(members, [&](auto* member) { return member->symbol; }), + }; + }); + return b.ty.type_name(std140_mat.name); + } + return nullptr; + }, [&](const sem::Array* arr) -> const ast::Type* { if (auto* std140 = Std140Type(arr->ElemType())) { utils::Vector attrs; @@ -380,6 +430,46 @@ struct Std140::State { }); } + /// @param mat the matrix to decompose (in ctx.src) + /// @param name_prefix the name prefix to apply to each of the returned column vector members. + /// @param align the alignment in bytes of the matrix. + /// @param size the size in bytes of the matrix. + /// @returns a vector of decomposed matrix column vectors as structure members (in ctx.dst). + utils::Vector DecomposedMatrixStructMembers( + const sem::Matrix* mat, + const std::string& name_prefix, + uint32_t align, + uint32_t size) { + // Replace the member with column vectors. + const auto num_columns = mat->columns(); + // Build a struct member for each column of the matrix + utils::Vector out; + for (uint32_t i = 0; i < num_columns; i++) { + utils::Vector attributes; + if ((i == 0) && mat->Align() != align) { + // The matrix was @align() annotated with a larger alignment + // than the natural alignment for the matrix. This extra padding + // needs to be applied to the first column vector. + attributes.Push(b.MemberAlign(u32(align))); + } + if ((i == num_columns - 1) && mat->Size() != size) { + // The matrix was @size() annotated with a larger size than the + // natural size for the matrix. This extra padding needs to be + // applied to the last column vector. + attributes.Push( + b.MemberSize(AInt(size - mat->ColumnType()->Size() * (num_columns - 1)))); + } + + // Build the member + const auto col_name = name_prefix + std::to_string(i); + const auto* col_ty = CreateASTTypeFor(ctx, mat->ColumnType()); + const auto* col_member = ctx.dst->Member(col_name, col_ty, std::move(attributes)); + // Record the member for std140_mat_members + out.Push(col_member); + } + return out; + } + /// Walks the @p ast_expr, constructing and returning an AccessChain. /// @returns an AccessChain if the expression is an access to a std140-forked uniform buffer, /// otherwise returns a std::nullopt. @@ -406,11 +496,13 @@ struct Std140::State { [&](const sem::VariableUser* user) { if (user->Variable() == access.var) { // Walked all the way to the source variable. We're done traversing. + access.indices.Push(UniformVariable{}); return Action::kStop; } if (user->Variable()->Type()->Is()) { // Found a pointer. As the source variable is a uniform buffer variable, - // this must be a pointer-let. Continue traversing from the let initializer. + // this must be a pointer-let. Continue traversing from the let + // initializer. expr = user->Variable()->Constructor(); return Action::kContinue; } @@ -421,7 +513,7 @@ struct Std140::State { }, [&](const sem::StructMemberAccess* a) { // Is this a std140 decomposed matrix? - if (!access.std140_mat_ty && std140_mats.Contains(a->Member())) { + if (std140_mat_members.Contains(a->Member())) { // Record this on the access. access.std140_mat_idx = access.indices.Length(); access.std140_mat_ty = expr->Type()->UnwrapRef()->As(); @@ -440,6 +532,15 @@ struct Std140::State { access.dynamic_indices.Push(a->Index()); } expr = a->Object(); + + // Is the object a std140 decomposed matrix? + if (auto* mat = expr->Type()->UnwrapRef()->As()) { + if (std140_mats.Contains(mat)) { + // Record this on the access. + access.std140_mat_idx = access.indices.Length(); + access.std140_mat_ty = mat; + } + } return Action::kContinue; }, [&](const sem::Swizzle* s) { @@ -512,8 +613,13 @@ struct Std140::State { ty, // [&](const sem::Struct* str) { return sym.NameFor(str->Name()); }, [&](const sem::Array* arr) { - return "arr_" + std::to_string(arr->Count()) + "_" + ConvertSuffix(arr->ElemType()); + return "arr" + std::to_string(arr->Count()) + "_" + ConvertSuffix(arr->ElemType()); }, + [&](const sem::Matrix* mat) { + return "mat" + std::to_string(mat->columns()) + "x" + std::to_string(mat->rows()) + + "_" + ConvertSuffix(mat->type()); + }, + [&](const sem::F32*) { return "f32"; }, [&](Default) { TINT_ICE(Transform, b.Diagnostics()) << "unhandled type for conversion name: " << ctx.src->FriendlyName(ty); @@ -523,15 +629,15 @@ struct Std140::State { /// Generates and returns an expression that loads the value from a std140 uniform buffer, /// converting the final result to a non-std140 type. - /// @param access the access chain from a uniform buffer to the value to load. - const ast::Expression* LoadWithConvert(const AccessChain& access) { - const ast::Expression* expr = b.Expr(sym.NameFor(access.var->Declaration()->symbol)); - const sem::Type* ty = access.var->Type()->UnwrapRef(); + /// @param chain the access chain from a uniform buffer to the value to load. + const ast::Expression* LoadWithConvert(const AccessChain& chain) { + const ast::Expression* expr = nullptr; + const sem::Type* ty = nullptr; auto dynamic_index = [&](size_t idx) { - return ctx.Clone(access.dynamic_indices[idx]->Declaration()); + return ctx.Clone(chain.dynamic_indices[idx]->Declaration()); }; - for (auto index : access.indices) { - auto [new_expr, new_ty, _] = BuildAccessExpr(expr, ty, index, dynamic_index); + for (size_t i = 0; i < chain.indices.Length(); i++) { + auto [new_expr, new_ty, _] = BuildAccessExpr(expr, ty, chain, i, dynamic_index); expr = new_expr; ty = new_ty; } @@ -559,11 +665,11 @@ struct Std140::State { Switch( ty, // [&](const sem::Struct* str) { - // Convert each of the structure members using either a converter function call, - // or by reassembling a std140 matrix from column vector members. + // Convert each of the structure members using either a converter function + // call, or by reassembling a std140 matrix from column vector members. utils::Vector args; for (auto* member : str->Members()) { - if (auto* col_members = std140_mats.Find(member)) { + if (auto* col_members = std140_mat_members.Find(member)) { // std140 decomposed matrix. Reassemble. auto* mat_ty = CreateASTTypeFor(ctx, member->Type()); auto mat_args = @@ -578,13 +684,28 @@ struct Std140::State { b.MemberAccessor(param, sym.NameFor(member->Name())))); } } - auto* converted = b.Construct(CreateASTTypeFor(ctx, ty), std::move(args)); - stmts.Push(b.Return(converted)); + stmts.Push(b.Return(b.Construct(CreateASTTypeFor(ctx, ty), std::move(args)))); + }, // + [&](const sem::Matrix* mat) { + // Reassemble a std140 matrix from the structure of column vector members. + if (auto std140_mat = std140_mats.Get(mat)) { + utils::Vector args; + // std140 decomposed matrix. Reassemble. + auto* mat_ty = CreateASTTypeFor(ctx, mat); + auto mat_args = utils::Transform(std140_mat->columns, [&](Symbol name) { + return b.MemberAccessor(param, name); + }); + stmts.Push(b.Return(b.Construct(mat_ty, std::move(mat_args)))); + } else { + TINT_ICE(Transform, b.Diagnostics()) + << "failed to find std140 matrix info for: " + << ctx.src->FriendlyName(ty); + } }, // [&](const sem::Array* arr) { - // Converting an array. Create a function var for the converted array, and loop - // over the input elements, converting each and assigning the result to the - // local array. + // Converting an array. Create a function var for the converted array, and + // loop over the input elements, converting each and assigning the result to + // the local array. auto* var = b.Var("arr", CreateASTTypeFor(ctx, ty)); auto* i = b.Var("i", b.ty.u32()); auto* dst_el = b.IndexAccessor(var, i); @@ -646,38 +767,57 @@ struct Std140::State { /// Loads a part of a std140-decomposed matrix from a uniform buffer, inline (without calling a /// helper function). - /// @param access the access chain from the uniform buffer to part of the matrix (column, + /// @param chain the access chain from the uniform buffer to part of the matrix (column, /// column-swizzle, or element). /// @note The matrix column must be statically indexed to use this method. /// @returns the loaded value expression. - const ast::Expression* LoadSubMatrixInline(const AccessChain& access) { - const ast::Expression* expr = b.Expr(ctx.Clone(access.var->Declaration()->symbol)); - const sem::Type* ty = access.var->Type()->UnwrapRef(); + const ast::Expression* LoadSubMatrixInline(const AccessChain& chain) { // Method for generating dynamic index expressions. // As this is inline, we can just clone the expression. auto dynamic_index = [&](size_t idx) { - return ctx.Clone(access.dynamic_indices[idx]->Declaration()); + return ctx.Clone(chain.dynamic_indices[idx]->Declaration()); }; - for (size_t i = 0; i < access.indices.Length(); i++) { - if (i == access.std140_mat_idx) { - // Access is to the std140 decomposed matrix. - // As this is accessing only part of the matrix, we just need to pick the right - // column vector member. - auto mat_member_idx = std::get(access.indices[i]); - auto* mat_member = ty->As()->Members()[mat_member_idx]; - auto mat_columns = *std140_mats.Get(mat_member); - auto column_idx = std::get(access.indices[i + 1]); - expr = b.MemberAccessor(expr, mat_columns[column_idx]->symbol); - ty = mat_member->Type()->As()->ColumnType(); - // We've consumed both the matrix member access and the column access. Increment i. - i++; - } else { - // Access is to something that is not a decomposed matrix. - auto [new_expr, new_ty, _] = - BuildAccessExpr(expr, ty, access.indices[i], dynamic_index); - expr = new_expr; - ty = new_ty; - } + + const ast::Expression* expr = nullptr; + const sem::Type* ty = nullptr; + + // Build the expression up to, but not including the matrix member + auto std140_mat_idx = *chain.std140_mat_idx; + for (size_t i = 0; i < std140_mat_idx; i++) { + auto [new_expr, new_ty, _] = BuildAccessExpr(expr, ty, chain, i, dynamic_index); + expr = new_expr; + ty = new_ty; + } + + // Access is to the std140 decomposed matrix. + // As this is accessing only part of the matrix, we just need to pick the right column + // vector member. + auto column_idx = std::get(chain.indices[std140_mat_idx + 1]); + if (auto* str = tint::As(ty)) { + // Structure member matrix. The columns are decomposed into the structure. + auto mat_member_idx = std::get(chain.indices[std140_mat_idx]); + auto* mat_member = str->Members()[mat_member_idx]; + auto mat_columns = *std140_mat_members.Get(mat_member); + expr = b.MemberAccessor(expr, mat_columns[column_idx]->symbol); + ty = mat_member->Type()->As()->ColumnType(); + } else { + // Non-structure-member matrix. The columns are decomposed into a new, bespoke std140 + // structure. + auto [new_expr, new_ty, _] = + BuildAccessExpr(expr, ty, chain, std140_mat_idx, dynamic_index); + expr = new_expr; + ty = new_ty; + auto* mat = ty->As(); + auto std140_mat = std140_mats.Get(ty->As()); + expr = b.MemberAccessor(expr, std140_mat->columns[column_idx]); + ty = mat->ColumnType(); + } + + // Build any remaining accesses into the column + for (size_t i = std140_mat_idx + 2; i < chain.indices.Length(); i++) { + auto [new_expr, new_ty, _] = BuildAccessExpr(expr, ty, chain, i, dynamic_index); + expr = new_expr; + ty = new_ty; } return expr; } @@ -687,27 +827,27 @@ struct Std140::State { /// access chain. /// The generated function uses a WGSL switch statement to dynamically select the decomposed /// matrix column. - /// @param access the access chain from the uniform buffer to part of the matrix (column, + /// @param chain the access chain from the uniform buffer to part of the matrix (column, /// column-swizzle, or element). /// @note The matrix column must be dynamically indexed to use this method. /// @returns the generated function name. - Symbol BuildLoadPartialMatrixFn(const AccessChain& access) { + Symbol BuildLoadPartialMatrixFn(const AccessChain& chain) { // Build the dynamic index parameters - auto dynamic_index_params = utils::Transform(access.dynamic_indices, [&](auto*, size_t i) { + auto dynamic_index_params = utils::Transform(chain.dynamic_indices, [&](auto*, size_t i) { return b.Param("p" + std::to_string(i), b.ty.u32()); }); // Method for generating dynamic index expressions. // These are passed in as arguments to the function. auto dynamic_index = [&](size_t idx) { return b.Expr(dynamic_index_params[idx]->symbol); }; - // Fetch the access chain indices of the matrix access and the parameter index that holds - // the matrix column index. - auto std140_mat_idx = *access.std140_mat_idx; - auto column_param_idx = std::get(access.indices[std140_mat_idx + 1]).slot; + // Fetch the access chain indices of the matrix access and the parameter index that + // holds the matrix column index. + auto std140_mat_idx = *chain.std140_mat_idx; + auto column_param_idx = std::get(chain.indices[std140_mat_idx + 1]).slot; // Begin building the function name. This is extended with logic in the loop below // (when column_idx == 0). - std::string name = "load_" + sym.NameFor(access.var->Declaration()->symbol); + std::string name = "load"; // The switch cases utils::Vector cases; @@ -716,41 +856,57 @@ struct Std140::State { const sem::Type* ret_ty = nullptr; // Build switch() cases for each column of the matrix - auto num_columns = access.std140_mat_ty->columns(); + auto num_columns = chain.std140_mat_ty->columns(); for (uint32_t column_idx = 0; column_idx < num_columns; column_idx++) { - const ast::Expression* expr = b.Expr(ctx.Clone(access.var->Declaration()->symbol)); - const sem::Type* ty = access.var->Type()->UnwrapRef(); - // Build the expression up to, but not including the matrix member - for (size_t i = 0; i < access.std140_mat_idx; i++) { + const ast::Expression* expr = nullptr; + const sem::Type* ty = nullptr; + + // Build the expression up to, but not including the matrix + for (size_t i = 0; i < std140_mat_idx; i++) { auto [new_expr, new_ty, access_name] = - BuildAccessExpr(expr, ty, access.indices[i], dynamic_index); + BuildAccessExpr(expr, ty, chain, i, dynamic_index); expr = new_expr; ty = new_ty; if (column_idx == 0) { - name = name + "_" + access_name; + name += "_" + access_name; } } - // Get the matrix member that was dynamically accessed. - auto mat_member_idx = std::get(access.indices[std140_mat_idx]); - auto* mat_member = ty->As()->Members()[mat_member_idx]; - auto mat_columns = *std140_mats.Get(mat_member); - if (column_idx == 0) { - name = name + +"_" + sym.NameFor(mat_member->Name()) + "_p" + - std::to_string(column_param_idx); - } - - // Build the expression to the column vector member. - expr = b.MemberAccessor(expr, mat_columns[column_idx]->symbol); - ty = mat_member->Type()->As()->ColumnType(); - // Build the rest of the expression, skipping over the column index. - for (size_t i = std140_mat_idx + 2; i < access.indices.Length(); i++) { - auto [new_expr, new_ty, access_name] = - BuildAccessExpr(expr, ty, access.indices[i], dynamic_index); + if (auto* str = tint::As(ty)) { + // Structure member matrix. The columns are decomposed into the structure. + auto mat_member_idx = std::get(chain.indices[std140_mat_idx]); + auto* mat_member = str->Members()[mat_member_idx]; + if (column_idx == 0) { + name += "_" + sym.NameFor(mat_member->Name()) + "_p" + + std::to_string(column_param_idx); + } + auto mat_columns = *std140_mat_members.Get(mat_member); + expr = b.MemberAccessor(expr, mat_columns[column_idx]->symbol); + ty = mat_member->Type()->As()->ColumnType(); + } else { + // Non-structure-member matrix. The columns are decomposed into a new, bespoke + // std140 structure. + auto [new_expr, new_ty, mat_name] = + BuildAccessExpr(expr, ty, chain, std140_mat_idx, dynamic_index); expr = new_expr; ty = new_ty; if (column_idx == 0) { - name = name + "_" + access_name; + name += "_" + mat_name + "_p" + std::to_string(column_param_idx); + } + auto* mat = ty->As(); + auto std140_mat = std140_mats.Get(ty->As()); + expr = b.MemberAccessor(expr, std140_mat->columns[column_idx]); + ty = mat->ColumnType(); + } + + // Build the rest of the expression, skipping over the column index. + for (size_t i = std140_mat_idx + 2; i < chain.indices.Length(); i++) { + auto [new_expr, new_ty, access_name] = + BuildAccessExpr(expr, ty, chain, i, dynamic_index); + expr = new_expr; + ty = new_ty; + if (column_idx == 0) { + name += "_" + access_name; } } @@ -764,7 +920,8 @@ struct Std140::State { } // Build the default case (required in WGSL). - // This just returns a zero value of the return type, as the index must be out of bounds. + // This just returns a zero value of the return type, as the index must be out of + // bounds. cases.Push(b.DefaultCase(b.Block(b.Return(b.Construct(CreateASTTypeFor(ctx, ret_ty)))))); auto* column_selector = dynamic_index(column_param_idx); @@ -779,30 +936,30 @@ struct Std140::State { /// Generates a function to load a whole std140-decomposed matrix from a uniform buffer. /// The generated function will have a parameter per dynamic (runtime-evaluated) index in the /// access chain. - /// @param access the access chain from the uniform buffer to the whole std140-decomposed + /// @param chain the access chain from the uniform buffer to the whole std140-decomposed /// matrix. /// @returns the generated function name. - Symbol BuildLoadWholeMatrixFn(const AccessChain& access) { + Symbol BuildLoadWholeMatrixFn(const AccessChain& chain) { // Build the dynamic index parameters - auto dynamic_index_params = utils::Transform(access.dynamic_indices, [&](auto*, size_t i) { + auto dynamic_index_params = utils::Transform(chain.dynamic_indices, [&](auto*, size_t i) { return b.Param("p" + std::to_string(i), b.ty.u32()); }); // Method for generating dynamic index expressions. // These are passed in as arguments to the function. auto dynamic_index = [&](size_t idx) { return b.Expr(dynamic_index_params[idx]->symbol); }; - const ast::Expression* expr = b.Expr(ctx.Clone(access.var->Declaration()->symbol)); - std::string name = sym.NameFor(access.var->Declaration()->symbol); - const sem::Type* ty = access.var->Type()->UnwrapRef(); + const ast::Expression* expr = nullptr; + const sem::Type* ty = nullptr; + std::string name = "load"; // Build the expression up to, but not including the matrix member - auto std140_mat_idx = *access.std140_mat_idx; + auto std140_mat_idx = *chain.std140_mat_idx; for (size_t i = 0; i < std140_mat_idx; i++) { auto [new_expr, new_ty, access_name] = - BuildAccessExpr(expr, ty, access.indices[i], dynamic_index); + BuildAccessExpr(expr, ty, chain, i, dynamic_index); expr = new_expr; ty = new_ty; - name = name + "_" + access_name; + name += "_" + access_name; } utils::Vector stmts; @@ -811,25 +968,41 @@ struct Std140::State { auto* let = b.Let("s", b.AddressOf(expr)); stmts.Push(b.Decl(let)); - // Gather the decomposed matrix columns - auto mat_member_idx = std::get(access.indices[std140_mat_idx]); - auto* mat_member = ty->As()->Members()[mat_member_idx]; - auto mat_columns = *std140_mats.Get(mat_member); - auto columns = utils::Transform(mat_columns, [&](auto* column_member) { - return b.MemberAccessor(b.Deref(let), column_member->symbol); - }); + utils::Vector columns; + if (auto* str = tint::As(ty)) { + // Structure member matrix. The columns are decomposed into the structure. + auto mat_member_idx = std::get(chain.indices[std140_mat_idx]); + auto* mat_member = str->Members()[mat_member_idx]; + auto mat_columns = *std140_mat_members.Get(mat_member); + columns = utils::Transform(mat_columns, [&](auto* column_member) { + return b.MemberAccessor(b.Deref(let), column_member->symbol); + }); + ty = mat_member->Type(); + name += "_" + sym.NameFor(mat_member->Name()); + } else { + // Non-structure-member matrix. The columns are decomposed into a new, bespoke + // std140 structure. + auto [new_expr, new_ty, mat_name] = + BuildAccessExpr(expr, ty, chain, std140_mat_idx, dynamic_index); + expr = new_expr; + auto* mat = ty->As(); + auto std140_mat = std140_mats.Get(ty->As()); + columns = utils::Transform(std140_mat->columns, [&](auto column_name) { + return b.MemberAccessor(b.Deref(let), column_name); + }); + ty = mat; + name += "_" + mat_name; + } // Reconstruct the matrix from the columns - expr = b.Construct(CreateASTTypeFor(ctx, access.std140_mat_ty), std::move(columns)); - ty = mat_member->Type(); - name = name + "_" + sym.NameFor(mat_member->Name()); + expr = b.Construct(CreateASTTypeFor(ctx, chain.std140_mat_ty), std::move(columns)); // Have the function return the constructed matrix stmts.Push(b.Return(expr)); // Build the function auto* ret_ty = CreateASTTypeFor(ctx, ty); - auto fn_sym = b.Symbols().New("load_" + name); + auto fn_sym = b.Symbols().New(name); b.Func(fn_sym, std::move(dynamic_index_params), ret_ty, std::move(stmts)); return fn_sym; } @@ -847,14 +1020,24 @@ struct Std140::State { /// Builds a single access in an access chain. /// @param lhs the expression to index using @p access /// @param ty the type of the expression @p lhs - /// @param access the access index to perform on @p lhs + /// @param chain the access index to perform on @p lhs /// @param dynamic_index a function that obtains the i'th dynamic index /// @returns a ExprTypeName which holds the new expression, new type and a name segment which /// can be used for creating helper function names. ExprTypeName BuildAccessExpr(const ast::Expression* lhs, const sem::Type* ty, - AccessIndex access, + const AccessChain& chain, + size_t index, std::function dynamic_index) { + auto& access = chain.indices[index]; + + if (std::get_if(&access)) { + const auto* expr = b.Expr(ctx.Clone(chain.var->Declaration()->symbol)); + const auto name = ctx.src->Symbols().NameFor(chain.var->Declaration()->symbol); + ty = chain.var->Type()->UnwrapRef(); + return {expr, ty, name}; + } + if (auto* dyn_idx = std::get_if(&access)) { /// The access uses a dynamic (runtime-expression) index. auto name = "p" + std::to_string(dyn_idx->slot); diff --git a/src/tint/transform/std140.h b/src/tint/transform/std140.h index f987805fcf..f41b1e34dd 100644 --- a/src/tint/transform/std140.h +++ b/src/tint/transform/std140.h @@ -19,13 +19,12 @@ namespace tint::transform { -/// Std140 is a transform that forks structures used in the uniform storage class that contain -/// `matNx2` matrices into `N`x`vec2` column vectors. Structure types that transitively -/// use these forked structures as members are also forked. `var` variables will use these -/// forked structures, and expressions loading from these variables will do appropriate conversions -/// to the regular WGSL types. As `matNx2` matrices are the only type that violate -/// std140-layout, this transformation is sufficient to have any WGSL structure be std140-layout -/// conformant. +/// Std140 is a transform that forks types used in the uniform storage class that contain +/// `matNx2` matrices into `N`x`vec2` column vectors. Types that transitively use these +/// forked types are also forked. `var` variables will use these forked types, and +/// expressions loading from these variables will do appropriate conversions to the regular WGSL +/// types. As `matNx2` matrices are the only type that violate std140-layout, this +/// transformation is sufficient to have any WGSL structure be std140-layout conformant. /// /// @note This transform requires the PromoteSideEffectsToDecl transform to have been run first. class Std140 final : public Castable { diff --git a/src/tint/transform/std140_test.cc b/src/tint/transform/std140_test.cc index 57e23e6d37..97936ad9fb 100644 --- a/src/tint/transform/std140_test.cc +++ b/src/tint/transform/std140_test.cc @@ -109,7 +109,7 @@ TEST_P(Std140TestShouldRun, ArrayUniform) { src = utils::ReplaceAll(src, "${mat}", GetParam().Mat()); - EXPECT_FALSE(ShouldRun(src)); + EXPECT_EQ(ShouldRun(src), GetParam().should_run); } INSTANTIATE_TEST_SUITE_P(Std140TestShouldRun, @@ -129,7 +129,7 @@ INSTANTIATE_TEST_SUITE_P(Std140TestShouldRun, TEST_F(Std140Test, EmptyModule) { auto* src = R"()"; - auto* expect = R"()"; + auto* expect = src; auto got = Run(src); @@ -1037,7 +1037,7 @@ fn conv_S(val : S_std140) -> S { return S(mat3x2(val.m_0, val.m_1, val.m_2)); } -fn conv_arr_3_S(val : array) -> array { +fn conv_arr3_S(val : array) -> array { var arr : array; for(var i : u32; (i < 3u); i = (i + 1)) { arr[i] = conv_S(val[i]); @@ -1046,7 +1046,7 @@ fn conv_arr_3_S(val : array) -> array { } fn f() { - let l = conv_arr_3_S(a); + let l = conv_arr3_S(a); } )"; @@ -1563,6 +1563,1330 @@ fn f() { EXPECT_EQ(expect, str(got)); } +TEST_F(Std140Test, Mat4x2Uniform_LoadMatrix) { + auto* src = R"( +@group(0) @binding(0) var m : mat4x2; + +fn f() { + let l = m; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var m : mat4x2_f32; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn f() { + let l = conv_mat4x2_f32(m); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat2x2Uniform_LoadColumn0) { + auto* src = R"( +@group(0) @binding(0) var a : mat2x2; + +fn f() { + let l = a[0]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : mat2x2_f32; + +fn f() { + let l = a.col0; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat4x2Uniform_LoadColumn1) { + auto* src = R"( +@group(0) @binding(0) var a : mat4x2; + +fn f() { + let l = a[1]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : mat4x2_f32; + +fn f() { + let l = a.col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat2x2Uniform_LoadColumnI) { + auto* src = R"( +@group(0) @binding(0) var a : mat2x2; + +fn f() { + let I = 1; + + let l = a[I]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : mat2x2_f32; + +fn load_a_p0(p0 : u32) -> vec2 { + switch(p0) { + case 0u: { + return a.col0; + } + case 1u: { + return a.col1; + } + default: { + return vec2(); + } + } +} + +fn f() { + let I = 1; + let l = load_a_p0(u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Swizzle) { + auto* src = R"( +@group(0) @binding(0) var a : mat2x2; + +fn f() { + let l = a[1].yx; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : mat2x2_f32; + +fn f() { + let l = a.col1.yx; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat4x2Uniform_LoadColumnISwizzle) { + auto* src = R"( +@group(0) @binding(0) var a : mat4x2; + +fn f() { + let I = 1; + + let l = a[I].yx; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : mat4x2_f32; + +fn load_a_p0_yx(p0 : u32) -> vec2 { + switch(p0) { + case 0u: { + return a.col0.yx; + } + case 1u: { + return a.col1.yx; + } + case 2u: { + return a.col2.yx; + } + case 3u: { + return a.col3.yx; + } + default: { + return vec2(); + } + } +} + +fn f() { + let I = 1; + let l = load_a_p0_yx(u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Element1) { + auto* src = R"( +@group(0) @binding(0) var a : mat2x2; + +fn f() { + let l = a[1][1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : mat2x2_f32; + +fn f() { + let l = a.col1[1u]; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, Mat4x2Uniform_LoadColumnIElementI) { + auto* src = R"( +@group(0) @binding(0) var a : mat4x2; + +fn f() { + let I = 1; + + let l = a[I][I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : mat4x2_f32; + +fn load_a_p0_p1(p0 : u32, p1 : u32) -> f32 { + switch(p0) { + case 0u: { + return a.col0[p1]; + } + case 1u: { + return a.col1[p1]; + } + case 2u: { + return a.col2[p1]; + } + case 3u: { + return a.col3[p1]; + } + default: { + return f32(); + } + } +} + +fn f() { + let I = 1; + let l = load_a_p0_p1(u32(I), u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat2x2Uniform_LoadArray) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let l = a; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn f() { + let l = conv_arr3_mat2x2_f32(a); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let l = a[0]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn f() { + let l = conv_mat4x2_f32(a[0u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let l = a[1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn f() { + let l = conv_mat2x2_f32(a[1u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrixI) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let I = 1; + let l = a[I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn f() { + let I = 1; + let l = conv_mat4x2_f32(a[I]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1Column0) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let l = a[1][0]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn f() { + let l = a[1u].col0; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0Column1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let l = a[0][1]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn f() { + let l = a[0u].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrixIColumn1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let I = 1; + let l = a[I][1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn f() { + let I = 1; + let l = a[I].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix1ColumnI) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>; + +fn f() { + let I = 1; + let l = a[1][I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array; + +fn load_a_1_p0(p0 : u32) -> vec2 { + switch(p0) { + case 0u: { + return a[1u].col0; + } + case 1u: { + return a[1u].col1; + } + case 2u: { + return a[1u].col2; + } + case 3u: { + return a[1u].col3; + } + default: { + return vec2(); + } + } +} + +fn f() { + let I = 1; + let l = load_a_1_p0(u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrays) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let l = a; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn conv_arr4_arr3_mat2x2_f32(val : array, 4u>) -> array, 3u>, 4u> { + var arr : array, 3u>, 4u>; + for(var i : u32; (i < 4u); i = (i + 1)) { + arr[i] = conv_arr3_mat2x2_f32(val[i]); + } + return arr; +} + +fn f() { + let l = conv_arr4_arr3_mat2x2_f32(a); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadArray0) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let l = a[0]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn conv_arr3_mat4x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + return arr; +} + +fn f() { + let l = conv_arr3_mat4x2_f32(a[0u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArray1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>,4>; + +fn f() { + let l = a[1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn f() { + let l = conv_arr3_mat2x2_f32(a[1u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrayI) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>,4>; + +fn f() { + let I = 1; + let l = a[I]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn f() { + let I = 1; + let l = conv_arr3_mat2x2_f32(a[I]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrix12Column0) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let l = a[1][2][0]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn f() { + let l = a[1u][2u].col0; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix2IColumn1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let I = 1; + let l = a[2][I][1]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn f() { + let I = 1; + let l = a[2u][I].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixI2Column1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let I = 1; + let l = a[I][2][1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn f() { + let I = 1; + let l = a[I][2u].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixIIColumn1) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let I = 1; + let l = a[I][I][1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn f() { + let I = 1; + let l = a[I][I].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix12ColumnI) { + auto* src = R"( +@group(0) @binding(0) var a : array, 3>, 4>; + +fn f() { + let I = 1; + let l = a[1][2][I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +@group(0) @binding(0) var a : array, 4u>; + +fn load_a_1_2_p0(p0 : u32) -> vec2 { + switch(p0) { + case 0u: { + return a[1u][2u].col0; + } + case 1u: { + return a[1u][2u].col1; + } + case 2u: { + return a[1u][2u].col2; + } + case 3u: { + return a[1u][2u].col3; + } + default: { + return vec2(); + } + } +} + +fn f() { + let I = 1; + let l = load_a_1_2_p0(u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadStruct) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn conv_S(val : S_std140) -> S { + return S(conv_arr3_mat2x2_f32(val.a)); +} + +fn f() { + let l = conv_S(s); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadArray) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s.a; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn conv_arr3_mat2x2_f32(val : array) -> array, 3u> { + var arr : array, 3u>; + for(var i : u32; (i < 3u); i = (i + 1)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + return arr; +} + +fn f() { + let l = conv_arr3_mat2x2_f32(s.a); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s.a[0]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn f() { + let l = conv_mat4x2_f32(s.a[0u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s.a[1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2 { + return mat2x2(val.col0, val.col1); +} + +fn f() { + let l = conv_mat2x2_f32(s.a[1u]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrixI) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let I = 1; + let l = s.a[I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2 { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +fn f() { + let I = 1; + let l = conv_mat4x2_f32(s.a[I]); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1Column0) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s.a[1][0]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn f() { + let l = s.a[1u].col0; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0Column1) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let l = s.a[0][1]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn f() { + let l = s.a[0u].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrixIColumn1) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let I = 1; + let l = s.a[I][1]; +} +)"; + + auto* expect = R"( +struct mat2x2_f32 { + col0 : vec2, + col1 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn f() { + let I = 1; + let l = s.a[I].col1; +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + +TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix1ColumnI) { + auto* src = R"( +struct S { + a : array, 3>, +}; + +@group(0) @binding(0) var s : S; + +fn f() { + let I = 1; + let l = s.a[1][I]; +} +)"; + + auto* expect = R"( +struct mat4x2_f32 { + col0 : vec2, + col1 : vec2, + col2 : vec2, + col3 : vec2, +} + +struct S { + a : array, 3>, +} + +struct S_std140 { + a : array, +} + +@group(0) @binding(0) var s : S_std140; + +fn load_s_a_1_p0(p0 : u32) -> vec2 { + switch(p0) { + case 0u: { + return s.a[1u].col0; + } + case 1u: { + return s.a[1u].col1; + } + case 2u: { + return s.a[1u].col2; + } + case 3u: { + return s.a[1u].col3; + } + default: { + return vec2(); + } + } +} + +fn f() { + let I = 1; + let l = load_s_a_1_p0(u32(I)); +} +)"; + + auto got = Run(src); + + EXPECT_EQ(expect, str(got)); +} + TEST_F(Std140Test, ArrayStructArrayStructMat4x2Uniform_Loads) { auto* src = R"( struct Inner { @@ -1614,7 +2938,7 @@ fn conv_Inner(val : Inner_std140) -> Inner { return Inner(mat4x2(val.m_0, val.m_1, val.m_2, val.m_3)); } -fn conv_arr_4_Inner(val : array) -> array { +fn conv_arr4_Inner(val : array) -> array { var arr : array; for(var i : u32; (i < 4u); i = (i + 1)) { arr[i] = conv_Inner(val[i]); @@ -1623,10 +2947,10 @@ fn conv_arr_4_Inner(val : array) -> array { } fn conv_Outer(val : Outer_std140) -> Outer { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -fn conv_arr_4_Outer(val : array) -> array { +fn conv_arr4_Outer(val : array) -> array { var arr : array; for(var i : u32; (i < 4u); i = (i + 1)) { arr[i] = conv_Outer(val[i]); @@ -1641,9 +2965,9 @@ fn load_a_0_a_2_m() -> mat4x2 { fn f() { let I = 1; - let l_a : array = conv_arr_4_Outer(a); + let l_a : array = conv_arr4_Outer(a); let l_a_1 : Outer = conv_Outer(a[1u]); - let l_a_2_a : array = conv_arr_4_Inner(a[2u].a); + let l_a_2_a : array = conv_arr4_Inner(a[2u].a); let l_a_3_a_1 : Inner = conv_Inner(a[3u].a[1u]); let l_a_0_a_2_m : mat4x2 = load_a_0_a_2_m(); let l_a_1_a_3_m_0 : vec2 = a[1u].a[3u].m_0; @@ -1717,7 +3041,7 @@ fn conv_Inner(val : Inner_std140) -> Inner { return Inner(mat4x2(val.m_0, val.m_1, val.m_2, val.m_3)); } -fn conv_arr_4_Inner(val : array) -> array { +fn conv_arr4_Inner(val : array) -> array { var arr : array; for(var i : u32; (i < 4u); i = (i + 1)) { arr[i] = conv_Inner(val[i]); @@ -1726,10 +3050,10 @@ fn conv_arr_4_Inner(val : array) -> array { } fn conv_Outer(val : Outer_std140) -> Outer { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -fn conv_arr_4_Outer(val : array) -> array { +fn conv_arr4_Outer(val : array) -> array { var arr : array; for(var i : u32; (i < 4u); i = (i + 1)) { arr[i] = conv_Outer(val[i]); @@ -1744,15 +3068,15 @@ fn load_a_3_a_2_m() -> mat4x2 { fn f() { let I = 1; - let p_a = conv_arr_4_Outer(a); + let p_a = conv_arr4_Outer(a); let p_a_3 = conv_Outer(a[3u]); - let p_a_3_a = conv_arr_4_Inner(a[3u].a); + let p_a_3_a = conv_arr4_Inner(a[3u].a); let p_a_3_a_2 = conv_Inner(a[3u].a[2u]); let p_a_3_a_2_m = load_a_3_a_2_m(); let p_a_3_a_2_m_1 = a[3u].a[2u].m_1; - let l_a : array = conv_arr_4_Outer(a); + let l_a : array = conv_arr4_Outer(a); let l_a_3 : Outer = conv_Outer(a[3u]); - let l_a_3_a : array = conv_arr_4_Inner(a[3u].a); + let l_a_3_a : array = conv_arr4_Inner(a[3u].a); let l_a_3_a_2 : Inner = conv_Inner(a[3u].a[2u]); let l_a_3_a_2_m : mat4x2 = load_a_3_a_2_m(); let l_a_3_a_2_m_1 : vec2 = a[3u].a[2u].m_1; @@ -1801,7 +3125,7 @@ fn conv_S(val : S_std140) -> S { return S(mat3x2(val.m_0, val.m_1, val.m_2)); } -fn conv_arr_4_S(val : array) -> array { +fn conv_arr4_S(val : array) -> array { var arr : array; for(var i : u32; (i < 4u); i = (i + 1)) { arr[i] = conv_S(val[i]); @@ -1810,7 +3134,7 @@ fn conv_arr_4_S(val : array) -> array { } fn f() { - s = conv_arr_4_S(u); + s = conv_arr4_S(u); } )"; @@ -1827,7 +3151,7 @@ struct S { } @group(0) @binding(0) var u : array; -@group(0) @binding(1) var w : array; +var w : array; fn f() { w[0] = u[1]; @@ -1835,9 +3159,32 @@ fn f() { )"; auto* expect = - R"(test:8:38 error: non-resource variables must not have @group or @binding attributes -@group(0) @binding(1) var w : array; - ^ + R"( +struct S { + v : vec4, + @size(64) + m : mat3x2, +} + +struct S_std140 { + v : vec4, + m_0 : vec2, + m_1 : vec2, + @size(48) + m_2 : vec2, +} + +@group(0) @binding(0) var u : array; + +var w : array; + +fn conv_S(val : S_std140) -> S { + return S(val.v, mat3x2(val.m_0, val.m_1, val.m_2)); +} + +fn f() { + w[0] = conv_S(u[1u]); +} )"; auto got = Run(src); diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc index 5031329dcb..d051981762 100644 --- a/src/tint/writer/glsl/generator_impl.cc +++ b/src/tint/writer/glsl/generator_impl.cc @@ -244,8 +244,7 @@ SanitizedResult Sanitize(const Program* in, manager.Add(); manager.Add(); - // Std140 must come after PromoteSideEffectsToDecl and AddBlockAttribute - // Std140 must come before SimplifyPointers. + // Std140 must come after PromoteSideEffectsToDecl and before SimplifyPointers. manager.Add(); manager.Add(); diff --git a/src/tint/writer/spirv/generator_impl.cc b/src/tint/writer/spirv/generator_impl.cc index 2a2c25c8c1..bf92bf94b4 100644 --- a/src/tint/writer/spirv/generator_impl.cc +++ b/src/tint/writer/spirv/generator_impl.cc @@ -87,7 +87,8 @@ SanitizedResult Sanitize(const Program* in, const Options& options) { manager.Add(); manager.Add(); - // Std140 must come after PromoteSideEffectsToDecl, AddBlockAttribute + // Std140 must come after PromoteSideEffectsToDecl. + // Std140 must come before VarForDynamicIndex and ForLoopToLoop. manager.Add(); // VarForDynamicIndex must come after Std140 diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl index 3b568528d8..265b9461db 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl @@ -1,7 +1,12 @@ #version 310 es -layout(binding = 0, std140) uniform a_block_ubo { - mat2 inner[4]; +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + +layout(binding = 0, std140) uniform a_block_std140_ubo { + mat2x2_f32 inner[4]; } a; int counter = 0; @@ -10,14 +15,46 @@ int i() { return counter; } +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + +vec2 load_a_inner_p0_p1(uint p0, uint p1) { + switch(p1) { + case 0u: { + return a.inner[p0].col0; + break; + } + case 1u: { + return a.inner[p0].col1; + break; + } + default: { + return vec2(0.0f); + break; + } + } +} + void f() { + mat2 p_a[4] = conv_arr4_mat2x2_f32(a.inner); int tint_symbol = i(); - int p_a_i_save = tint_symbol; + mat2 p_a_i = conv_mat2x2_f32(a.inner[tint_symbol]); int tint_symbol_1 = i(); - int p_a_i_i_save = tint_symbol_1; - mat2 l_a[4] = a.inner; - mat2 l_a_i = a.inner[p_a_i_save]; - vec2 l_a_i_i = a.inner[p_a_i_save][p_a_i_i_save]; + vec2 p_a_i_i = load_a_inner_p0_p1(uint(tint_symbol), uint(tint_symbol_1)); + mat2 l_a[4] = conv_arr4_mat2x2_f32(a.inner); + mat2 l_a_i = conv_mat2x2_f32(a.inner[tint_symbol]); + vec2 l_a_i_i = load_a_inner_p0_p1(uint(tint_symbol), uint(tint_symbol_1)); } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm index b9a3ee9897..40ede286ad 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm @@ -1,47 +1,77 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 37 +; Bound: 98 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %a_block "a_block" - OpMemberName %a_block 0 "inner" + OpName %a_block_std140 "a_block_std140" + OpMemberName %a_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %a "a" OpName %counter "counter" OpName %i "i" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i_0 "i" + OpName %var_for_index "var_for_index" + OpName %load_a_inner_p0_p1 "load_a_inner_p0_p1" + OpName %p0 "p0" + OpName %p1 "p1" OpName %f "f" - OpDecorate %a_block Block - OpMemberDecorate %a_block 0 Offset 0 - OpMemberDecorate %a_block 0 ColMajor - OpMemberDecorate %a_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %a_block_std140 Block + OpMemberDecorate %a_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %a NonWritable OpDecorate %a DescriptorSet 0 OpDecorate %a Binding 0 + OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 -%_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %a_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_a_block = OpTypePointer Uniform %a_block - %a = OpVariable %_ptr_Uniform_a_block Uniform +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%a_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_a_block_std140 = OpTypePointer Uniform %a_block_std140 + %a = OpVariable %_ptr_Uniform_a_block_std140 Uniform %int = OpTypeInt 32 1 %11 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int %counter = OpVariable %_ptr_Private_int Private %11 %14 = OpTypeFunction %int %int_1 = OpConstant %int 1 - %void = OpTypeVoid - %21 = OpTypeFunction %void +%mat2v2float = OpTypeMatrix %v2float 2 + %21 = OpTypeFunction %mat2v2float %mat2x2_f32 +%_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 + %29 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 + %36 = OpConstantNull %_arr_mat2v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %39 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %52 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 + %uint_1 = OpConstant %uint 1 + %65 = OpTypeFunction %v2float %uint %uint %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float + %80 = OpConstantNull %v2float + %void = OpTypeVoid + %81 = OpTypeFunction %void +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 %i = OpFunction %int None %14 %16 = OpLabel %17 = OpLoad %int %counter @@ -50,15 +80,82 @@ %20 = OpLoad %int %counter OpReturnValue %20 OpFunctionEnd - %f = OpFunction %void None %21 - %24 = OpLabel - %25 = OpFunctionCall %int %i - %26 = OpFunctionCall %int %i - %29 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %a %uint_0 - %30 = OpLoad %_arr_mat2v2float_uint_4 %29 - %32 = OpAccessChain %_ptr_Uniform_mat2v2float %a %uint_0 %25 - %33 = OpLoad %mat2v2float %32 - %35 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %25 %26 - %36 = OpLoad %v2float %35 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %21 + %val = OpFunctionParameter %mat2x2_f32 + %25 = OpLabel + %26 = OpCompositeExtract %v2float %val 0 + %27 = OpCompositeExtract %v2float %val 1 + %28 = OpCompositeConstruct %mat2v2float %26 %27 + OpReturnValue %28 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %29 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %33 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %36 + %i_0 = OpVariable %_ptr_Function_uint Function %39 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %52 + OpBranch %40 + %40 = OpLabel + OpLoopMerge %41 %42 None + OpBranch %43 + %43 = OpLabel + %45 = OpLoad %uint %i_0 + %46 = OpULessThan %bool %45 %uint_4 + %44 = OpLogicalNot %bool %46 + OpSelectionMerge %48 None + OpBranchConditional %44 %49 %48 + %49 = OpLabel + OpBranch %41 + %48 = OpLabel + OpStore %var_for_index %val_0 + %53 = OpLoad %uint %i_0 + %55 = OpAccessChain %_ptr_Function_mat2v2float %arr %53 + %57 = OpLoad %uint %i_0 + %59 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %57 + %60 = OpLoad %mat2x2_f32 %59 + %56 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %60 + OpStore %55 %56 + OpBranch %42 + %42 = OpLabel + %61 = OpLoad %uint %i_0 + %63 = OpIAdd %uint %61 %uint_1 + OpStore %i_0 %63 + OpBranch %40 + %41 = OpLabel + %64 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %64 + OpFunctionEnd +%load_a_inner_p0_p1 = OpFunction %v2float None %65 + %p0 = OpFunctionParameter %uint + %p1 = OpFunctionParameter %uint + %69 = OpLabel + OpSelectionMerge %70 None + OpSwitch %p1 %71 0 %72 1 %73 + %72 = OpLabel + %76 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_0 + %77 = OpLoad %v2float %76 + OpReturnValue %77 + %73 = OpLabel + %78 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_1 + %79 = OpLoad %v2float %78 + OpReturnValue %79 + %71 = OpLabel + OpReturnValue %80 + %70 = OpLabel + OpReturnValue %80 + OpFunctionEnd + %f = OpFunction %void None %81 + %84 = OpLabel + %85 = OpFunctionCall %int %i + %86 = OpFunctionCall %int %i + %89 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %a %uint_0 + %90 = OpLoad %_arr_mat2x2_f32_uint_4 %89 + %87 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %90 + %93 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %a %uint_0 %85 + %94 = OpLoad %mat2x2_f32 %93 + %91 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %94 + %96 = OpBitcast %uint %85 + %97 = OpBitcast %uint %86 + %95 = OpFunctionCall %v2float %load_a_inner_p0_p1 %96 %97 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.glsl index a3d6e08a3f..19803ada0d 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.glsl @@ -1,13 +1,35 @@ #version 310 es -layout(binding = 0, std140) uniform a_block_ubo { - mat2 inner[4]; +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + +layout(binding = 0, std140) uniform a_block_std140_ubo { + mat2x2_f32 inner[4]; } a; +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + void f() { - mat2 l_a[4] = a.inner; - mat2 l_a_i = a.inner[2]; - vec2 l_a_i_i = a.inner[2][1]; + mat2 p_a[4] = conv_arr4_mat2x2_f32(a.inner); + mat2 p_a_2 = conv_mat2x2_f32(a.inner[2u]); + vec2 p_a_2_1 = a.inner[2u].col1; + mat2 l_a[4] = conv_arr4_mat2x2_f32(a.inner); + mat2 l_a_i = conv_mat2x2_f32(a.inner[2u]); + vec2 l_a_i_i = a.inner[2u].col1; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.spvasm index 0e6ccba35f..1274970a42 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/static_index_via_ptr.wgsl.expected.spvasm @@ -1,49 +1,119 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 27 +; Bound: 71 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %a_block "a_block" - OpMemberName %a_block 0 "inner" + OpName %a_block_std140 "a_block_std140" + OpMemberName %a_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %a "a" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %a_block Block - OpMemberDecorate %a_block 0 Offset 0 - OpMemberDecorate %a_block 0 ColMajor - OpMemberDecorate %a_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %a_block_std140 Block + OpMemberDecorate %a_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %a NonWritable OpDecorate %a DescriptorSet 0 OpDecorate %a Binding 0 + OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%a_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_a_block_std140 = OpTypePointer Uniform %a_block_std140 + %a = OpVariable %_ptr_Uniform_a_block_std140 Uniform +%mat2v2float = OpTypeMatrix %v2float 2 + %10 = OpTypeFunction %mat2v2float %mat2x2_f32 %_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %a_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_a_block = OpTypePointer Uniform %a_block - %a = OpVariable %_ptr_Uniform_a_block Uniform + %18 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 + %25 = OpConstantNull %_arr_mat2v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %28 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %41 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %10 = OpTypeFunction %void + %54 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 - %int = OpTypeInt 32 1 - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %int_1 = OpConstant %int 1 +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float - %f = OpFunction %void None %10 - %13 = OpLabel - %16 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %a %uint_0 - %17 = OpLoad %_arr_mat2v2float_uint_4 %16 - %21 = OpAccessChain %_ptr_Uniform_mat2v2float %a %uint_0 %int_2 - %22 = OpLoad %mat2v2float %21 - %25 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %int_2 %int_1 - %26 = OpLoad %v2float %25 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %10 + %val = OpFunctionParameter %mat2x2_f32 + %14 = OpLabel + %15 = OpCompositeExtract %v2float %val 0 + %16 = OpCompositeExtract %v2float %val 1 + %17 = OpCompositeConstruct %mat2v2float %15 %16 + OpReturnValue %17 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %18 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %22 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %25 + %i = OpVariable %_ptr_Function_uint Function %28 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %41 + OpBranch %29 + %29 = OpLabel + OpLoopMerge %30 %31 None + OpBranch %32 + %32 = OpLabel + %34 = OpLoad %uint %i + %35 = OpULessThan %bool %34 %uint_4 + %33 = OpLogicalNot %bool %35 + OpSelectionMerge %37 None + OpBranchConditional %33 %38 %37 + %38 = OpLabel + OpBranch %30 + %37 = OpLabel + OpStore %var_for_index %val_0 + %42 = OpLoad %uint %i + %44 = OpAccessChain %_ptr_Function_mat2v2float %arr %42 + %46 = OpLoad %uint %i + %48 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %46 + %49 = OpLoad %mat2x2_f32 %48 + %45 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %49 + OpStore %44 %45 + OpBranch %31 + %31 = OpLabel + %50 = OpLoad %uint %i + %52 = OpIAdd %uint %50 %uint_1 + OpStore %i %52 + OpBranch %29 + %30 = OpLabel + %53 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %53 + OpFunctionEnd + %f = OpFunction %void None %54 + %57 = OpLabel + %61 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %a %uint_0 + %62 = OpLoad %_arr_mat2x2_f32_uint_4 %61 + %58 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %62 + %66 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %a %uint_0 %uint_2 + %67 = OpLoad %mat2x2_f32 %66 + %63 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %67 + %69 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %uint_2 %uint_1 + %70 = OpLoad %v2float %69 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.glsl index ffcbc7c88a..2bffe0d376 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.glsl @@ -1,13 +1,22 @@ #version 310 es -layout(binding = 0, std140) uniform u_block_ubo { - mat2 inner[4]; +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat2x2_f32 inner[4]; } u; +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + void f() { - mat2 t = transpose(u.inner[2]); - float l = length(u.inner[0][1].yx); - float a = abs(u.inner[0][1].yx.x); + mat2 t = transpose(conv_mat2x2_f32(u.inner[2u])); + float l = length(u.inner[0u].col1.yx); + float a = abs(u.inner[0u].col1.yx[0u]); } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.spvasm index 399fe032f5..3890b7a639 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_builtin.wgsl.expected.spvasm @@ -1,56 +1,71 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 34 +; Bound: 42 ; Schema: 0 OpCapability Shader - %22 = OpExtInstImport "GLSL.std.450" + %30 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %u "u" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" OpName %f "f" - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 -%_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat2v2float = OpTypeMatrix %v2float 2 + %10 = OpTypeFunction %mat2v2float %mat2x2_f32 %void = OpTypeVoid - %10 = OpTypeFunction %void + %18 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 - %int = OpTypeInt 32 1 - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %23 = OpConstantNull %int - %int_1 = OpConstant %int 1 + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 + %31 = OpConstantNull %uint + %uint_1 = OpConstant %uint 1 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float - %f = OpFunction %void None %10 - %13 = OpLabel - %19 = OpAccessChain %_ptr_Uniform_mat2v2float %u %uint_0 %int_2 - %20 = OpLoad %mat2v2float %19 - %14 = OpTranspose %mat2v2float %20 - %26 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %23 %int_1 - %27 = OpLoad %v2float %26 - %28 = OpVectorShuffle %v2float %27 %27 1 0 - %21 = OpExtInst %float %22 Length %28 - %30 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %23 %int_1 - %31 = OpLoad %v2float %30 - %32 = OpVectorShuffle %v2float %31 %31 1 0 - %33 = OpCompositeExtract %float %32 0 - %29 = OpExtInst %float %22 FAbs %33 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %10 + %val = OpFunctionParameter %mat2x2_f32 + %14 = OpLabel + %15 = OpCompositeExtract %v2float %val 0 + %16 = OpCompositeExtract %v2float %val 1 + %17 = OpCompositeConstruct %mat2v2float %15 %16 + OpReturnValue %17 + OpFunctionEnd + %f = OpFunction %void None %18 + %21 = OpLabel + %27 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %u %uint_0 %uint_2 + %28 = OpLoad %mat2x2_f32 %27 + %23 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %28 + %22 = OpTranspose %mat2v2float %23 + %34 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %31 %uint_1 + %35 = OpLoad %v2float %34 + %36 = OpVectorShuffle %v2float %35 %35 1 0 + %29 = OpExtInst %float %30 Length %36 + %38 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %31 %uint_1 + %39 = OpLoad %v2float %38 + %40 = OpVectorShuffle %v2float %39 %39 1 0 + %41 = OpCompositeExtract %float %40 0 + %37 = OpExtInst %float %30 FAbs %41 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.glsl index bc291fd2ec..ad45982135 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.glsl @@ -1,7 +1,12 @@ #version 310 es -layout(binding = 0, std140) uniform u_block_ubo { - mat2 inner[4]; +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat2x2_f32 inner[4]; } u; void a(mat2 a_1[4]) { @@ -16,11 +21,25 @@ void c(vec2 v) { void d(float f_1) { } +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + void f() { - a(u.inner); - b(u.inner[1]); - c(u.inner[1][0].yx); - d(u.inner[1][0].yx.x); + a(conv_arr4_mat2x2_f32(u.inner)); + b(conv_mat2x2_f32(u.inner[1u])); + c(u.inner[1u].col0.yx); + d(u.inner[1u].col0.yx[0u]); } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.spvasm index 8f407ac12e..cdbf08f92e 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_fn.wgsl.expected.spvasm @@ -1,14 +1,17 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 52 +; Bound: 95 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %u "u" OpName %a "a" OpName %a_1 "a_1" @@ -18,73 +21,139 @@ OpName %v "v" OpName %d "d" OpName %f_1 "f_1" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 -%_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform %void = OpTypeVoid +%mat2v2float = OpTypeMatrix %v2float 2 +%_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 %10 = OpTypeFunction %void %_arr_mat2v2float_uint_4 - %15 = OpTypeFunction %void %mat2v2float - %19 = OpTypeFunction %void %v2float - %23 = OpTypeFunction %void %float - %27 = OpTypeFunction %void + %17 = OpTypeFunction %void %mat2v2float + %21 = OpTypeFunction %void %v2float + %25 = OpTypeFunction %void %float + %29 = OpTypeFunction %mat2v2float %mat2x2_f32 + %36 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 + %42 = OpConstantNull %_arr_mat2v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %45 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %58 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 + %uint_1 = OpConstant %uint 1 + %71 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 - %int = OpTypeInt 32 1 - %int_1 = OpConstant %int 1 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %42 = OpConstantNull %int +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %a = OpFunction %void None %10 %a_1 = OpFunctionParameter %_arr_mat2v2float_uint_4 - %14 = OpLabel + %16 = OpLabel OpReturn OpFunctionEnd - %b = OpFunction %void None %15 + %b = OpFunction %void None %17 %m = OpFunctionParameter %mat2v2float - %18 = OpLabel + %20 = OpLabel OpReturn OpFunctionEnd - %c = OpFunction %void None %19 + %c = OpFunction %void None %21 %v = OpFunctionParameter %v2float - %22 = OpLabel + %24 = OpLabel OpReturn OpFunctionEnd - %d = OpFunction %void None %23 + %d = OpFunction %void None %25 %f_1 = OpFunctionParameter %float - %26 = OpLabel + %28 = OpLabel OpReturn OpFunctionEnd - %f = OpFunction %void None %27 - %29 = OpLabel - %33 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %u %uint_0 - %34 = OpLoad %_arr_mat2v2float_uint_4 %33 - %30 = OpFunctionCall %void %a %34 - %39 = OpAccessChain %_ptr_Uniform_mat2v2float %u %uint_0 %int_1 - %40 = OpLoad %mat2v2float %39 - %35 = OpFunctionCall %void %b %40 - %44 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %int_1 %42 - %45 = OpLoad %v2float %44 - %46 = OpVectorShuffle %v2float %45 %45 1 0 - %41 = OpFunctionCall %void %c %46 - %48 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %int_1 %42 - %49 = OpLoad %v2float %48 - %50 = OpVectorShuffle %v2float %49 %49 1 0 - %51 = OpCompositeExtract %float %50 0 - %47 = OpFunctionCall %void %d %51 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %29 + %val = OpFunctionParameter %mat2x2_f32 + %32 = OpLabel + %33 = OpCompositeExtract %v2float %val 0 + %34 = OpCompositeExtract %v2float %val 1 + %35 = OpCompositeConstruct %mat2v2float %33 %34 + OpReturnValue %35 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %36 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %39 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %42 + %i = OpVariable %_ptr_Function_uint Function %45 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %58 + OpBranch %46 + %46 = OpLabel + OpLoopMerge %47 %48 None + OpBranch %49 + %49 = OpLabel + %51 = OpLoad %uint %i + %52 = OpULessThan %bool %51 %uint_4 + %50 = OpLogicalNot %bool %52 + OpSelectionMerge %54 None + OpBranchConditional %50 %55 %54 + %55 = OpLabel + OpBranch %47 + %54 = OpLabel + OpStore %var_for_index %val_0 + %59 = OpLoad %uint %i + %61 = OpAccessChain %_ptr_Function_mat2v2float %arr %59 + %63 = OpLoad %uint %i + %65 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %63 + %66 = OpLoad %mat2x2_f32 %65 + %62 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %66 + OpStore %61 %62 + OpBranch %48 + %48 = OpLabel + %67 = OpLoad %uint %i + %69 = OpIAdd %uint %67 %uint_1 + OpStore %i %69 + OpBranch %46 + %47 = OpLabel + %70 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %70 + OpFunctionEnd + %f = OpFunction %void None %71 + %73 = OpLabel + %78 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %u %uint_0 + %79 = OpLoad %_arr_mat2x2_f32_uint_4 %78 + %75 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %79 + %74 = OpFunctionCall %void %a %75 + %83 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %u %uint_0 %uint_1 + %84 = OpLoad %mat2x2_f32 %83 + %81 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %84 + %80 = OpFunctionCall %void %b %81 + %87 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %uint_1 %uint_0 + %88 = OpLoad %v2float %87 + %89 = OpVectorShuffle %v2float %88 %88 1 0 + %85 = OpFunctionCall %void %c %89 + %91 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %uint_1 %uint_0 + %92 = OpLoad %v2float %91 + %93 = OpVectorShuffle %v2float %92 %92 1 0 + %94 = OpCompositeExtract %float %93 0 + %90 = OpFunctionCall %void %d %94 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.glsl index 59ec729b82..2118347862 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.glsl @@ -1,21 +1,40 @@ #version 310 es +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + struct S { int before; mat2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat2x2_f32 inner[4]; } u; mat2 p[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + void f() { - p = u.inner; - p[1] = u.inner[2]; - p[1][0] = u.inner[0][1].yx; - p[1][0].x = u.inner[0][1].x; + p = conv_arr4_mat2x2_f32(u.inner); + p[1] = conv_mat2x2_f32(u.inner[2u]); + p[1][0] = u.inner[0u].col1.yx; + p[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.spvasm index 922f2c7fef..c91d661f25 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_private.wgsl.expected.spvasm @@ -1,68 +1,139 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 41 +; Bound: 86 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %u "u" OpName %p "p" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat2v2float = OpTypeMatrix %v2float 2 %_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_Private__arr_mat2v2float_uint_4 = OpTypePointer Private %_arr_mat2v2float_uint_4 - %12 = OpConstantNull %_arr_mat2v2float_uint_4 - %p = OpVariable %_ptr_Private__arr_mat2v2float_uint_4 Private %12 + %14 = OpConstantNull %_arr_mat2v2float_uint_4 + %p = OpVariable %_ptr_Private__arr_mat2v2float_uint_4 Private %14 + %15 = OpTypeFunction %mat2v2float %mat2x2_f32 + %22 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %30 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %43 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %13 = OpTypeFunction %void + %56 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Private_mat2v2float = OpTypePointer Private %mat2v2float - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %29 = OpConstantNull %int + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 + %74 = OpConstantNull %int %_ptr_Private_v2float = OpTypePointer Private %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Private_float = OpTypePointer Private %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %f = OpFunction %void None %13 - %16 = OpLabel - %19 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %u %uint_0 - %20 = OpLoad %_arr_mat2v2float_uint_4 %19 - OpStore %p %20 - %24 = OpAccessChain %_ptr_Private_mat2v2float %p %int_1 - %27 = OpAccessChain %_ptr_Uniform_mat2v2float %u %uint_0 %int_2 - %28 = OpLoad %mat2v2float %27 - OpStore %24 %28 - %31 = OpAccessChain %_ptr_Private_v2float %p %int_1 %29 - %33 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %29 %int_1 - %34 = OpLoad %v2float %33 - %35 = OpVectorShuffle %v2float %34 %34 1 0 - OpStore %31 %35 - %37 = OpAccessChain %_ptr_Private_float %p %int_1 %29 %uint_0 - %39 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %29 %int_1 %uint_0 - %40 = OpLoad %float %39 - OpStore %37 %40 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %15 + %val = OpFunctionParameter %mat2x2_f32 + %18 = OpLabel + %19 = OpCompositeExtract %v2float %val 0 + %20 = OpCompositeExtract %v2float %val 1 + %21 = OpCompositeConstruct %mat2v2float %19 %20 + OpReturnValue %21 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %22 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %25 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %14 + %i = OpVariable %_ptr_Function_uint Function %30 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %43 + OpBranch %31 + %31 = OpLabel + OpLoopMerge %32 %33 None + OpBranch %34 + %34 = OpLabel + %36 = OpLoad %uint %i + %37 = OpULessThan %bool %36 %uint_4 + %35 = OpLogicalNot %bool %37 + OpSelectionMerge %39 None + OpBranchConditional %35 %40 %39 + %40 = OpLabel + OpBranch %32 + %39 = OpLabel + OpStore %var_for_index %val_0 + %44 = OpLoad %uint %i + %46 = OpAccessChain %_ptr_Function_mat2v2float %arr %44 + %48 = OpLoad %uint %i + %50 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %48 + %51 = OpLoad %mat2x2_f32 %50 + %47 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %51 + OpStore %46 %47 + OpBranch %33 + %33 = OpLabel + %52 = OpLoad %uint %i + %54 = OpIAdd %uint %52 %uint_1 + OpStore %i %54 + OpBranch %31 + %32 = OpLabel + %55 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %55 + OpFunctionEnd + %f = OpFunction %void None %56 + %59 = OpLabel + %63 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %u %uint_0 + %64 = OpLoad %_arr_mat2x2_f32_uint_4 %63 + %60 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %64 + OpStore %p %60 + %68 = OpAccessChain %_ptr_Private_mat2v2float %p %int_1 + %72 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %u %uint_0 %uint_2 + %73 = OpLoad %mat2x2_f32 %72 + %69 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %73 + OpStore %68 %69 + %76 = OpAccessChain %_ptr_Private_v2float %p %int_1 %74 + %78 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %30 %uint_1 + %79 = OpLoad %v2float %78 + %80 = OpVectorShuffle %v2float %79 %79 1 0 + OpStore %76 %80 + %82 = OpAccessChain %_ptr_Private_float %p %int_1 %74 %uint_0 + %84 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %30 %uint_1 %30 + %85 = OpLoad %float %84 + OpStore %82 %85 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.glsl index 2a920f8c1f..c6be613678 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.glsl @@ -1,24 +1,43 @@ #version 310 es +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + struct S { int before; mat2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat2x2_f32 inner[4]; } u; layout(binding = 1, std430) buffer u_block_ssbo { mat2 inner[4]; } s; +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + void f() { - s.inner = u.inner; - s.inner[1] = u.inner[2]; - s.inner[1][0] = u.inner[0][1].yx; - s.inner[1][0].x = u.inner[0][1].x; + s.inner = conv_arr4_mat2x2_f32(u.inner); + s.inner[1] = conv_mat2x2_f32(u.inner[2u]); + s.inner[1][0] = u.inner[0u].col1.yx; + s.inner[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.spvasm index 19eba56c8f..1edbc86eba 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_storage.wgsl.expected.spvasm @@ -1,71 +1,150 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 42 +; Bound: 89 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" + OpName %u "u" OpName %u_block "u_block" OpMemberName %u_block 0 "inner" - OpName %u "u" OpName %s "s" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 + OpDecorate %u NonWritable + OpDecorate %u DescriptorSet 0 + OpDecorate %u Binding 0 OpDecorate %u_block Block OpMemberDecorate %u_block 0 Offset 0 OpMemberDecorate %u_block 0 ColMajor OpMemberDecorate %u_block 0 MatrixStride 8 OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 - OpDecorate %u NonWritable - OpDecorate %u DescriptorSet 0 - OpDecorate %u Binding 0 OpDecorate %s DescriptorSet 0 OpDecorate %s Binding 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat2v2float = OpTypeMatrix %v2float 2 %_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 %u_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_StorageBuffer_u_block = OpTypePointer StorageBuffer %u_block %s = OpVariable %_ptr_StorageBuffer_u_block StorageBuffer + %15 = OpTypeFunction %mat2v2float %mat2x2_f32 + %22 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 + %28 = OpConstantNull %_arr_mat2v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %31 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %44 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %12 = OpTypeFunction %void + %57 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer__arr_mat2v2float_uint_4 = OpTypePointer StorageBuffer %_arr_mat2v2float_uint_4 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_mat2v2float = OpTypePointer StorageBuffer %mat2v2float - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %30 = OpConstantNull %int + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 + %77 = OpConstantNull %int %_ptr_StorageBuffer_v2float = OpTypePointer StorageBuffer %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %f = OpFunction %void None %12 - %15 = OpLabel - %18 = OpAccessChain %_ptr_StorageBuffer__arr_mat2v2float_uint_4 %s %uint_0 - %20 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %u %uint_0 - %21 = OpLoad %_arr_mat2v2float_uint_4 %20 - OpStore %18 %21 - %25 = OpAccessChain %_ptr_StorageBuffer_mat2v2float %s %uint_0 %int_1 - %28 = OpAccessChain %_ptr_Uniform_mat2v2float %u %uint_0 %int_2 - %29 = OpLoad %mat2v2float %28 - OpStore %25 %29 - %32 = OpAccessChain %_ptr_StorageBuffer_v2float %s %uint_0 %int_1 %30 - %34 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %30 %int_1 - %35 = OpLoad %v2float %34 - %36 = OpVectorShuffle %v2float %35 %35 1 0 - OpStore %32 %36 - %38 = OpAccessChain %_ptr_StorageBuffer_float %s %uint_0 %int_1 %30 %uint_0 - %40 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %30 %int_1 %uint_0 - %41 = OpLoad %float %40 - OpStore %38 %41 +%conv_mat2x2_f32 = OpFunction %mat2v2float None %15 + %val = OpFunctionParameter %mat2x2_f32 + %18 = OpLabel + %19 = OpCompositeExtract %v2float %val 0 + %20 = OpCompositeExtract %v2float %val 1 + %21 = OpCompositeConstruct %mat2v2float %19 %20 + OpReturnValue %21 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %22 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %25 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %28 + %i = OpVariable %_ptr_Function_uint Function %31 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %44 + OpBranch %32 + %32 = OpLabel + OpLoopMerge %33 %34 None + OpBranch %35 + %35 = OpLabel + %37 = OpLoad %uint %i + %38 = OpULessThan %bool %37 %uint_4 + %36 = OpLogicalNot %bool %38 + OpSelectionMerge %40 None + OpBranchConditional %36 %41 %40 + %41 = OpLabel + OpBranch %33 + %40 = OpLabel + OpStore %var_for_index %val_0 + %45 = OpLoad %uint %i + %47 = OpAccessChain %_ptr_Function_mat2v2float %arr %45 + %49 = OpLoad %uint %i + %51 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %49 + %52 = OpLoad %mat2x2_f32 %51 + %48 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %52 + OpStore %47 %48 + OpBranch %34 + %34 = OpLabel + %53 = OpLoad %uint %i + %55 = OpIAdd %uint %53 %uint_1 + OpStore %i %55 + OpBranch %32 + %33 = OpLabel + %56 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %56 + OpFunctionEnd + %f = OpFunction %void None %57 + %60 = OpLabel + %63 = OpAccessChain %_ptr_StorageBuffer__arr_mat2v2float_uint_4 %s %uint_0 + %66 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %u %uint_0 + %67 = OpLoad %_arr_mat2x2_f32_uint_4 %66 + %64 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %67 + OpStore %63 %64 + %71 = OpAccessChain %_ptr_StorageBuffer_mat2v2float %s %uint_0 %int_1 + %75 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %u %uint_0 %uint_2 + %76 = OpLoad %mat2x2_f32 %75 + %72 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %76 + OpStore %71 %72 + %79 = OpAccessChain %_ptr_StorageBuffer_v2float %s %uint_0 %int_1 %77 + %81 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %31 %uint_1 + %82 = OpLoad %v2float %81 + %83 = OpVectorShuffle %v2float %82 %82 1 0 + OpStore %79 %83 + %85 = OpAccessChain %_ptr_StorageBuffer_float %s %uint_0 %int_1 %77 %uint_0 + %87 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %31 %uint_1 %31 + %88 = OpLoad %float %87 + OpStore %85 %88 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.glsl index 8dcc07dcec..e459ce3dea 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.glsl @@ -1,16 +1,35 @@ #version 310 es +struct mat2x2_f32 { + vec2 col0; + vec2 col1; +}; + struct S { int before; mat2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat2x2_f32 inner[4]; } u; shared mat2 w[4]; +mat2 conv_mat2x2_f32(mat2x2_f32 val) { + return mat2(val.col0, val.col1); +} + +mat2[4] conv_arr4_mat2x2_f32(mat2x2_f32 val[4]) { + mat2 arr[4] = mat2[4](mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f), mat2(0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat2x2_f32(val[i]); + } + } + return arr; +} + void f(uint local_invocation_index) { { for(uint idx = local_invocation_index; (idx < 4u); idx = (idx + 1u)) { @@ -19,10 +38,10 @@ void f(uint local_invocation_index) { } } barrier(); - w = u.inner; - w[1] = u.inner[2]; - w[1][0] = u.inner[0][1].yx; - w[1][0].x = u.inner[0][1].x; + w = conv_arr4_mat2x2_f32(u.inner); + w[1] = conv_mat2x2_f32(u.inner[2u]); + w[1][0] = u.inner[0u].col1.yx; + w[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.spvasm index 495667cecb..e70212f2ce 100644 --- a/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat2x2/to_workgroup.wgsl.expected.spvasm @@ -1,115 +1,182 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 70 +; Bound: 111 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" %local_invocation_index_1 OpExecutionMode %f LocalSize 1 1 1 OpName %local_invocation_index_1 "local_invocation_index_1" - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat2x2_f32 "mat2x2_f32" + OpMemberName %mat2x2_f32 0 "col0" + OpMemberName %mat2x2_f32 1 "col1" OpName %u "u" OpName %w "w" + OpName %conv_mat2x2_f32 "conv_mat2x2_f32" + OpName %val "val" + OpName %conv_arr4_mat2x2_f32 "conv_arr4_mat2x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f_inner "f_inner" OpName %local_invocation_index "local_invocation_index" OpName %idx "idx" OpName %f "f" OpDecorate %local_invocation_index_1 BuiltIn LocalInvocationIndex - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat2x2_f32 0 Offset 0 + OpMemberDecorate %mat2x2_f32 1 Offset 8 + OpDecorate %_arr_mat2x2_f32_uint_4 ArrayStride 16 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat2v2float_uint_4 ArrayStride 16 %uint = OpTypeInt 32 0 %_ptr_Input_uint = OpTypePointer Input %uint %local_invocation_index_1 = OpVariable %_ptr_Input_uint Input %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat2v2float = OpTypeMatrix %v2float 2 + %mat2x2_f32 = OpTypeStruct %v2float %v2float %uint_4 = OpConstant %uint 4 +%_arr_mat2x2_f32_uint_4 = OpTypeArray %mat2x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat2x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat2v2float = OpTypeMatrix %v2float 2 %_arr_mat2v2float_uint_4 = OpTypeArray %mat2v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat2v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_Workgroup__arr_mat2v2float_uint_4 = OpTypePointer Workgroup %_arr_mat2v2float_uint_4 %w = OpVariable %_ptr_Workgroup__arr_mat2v2float_uint_4 Workgroup - %void = OpTypeVoid - %14 = OpTypeFunction %void %uint + %16 = OpTypeFunction %mat2v2float %mat2x2_f32 + %23 = OpTypeFunction %_arr_mat2v2float_uint_4 %_arr_mat2x2_f32_uint_4 +%_ptr_Function__arr_mat2v2float_uint_4 = OpTypePointer Function %_arr_mat2v2float_uint_4 + %29 = OpConstantNull %_arr_mat2v2float_uint_4 %_ptr_Function_uint = OpTypePointer Function %uint - %21 = OpConstantNull %uint + %32 = OpConstantNull %uint %bool = OpTypeBool -%_ptr_Workgroup_mat2v2float = OpTypePointer Workgroup %mat2v2float - %35 = OpConstantNull %mat2v2float +%_ptr_Function__arr_mat2x2_f32_uint_4 = OpTypePointer Function %_arr_mat2x2_f32_uint_4 + %45 = OpConstantNull %_arr_mat2x2_f32_uint_4 +%_ptr_Function_mat2v2float = OpTypePointer Function %mat2v2float +%_ptr_Function_mat2x2_f32 = OpTypePointer Function %mat2x2_f32 %uint_1 = OpConstant %uint 1 + %void = OpTypeVoid + %58 = OpTypeFunction %void %uint +%_ptr_Workgroup_mat2v2float = OpTypePointer Workgroup %mat2v2float + %76 = OpConstantNull %mat2v2float %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat2v2float_uint_4 = OpTypePointer Uniform %_arr_mat2v2float_uint_4 +%_ptr_Uniform__arr_mat2x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat2x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat2v2float = OpTypePointer Uniform %mat2v2float - %53 = OpConstantNull %int +%_ptr_Uniform_mat2x2_f32 = OpTypePointer Uniform %mat2x2_f32 + %94 = OpConstantNull %int %_ptr_Workgroup_v2float = OpTypePointer Workgroup %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %65 = OpTypeFunction %void - %f_inner = OpFunction %void None %14 + %106 = OpTypeFunction %void +%conv_mat2x2_f32 = OpFunction %mat2v2float None %16 + %val = OpFunctionParameter %mat2x2_f32 + %19 = OpLabel + %20 = OpCompositeExtract %v2float %val 0 + %21 = OpCompositeExtract %v2float %val 1 + %22 = OpCompositeConstruct %mat2v2float %20 %21 + OpReturnValue %22 + OpFunctionEnd +%conv_arr4_mat2x2_f32 = OpFunction %_arr_mat2v2float_uint_4 None %23 + %val_0 = OpFunctionParameter %_arr_mat2x2_f32_uint_4 + %26 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat2v2float_uint_4 Function %29 + %i = OpVariable %_ptr_Function_uint Function %32 +%var_for_index = OpVariable %_ptr_Function__arr_mat2x2_f32_uint_4 Function %45 + OpBranch %33 + %33 = OpLabel + OpLoopMerge %34 %35 None + OpBranch %36 + %36 = OpLabel + %38 = OpLoad %uint %i + %39 = OpULessThan %bool %38 %uint_4 + %37 = OpLogicalNot %bool %39 + OpSelectionMerge %41 None + OpBranchConditional %37 %42 %41 + %42 = OpLabel + OpBranch %34 + %41 = OpLabel + OpStore %var_for_index %val_0 + %46 = OpLoad %uint %i + %48 = OpAccessChain %_ptr_Function_mat2v2float %arr %46 + %50 = OpLoad %uint %i + %52 = OpAccessChain %_ptr_Function_mat2x2_f32 %var_for_index %50 + %53 = OpLoad %mat2x2_f32 %52 + %49 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %53 + OpStore %48 %49 + OpBranch %35 + %35 = OpLabel + %54 = OpLoad %uint %i + %56 = OpIAdd %uint %54 %uint_1 + OpStore %i %56 + OpBranch %33 + %34 = OpLabel + %57 = OpLoad %_arr_mat2v2float_uint_4 %arr + OpReturnValue %57 + OpFunctionEnd + %f_inner = OpFunction %void None %58 %local_invocation_index = OpFunctionParameter %uint - %18 = OpLabel - %idx = OpVariable %_ptr_Function_uint Function %21 + %62 = OpLabel + %idx = OpVariable %_ptr_Function_uint Function %32 OpStore %idx %local_invocation_index - OpBranch %22 - %22 = OpLabel - OpLoopMerge %23 %24 None - OpBranch %25 - %25 = OpLabel - %27 = OpLoad %uint %idx - %28 = OpULessThan %bool %27 %uint_4 - %26 = OpLogicalNot %bool %28 - OpSelectionMerge %30 None - OpBranchConditional %26 %31 %30 - %31 = OpLabel - OpBranch %23 - %30 = OpLabel - %32 = OpLoad %uint %idx - %34 = OpAccessChain %_ptr_Workgroup_mat2v2float %w %32 - OpStore %34 %35 - OpBranch %24 - %24 = OpLabel - %36 = OpLoad %uint %idx - %38 = OpIAdd %uint %36 %uint_1 - OpStore %idx %38 - OpBranch %22 - %23 = OpLabel - OpControlBarrier %uint_2 %uint_2 %uint_264 - %44 = OpAccessChain %_ptr_Uniform__arr_mat2v2float_uint_4 %u %uint_0 - %45 = OpLoad %_arr_mat2v2float_uint_4 %44 - OpStore %w %45 - %48 = OpAccessChain %_ptr_Workgroup_mat2v2float %w %int_1 - %51 = OpAccessChain %_ptr_Uniform_mat2v2float %u %uint_0 %int_2 - %52 = OpLoad %mat2v2float %51 - OpStore %48 %52 - %55 = OpAccessChain %_ptr_Workgroup_v2float %w %int_1 %53 - %57 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %53 %int_1 - %58 = OpLoad %v2float %57 - %59 = OpVectorShuffle %v2float %58 %58 1 0 - OpStore %55 %59 - %61 = OpAccessChain %_ptr_Workgroup_float %w %int_1 %53 %uint_0 - %63 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %53 %int_1 %uint_0 - %64 = OpLoad %float %63 - OpStore %61 %64 - OpReturn - OpFunctionEnd - %f = OpFunction %void None %65 + OpBranch %64 + %64 = OpLabel + OpLoopMerge %65 %66 None + OpBranch %67 %67 = OpLabel - %69 = OpLoad %uint %local_invocation_index_1 - %68 = OpFunctionCall %void %f_inner %69 + %69 = OpLoad %uint %idx + %70 = OpULessThan %bool %69 %uint_4 + %68 = OpLogicalNot %bool %70 + OpSelectionMerge %71 None + OpBranchConditional %68 %72 %71 + %72 = OpLabel + OpBranch %65 + %71 = OpLabel + %73 = OpLoad %uint %idx + %75 = OpAccessChain %_ptr_Workgroup_mat2v2float %w %73 + OpStore %75 %76 + OpBranch %66 + %66 = OpLabel + %77 = OpLoad %uint %idx + %78 = OpIAdd %uint %77 %uint_1 + OpStore %idx %78 + OpBranch %64 + %65 = OpLabel + OpControlBarrier %uint_2 %uint_2 %uint_264 + %85 = OpAccessChain %_ptr_Uniform__arr_mat2x2_f32_uint_4 %u %uint_0 + %86 = OpLoad %_arr_mat2x2_f32_uint_4 %85 + %82 = OpFunctionCall %_arr_mat2v2float_uint_4 %conv_arr4_mat2x2_f32 %86 + OpStore %w %82 + %89 = OpAccessChain %_ptr_Workgroup_mat2v2float %w %int_1 + %92 = OpAccessChain %_ptr_Uniform_mat2x2_f32 %u %uint_0 %uint_2 + %93 = OpLoad %mat2x2_f32 %92 + %90 = OpFunctionCall %mat2v2float %conv_mat2x2_f32 %93 + OpStore %89 %90 + %96 = OpAccessChain %_ptr_Workgroup_v2float %w %int_1 %94 + %98 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %32 %uint_1 + %99 = OpLoad %v2float %98 + %100 = OpVectorShuffle %v2float %99 %99 1 0 + OpStore %96 %100 + %102 = OpAccessChain %_ptr_Workgroup_float %w %int_1 %94 %uint_0 + %104 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %32 %uint_1 %32 + %105 = OpLoad %float %104 + OpStore %102 %105 + OpReturn + OpFunctionEnd + %f = OpFunction %void None %106 + %108 = OpLabel + %110 = OpLoad %uint %local_invocation_index_1 + %109 = OpFunctionCall %void %f_inner %110 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl index a71a1431e5..991d47876c 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl @@ -1,7 +1,14 @@ #version 310 es -layout(binding = 0, std140) uniform a_block_ubo { - mat4x2 inner[4]; +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + +layout(binding = 0, std140) uniform a_block_std140_ubo { + mat4x2_f32 inner[4]; } a; int counter = 0; @@ -10,14 +17,54 @@ int i() { return counter; } +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + +vec2 load_a_inner_p0_p1(uint p0, uint p1) { + switch(p1) { + case 0u: { + return a.inner[p0].col0; + break; + } + case 1u: { + return a.inner[p0].col1; + break; + } + case 2u: { + return a.inner[p0].col2; + break; + } + case 3u: { + return a.inner[p0].col3; + break; + } + default: { + return vec2(0.0f); + break; + } + } +} + void f() { + mat4x2 p_a[4] = conv_arr4_mat4x2_f32(a.inner); int tint_symbol = i(); - int p_a_i_save = tint_symbol; + mat4x2 p_a_i = conv_mat4x2_f32(a.inner[tint_symbol]); int tint_symbol_1 = i(); - int p_a_i_i_save = tint_symbol_1; - mat4x2 l_a[4] = a.inner; - mat4x2 l_a_i = a.inner[p_a_i_save]; - vec2 l_a_i_i = a.inner[p_a_i_save][p_a_i_i_save]; + vec2 p_a_i_i = load_a_inner_p0_p1(uint(tint_symbol), uint(tint_symbol_1)); + mat4x2 l_a[4] = conv_arr4_mat4x2_f32(a.inner); + mat4x2 l_a_i = conv_mat4x2_f32(a.inner[tint_symbol]); + vec2 l_a_i_i = load_a_inner_p0_p1(uint(tint_symbol), uint(tint_symbol_1)); } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm index 11457bda51..40c95acd8a 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm @@ -1,47 +1,83 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 37 +; Bound: 108 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %a_block "a_block" - OpMemberName %a_block 0 "inner" + OpName %a_block_std140 "a_block_std140" + OpMemberName %a_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" OpName %a "a" OpName %counter "counter" OpName %i "i" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i_0 "i" + OpName %var_for_index "var_for_index" + OpName %load_a_inner_p0_p1 "load_a_inner_p0_p1" + OpName %p0 "p0" + OpName %p1 "p1" OpName %f "f" - OpDecorate %a_block Block - OpMemberDecorate %a_block 0 Offset 0 - OpMemberDecorate %a_block 0 ColMajor - OpMemberDecorate %a_block 0 MatrixStride 8 - OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 + OpDecorate %a_block_std140 Block + OpMemberDecorate %a_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 OpDecorate %a NonWritable OpDecorate %a DescriptorSet 0 OpDecorate %a Binding 0 + OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 -%_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 - %a_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_a_block = OpTypePointer Uniform %a_block - %a = OpVariable %_ptr_Uniform_a_block Uniform +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%a_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_a_block_std140 = OpTypePointer Uniform %a_block_std140 + %a = OpVariable %_ptr_Uniform_a_block_std140 Uniform %int = OpTypeInt 32 1 %11 = OpConstantNull %int %_ptr_Private_int = OpTypePointer Private %int %counter = OpVariable %_ptr_Private_int Private %11 %14 = OpTypeFunction %int %int_1 = OpConstant %int 1 - %void = OpTypeVoid - %21 = OpTypeFunction %void +%mat4v2float = OpTypeMatrix %v2float 4 + %21 = OpTypeFunction %mat4v2float %mat4x2_f32 +%_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 + %31 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 + %38 = OpConstantNull %_arr_mat4v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %41 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %54 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 + %uint_1 = OpConstant %uint 1 + %67 = OpTypeFunction %v2float %uint %uint %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float + %uint_2 = OpConstant %uint 2 + %uint_3 = OpConstant %uint 3 + %90 = OpConstantNull %v2float + %void = OpTypeVoid + %91 = OpTypeFunction %void +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 %i = OpFunction %int None %14 %16 = OpLabel %17 = OpLoad %int %counter @@ -50,15 +86,92 @@ %20 = OpLoad %int %counter OpReturnValue %20 OpFunctionEnd - %f = OpFunction %void None %21 - %24 = OpLabel - %25 = OpFunctionCall %int %i - %26 = OpFunctionCall %int %i - %29 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %a %uint_0 - %30 = OpLoad %_arr_mat4v2float_uint_4 %29 - %32 = OpAccessChain %_ptr_Uniform_mat4v2float %a %uint_0 %25 - %33 = OpLoad %mat4v2float %32 - %35 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %25 %26 - %36 = OpLoad %v2float %35 +%conv_mat4x2_f32 = OpFunction %mat4v2float None %21 + %val = OpFunctionParameter %mat4x2_f32 + %25 = OpLabel + %26 = OpCompositeExtract %v2float %val 0 + %27 = OpCompositeExtract %v2float %val 1 + %28 = OpCompositeExtract %v2float %val 2 + %29 = OpCompositeExtract %v2float %val 3 + %30 = OpCompositeConstruct %mat4v2float %26 %27 %28 %29 + OpReturnValue %30 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %31 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %35 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %38 + %i_0 = OpVariable %_ptr_Function_uint Function %41 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %54 + OpBranch %42 + %42 = OpLabel + OpLoopMerge %43 %44 None + OpBranch %45 + %45 = OpLabel + %47 = OpLoad %uint %i_0 + %48 = OpULessThan %bool %47 %uint_4 + %46 = OpLogicalNot %bool %48 + OpSelectionMerge %50 None + OpBranchConditional %46 %51 %50 + %51 = OpLabel + OpBranch %43 + %50 = OpLabel + OpStore %var_for_index %val_0 + %55 = OpLoad %uint %i_0 + %57 = OpAccessChain %_ptr_Function_mat4v2float %arr %55 + %59 = OpLoad %uint %i_0 + %61 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %59 + %62 = OpLoad %mat4x2_f32 %61 + %58 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %62 + OpStore %57 %58 + OpBranch %44 + %44 = OpLabel + %63 = OpLoad %uint %i_0 + %65 = OpIAdd %uint %63 %uint_1 + OpStore %i_0 %65 + OpBranch %42 + %43 = OpLabel + %66 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %66 + OpFunctionEnd +%load_a_inner_p0_p1 = OpFunction %v2float None %67 + %p0 = OpFunctionParameter %uint + %p1 = OpFunctionParameter %uint + %71 = OpLabel + OpSelectionMerge %72 None + OpSwitch %p1 %73 0 %74 1 %75 2 %76 3 %77 + %74 = OpLabel + %80 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_0 + %81 = OpLoad %v2float %80 + OpReturnValue %81 + %75 = OpLabel + %82 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_1 + %83 = OpLoad %v2float %82 + OpReturnValue %83 + %76 = OpLabel + %85 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_2 + %86 = OpLoad %v2float %85 + OpReturnValue %86 + %77 = OpLabel + %88 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %p0 %uint_3 + %89 = OpLoad %v2float %88 + OpReturnValue %89 + %73 = OpLabel + OpReturnValue %90 + %72 = OpLabel + OpReturnValue %90 + OpFunctionEnd + %f = OpFunction %void None %91 + %94 = OpLabel + %95 = OpFunctionCall %int %i + %96 = OpFunctionCall %int %i + %99 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %a %uint_0 + %100 = OpLoad %_arr_mat4x2_f32_uint_4 %99 + %97 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %100 + %103 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %a %uint_0 %95 + %104 = OpLoad %mat4x2_f32 %103 + %101 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %104 + %106 = OpBitcast %uint %95 + %107 = OpBitcast %uint %96 + %105 = OpFunctionCall %v2float %load_a_inner_p0_p1 %106 %107 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.glsl index ef740a1748..bd894deac0 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.glsl @@ -1,13 +1,37 @@ #version 310 es -layout(binding = 0, std140) uniform a_block_ubo { - mat4x2 inner[4]; +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + +layout(binding = 0, std140) uniform a_block_std140_ubo { + mat4x2_f32 inner[4]; } a; +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + void f() { - mat4x2 l_a[4] = a.inner; - mat4x2 l_a_i = a.inner[2]; - vec2 l_a_i_i = a.inner[2][1]; + mat4x2 p_a[4] = conv_arr4_mat4x2_f32(a.inner); + mat4x2 p_a_2 = conv_mat4x2_f32(a.inner[2u]); + vec2 p_a_2_1 = a.inner[2u].col1; + mat4x2 l_a[4] = conv_arr4_mat4x2_f32(a.inner); + mat4x2 l_a_i = conv_mat4x2_f32(a.inner[2u]); + vec2 l_a_i_i = a.inner[2u].col1; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.spvasm index d69110ba33..844eddbc5c 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/static_index_via_ptr.wgsl.expected.spvasm @@ -1,49 +1,125 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 27 +; Bound: 73 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %a_block "a_block" - OpMemberName %a_block 0 "inner" + OpName %a_block_std140 "a_block_std140" + OpMemberName %a_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" OpName %a "a" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %a_block Block - OpMemberDecorate %a_block 0 Offset 0 - OpMemberDecorate %a_block 0 ColMajor - OpMemberDecorate %a_block 0 MatrixStride 8 - OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 + OpDecorate %a_block_std140 Block + OpMemberDecorate %a_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 OpDecorate %a NonWritable OpDecorate %a DescriptorSet 0 OpDecorate %a Binding 0 + OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%a_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_a_block_std140 = OpTypePointer Uniform %a_block_std140 + %a = OpVariable %_ptr_Uniform_a_block_std140 Uniform +%mat4v2float = OpTypeMatrix %v2float 4 + %10 = OpTypeFunction %mat4v2float %mat4x2_f32 %_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 - %a_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_a_block = OpTypePointer Uniform %a_block - %a = OpVariable %_ptr_Uniform_a_block Uniform + %20 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 + %27 = OpConstantNull %_arr_mat4v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %30 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %43 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %10 = OpTypeFunction %void + %56 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 - %int = OpTypeInt 32 1 - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float - %int_1 = OpConstant %int 1 +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float - %f = OpFunction %void None %10 - %13 = OpLabel - %16 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %a %uint_0 - %17 = OpLoad %_arr_mat4v2float_uint_4 %16 - %21 = OpAccessChain %_ptr_Uniform_mat4v2float %a %uint_0 %int_2 - %22 = OpLoad %mat4v2float %21 - %25 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %int_2 %int_1 - %26 = OpLoad %v2float %25 +%conv_mat4x2_f32 = OpFunction %mat4v2float None %10 + %val = OpFunctionParameter %mat4x2_f32 + %14 = OpLabel + %15 = OpCompositeExtract %v2float %val 0 + %16 = OpCompositeExtract %v2float %val 1 + %17 = OpCompositeExtract %v2float %val 2 + %18 = OpCompositeExtract %v2float %val 3 + %19 = OpCompositeConstruct %mat4v2float %15 %16 %17 %18 + OpReturnValue %19 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %20 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %24 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %27 + %i = OpVariable %_ptr_Function_uint Function %30 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %43 + OpBranch %31 + %31 = OpLabel + OpLoopMerge %32 %33 None + OpBranch %34 + %34 = OpLabel + %36 = OpLoad %uint %i + %37 = OpULessThan %bool %36 %uint_4 + %35 = OpLogicalNot %bool %37 + OpSelectionMerge %39 None + OpBranchConditional %35 %40 %39 + %40 = OpLabel + OpBranch %32 + %39 = OpLabel + OpStore %var_for_index %val_0 + %44 = OpLoad %uint %i + %46 = OpAccessChain %_ptr_Function_mat4v2float %arr %44 + %48 = OpLoad %uint %i + %50 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %48 + %51 = OpLoad %mat4x2_f32 %50 + %47 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %51 + OpStore %46 %47 + OpBranch %33 + %33 = OpLabel + %52 = OpLoad %uint %i + %54 = OpIAdd %uint %52 %uint_1 + OpStore %i %54 + OpBranch %31 + %32 = OpLabel + %55 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %55 + OpFunctionEnd + %f = OpFunction %void None %56 + %59 = OpLabel + %63 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %a %uint_0 + %64 = OpLoad %_arr_mat4x2_f32_uint_4 %63 + %60 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %64 + %68 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %a %uint_0 %uint_2 + %69 = OpLoad %mat4x2_f32 %68 + %65 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %69 + %71 = OpAccessChain %_ptr_Uniform_v2float %a %uint_0 %uint_2 %uint_1 + %72 = OpLoad %v2float %71 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.glsl index 850d58623c..7097f20310 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.glsl @@ -1,7 +1,14 @@ #version 310 es -layout(binding = 0, std140) uniform u_block_ubo { - mat4x2 inner[4]; +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat4x2_f32 inner[4]; } u; void a(mat4x2 a_1[4]) { @@ -16,11 +23,25 @@ void c(vec2 v) { void d(float f_1) { } +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + void f() { - a(u.inner); - b(u.inner[1]); - c(u.inner[1][0].yx); - d(u.inner[1][0].yx.x); + a(conv_arr4_mat4x2_f32(u.inner)); + b(conv_mat4x2_f32(u.inner[1u])); + c(u.inner[1u].col0.yx); + d(u.inner[1u].col0.yx[0u]); } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.spvasm index 8ee216d514..17a9c662c4 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_fn.wgsl.expected.spvasm @@ -1,14 +1,19 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 52 +; Bound: 97 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" OpName %u "u" OpName %a "a" OpName %a_1 "a_1" @@ -18,73 +23,143 @@ OpName %v "v" OpName %d "d" OpName %f_1 "f_1" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 -%_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform %void = OpTypeVoid +%mat4v2float = OpTypeMatrix %v2float 4 +%_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 %10 = OpTypeFunction %void %_arr_mat4v2float_uint_4 - %15 = OpTypeFunction %void %mat4v2float - %19 = OpTypeFunction %void %v2float - %23 = OpTypeFunction %void %float - %27 = OpTypeFunction %void + %17 = OpTypeFunction %void %mat4v2float + %21 = OpTypeFunction %void %v2float + %25 = OpTypeFunction %void %float + %29 = OpTypeFunction %mat4v2float %mat4x2_f32 + %38 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 + %44 = OpConstantNull %_arr_mat4v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %47 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %60 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 + %uint_1 = OpConstant %uint 1 + %73 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 - %int = OpTypeInt 32 1 - %int_1 = OpConstant %int 1 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float - %42 = OpConstantNull %int +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %a = OpFunction %void None %10 %a_1 = OpFunctionParameter %_arr_mat4v2float_uint_4 - %14 = OpLabel + %16 = OpLabel OpReturn OpFunctionEnd - %b = OpFunction %void None %15 + %b = OpFunction %void None %17 %m = OpFunctionParameter %mat4v2float - %18 = OpLabel + %20 = OpLabel OpReturn OpFunctionEnd - %c = OpFunction %void None %19 + %c = OpFunction %void None %21 %v = OpFunctionParameter %v2float - %22 = OpLabel + %24 = OpLabel OpReturn OpFunctionEnd - %d = OpFunction %void None %23 + %d = OpFunction %void None %25 %f_1 = OpFunctionParameter %float - %26 = OpLabel + %28 = OpLabel OpReturn OpFunctionEnd - %f = OpFunction %void None %27 - %29 = OpLabel - %33 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %u %uint_0 - %34 = OpLoad %_arr_mat4v2float_uint_4 %33 - %30 = OpFunctionCall %void %a %34 - %39 = OpAccessChain %_ptr_Uniform_mat4v2float %u %uint_0 %int_1 - %40 = OpLoad %mat4v2float %39 - %35 = OpFunctionCall %void %b %40 - %44 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %int_1 %42 - %45 = OpLoad %v2float %44 - %46 = OpVectorShuffle %v2float %45 %45 1 0 - %41 = OpFunctionCall %void %c %46 - %48 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %int_1 %42 - %49 = OpLoad %v2float %48 - %50 = OpVectorShuffle %v2float %49 %49 1 0 - %51 = OpCompositeExtract %float %50 0 - %47 = OpFunctionCall %void %d %51 +%conv_mat4x2_f32 = OpFunction %mat4v2float None %29 + %val = OpFunctionParameter %mat4x2_f32 + %32 = OpLabel + %33 = OpCompositeExtract %v2float %val 0 + %34 = OpCompositeExtract %v2float %val 1 + %35 = OpCompositeExtract %v2float %val 2 + %36 = OpCompositeExtract %v2float %val 3 + %37 = OpCompositeConstruct %mat4v2float %33 %34 %35 %36 + OpReturnValue %37 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %38 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %41 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %44 + %i = OpVariable %_ptr_Function_uint Function %47 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %60 + OpBranch %48 + %48 = OpLabel + OpLoopMerge %49 %50 None + OpBranch %51 + %51 = OpLabel + %53 = OpLoad %uint %i + %54 = OpULessThan %bool %53 %uint_4 + %52 = OpLogicalNot %bool %54 + OpSelectionMerge %56 None + OpBranchConditional %52 %57 %56 + %57 = OpLabel + OpBranch %49 + %56 = OpLabel + OpStore %var_for_index %val_0 + %61 = OpLoad %uint %i + %63 = OpAccessChain %_ptr_Function_mat4v2float %arr %61 + %65 = OpLoad %uint %i + %67 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %65 + %68 = OpLoad %mat4x2_f32 %67 + %64 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %68 + OpStore %63 %64 + OpBranch %50 + %50 = OpLabel + %69 = OpLoad %uint %i + %71 = OpIAdd %uint %69 %uint_1 + OpStore %i %71 + OpBranch %48 + %49 = OpLabel + %72 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %72 + OpFunctionEnd + %f = OpFunction %void None %73 + %75 = OpLabel + %80 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %u %uint_0 + %81 = OpLoad %_arr_mat4x2_f32_uint_4 %80 + %77 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %81 + %76 = OpFunctionCall %void %a %77 + %85 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %u %uint_0 %uint_1 + %86 = OpLoad %mat4x2_f32 %85 + %83 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %86 + %82 = OpFunctionCall %void %b %83 + %89 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %uint_1 %uint_0 + %90 = OpLoad %v2float %89 + %91 = OpVectorShuffle %v2float %90 %90 1 0 + %87 = OpFunctionCall %void %c %91 + %93 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %uint_1 %uint_0 + %94 = OpLoad %v2float %93 + %95 = OpVectorShuffle %v2float %94 %94 1 0 + %96 = OpCompositeExtract %float %95 0 + %92 = OpFunctionCall %void %d %96 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.glsl index 0b73e75e37..01b3ece97f 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.glsl @@ -1,21 +1,42 @@ #version 310 es +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + struct S { int before; mat4x2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat4x2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat4x2_f32 inner[4]; } u; mat4x2 p[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + void f() { - p = u.inner; - p[1] = u.inner[2]; - p[1][0] = u.inner[0][1].yx; - p[1][0].x = u.inner[0][1].x; + p = conv_arr4_mat4x2_f32(u.inner); + p[1] = conv_mat4x2_f32(u.inner[2u]); + p[1][0] = u.inner[0u].col1.yx; + p[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.spvasm index 41ac892634..f22ef5d5b6 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_private.wgsl.expected.spvasm @@ -1,68 +1,145 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 41 +; Bound: 88 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" OpName %u "u" OpName %p "p" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat4v2float = OpTypeMatrix %v2float 4 %_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_Private__arr_mat4v2float_uint_4 = OpTypePointer Private %_arr_mat4v2float_uint_4 - %12 = OpConstantNull %_arr_mat4v2float_uint_4 - %p = OpVariable %_ptr_Private__arr_mat4v2float_uint_4 Private %12 + %14 = OpConstantNull %_arr_mat4v2float_uint_4 + %p = OpVariable %_ptr_Private__arr_mat4v2float_uint_4 Private %14 + %15 = OpTypeFunction %mat4v2float %mat4x2_f32 + %24 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %32 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %45 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %13 = OpTypeFunction %void + %58 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_Private_mat4v2float = OpTypePointer Private %mat4v2float - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float - %29 = OpConstantNull %int + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 + %76 = OpConstantNull %int %_ptr_Private_v2float = OpTypePointer Private %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Private_float = OpTypePointer Private %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %f = OpFunction %void None %13 - %16 = OpLabel - %19 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %u %uint_0 - %20 = OpLoad %_arr_mat4v2float_uint_4 %19 - OpStore %p %20 - %24 = OpAccessChain %_ptr_Private_mat4v2float %p %int_1 - %27 = OpAccessChain %_ptr_Uniform_mat4v2float %u %uint_0 %int_2 - %28 = OpLoad %mat4v2float %27 - OpStore %24 %28 - %31 = OpAccessChain %_ptr_Private_v2float %p %int_1 %29 - %33 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %29 %int_1 - %34 = OpLoad %v2float %33 - %35 = OpVectorShuffle %v2float %34 %34 1 0 - OpStore %31 %35 - %37 = OpAccessChain %_ptr_Private_float %p %int_1 %29 %uint_0 - %39 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %29 %int_1 %uint_0 - %40 = OpLoad %float %39 - OpStore %37 %40 +%conv_mat4x2_f32 = OpFunction %mat4v2float None %15 + %val = OpFunctionParameter %mat4x2_f32 + %18 = OpLabel + %19 = OpCompositeExtract %v2float %val 0 + %20 = OpCompositeExtract %v2float %val 1 + %21 = OpCompositeExtract %v2float %val 2 + %22 = OpCompositeExtract %v2float %val 3 + %23 = OpCompositeConstruct %mat4v2float %19 %20 %21 %22 + OpReturnValue %23 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %24 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %27 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %14 + %i = OpVariable %_ptr_Function_uint Function %32 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %45 + OpBranch %33 + %33 = OpLabel + OpLoopMerge %34 %35 None + OpBranch %36 + %36 = OpLabel + %38 = OpLoad %uint %i + %39 = OpULessThan %bool %38 %uint_4 + %37 = OpLogicalNot %bool %39 + OpSelectionMerge %41 None + OpBranchConditional %37 %42 %41 + %42 = OpLabel + OpBranch %34 + %41 = OpLabel + OpStore %var_for_index %val_0 + %46 = OpLoad %uint %i + %48 = OpAccessChain %_ptr_Function_mat4v2float %arr %46 + %50 = OpLoad %uint %i + %52 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %50 + %53 = OpLoad %mat4x2_f32 %52 + %49 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %53 + OpStore %48 %49 + OpBranch %35 + %35 = OpLabel + %54 = OpLoad %uint %i + %56 = OpIAdd %uint %54 %uint_1 + OpStore %i %56 + OpBranch %33 + %34 = OpLabel + %57 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %57 + OpFunctionEnd + %f = OpFunction %void None %58 + %61 = OpLabel + %65 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %u %uint_0 + %66 = OpLoad %_arr_mat4x2_f32_uint_4 %65 + %62 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %66 + OpStore %p %62 + %70 = OpAccessChain %_ptr_Private_mat4v2float %p %int_1 + %74 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %u %uint_0 %uint_2 + %75 = OpLoad %mat4x2_f32 %74 + %71 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %75 + OpStore %70 %71 + %78 = OpAccessChain %_ptr_Private_v2float %p %int_1 %76 + %80 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %32 %uint_1 + %81 = OpLoad %v2float %80 + %82 = OpVectorShuffle %v2float %81 %81 1 0 + OpStore %78 %82 + %84 = OpAccessChain %_ptr_Private_float %p %int_1 %76 %uint_0 + %86 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %32 %uint_1 %32 + %87 = OpLoad %float %86 + OpStore %84 %87 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.glsl index 7eb1bf5a30..b7e9977756 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.glsl @@ -1,24 +1,45 @@ #version 310 es +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + struct S { int before; mat4x2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat4x2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat4x2_f32 inner[4]; } u; layout(binding = 1, std430) buffer u_block_ssbo { mat4x2 inner[4]; } s; +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + void f() { - s.inner = u.inner; - s.inner[1] = u.inner[2]; - s.inner[1][0] = u.inner[0][1].yx; - s.inner[1][0].x = u.inner[0][1].x; + s.inner = conv_arr4_mat4x2_f32(u.inner); + s.inner[1] = conv_mat4x2_f32(u.inner[2u]); + s.inner[1][0] = u.inner[0u].col1.yx; + s.inner[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.spvasm index f922154b50..ed2b150ffc 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_storage.wgsl.expected.spvasm @@ -1,71 +1,156 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 42 +; Bound: 91 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" OpExecutionMode %f LocalSize 1 1 1 + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" + OpName %u "u" OpName %u_block "u_block" OpMemberName %u_block 0 "inner" - OpName %u "u" OpName %s "s" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f "f" + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 + OpDecorate %u NonWritable + OpDecorate %u DescriptorSet 0 + OpDecorate %u Binding 0 OpDecorate %u_block Block OpMemberDecorate %u_block 0 Offset 0 OpMemberDecorate %u_block 0 ColMajor OpMemberDecorate %u_block 0 MatrixStride 8 OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 - OpDecorate %u NonWritable - OpDecorate %u DescriptorSet 0 - OpDecorate %u Binding 0 OpDecorate %s DescriptorSet 0 OpDecorate %s Binding 1 %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint = OpTypeInt 32 0 %uint_4 = OpConstant %uint 4 +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat4v2float = OpTypeMatrix %v2float 4 %_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 %u_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_StorageBuffer_u_block = OpTypePointer StorageBuffer %u_block %s = OpVariable %_ptr_StorageBuffer_u_block StorageBuffer + %15 = OpTypeFunction %mat4v2float %mat4x2_f32 + %24 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 + %30 = OpConstantNull %_arr_mat4v2float_uint_4 +%_ptr_Function_uint = OpTypePointer Function %uint + %33 = OpConstantNull %uint + %bool = OpTypeBool +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %46 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 + %uint_1 = OpConstant %uint 1 %void = OpTypeVoid - %12 = OpTypeFunction %void + %59 = OpTypeFunction %void %uint_0 = OpConstant %uint 0 %_ptr_StorageBuffer__arr_mat4v2float_uint_4 = OpTypePointer StorageBuffer %_arr_mat4v2float_uint_4 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 %_ptr_StorageBuffer_mat4v2float = OpTypePointer StorageBuffer %mat4v2float - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float - %30 = OpConstantNull %int + %uint_2 = OpConstant %uint 2 +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 + %79 = OpConstantNull %int %_ptr_StorageBuffer_v2float = OpTypePointer StorageBuffer %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_StorageBuffer_float = OpTypePointer StorageBuffer %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %f = OpFunction %void None %12 - %15 = OpLabel - %18 = OpAccessChain %_ptr_StorageBuffer__arr_mat4v2float_uint_4 %s %uint_0 - %20 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %u %uint_0 - %21 = OpLoad %_arr_mat4v2float_uint_4 %20 - OpStore %18 %21 - %25 = OpAccessChain %_ptr_StorageBuffer_mat4v2float %s %uint_0 %int_1 - %28 = OpAccessChain %_ptr_Uniform_mat4v2float %u %uint_0 %int_2 - %29 = OpLoad %mat4v2float %28 - OpStore %25 %29 - %32 = OpAccessChain %_ptr_StorageBuffer_v2float %s %uint_0 %int_1 %30 - %34 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %30 %int_1 - %35 = OpLoad %v2float %34 - %36 = OpVectorShuffle %v2float %35 %35 1 0 - OpStore %32 %36 - %38 = OpAccessChain %_ptr_StorageBuffer_float %s %uint_0 %int_1 %30 %uint_0 - %40 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %30 %int_1 %uint_0 - %41 = OpLoad %float %40 - OpStore %38 %41 +%conv_mat4x2_f32 = OpFunction %mat4v2float None %15 + %val = OpFunctionParameter %mat4x2_f32 + %18 = OpLabel + %19 = OpCompositeExtract %v2float %val 0 + %20 = OpCompositeExtract %v2float %val 1 + %21 = OpCompositeExtract %v2float %val 2 + %22 = OpCompositeExtract %v2float %val 3 + %23 = OpCompositeConstruct %mat4v2float %19 %20 %21 %22 + OpReturnValue %23 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %24 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %27 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %30 + %i = OpVariable %_ptr_Function_uint Function %33 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %46 + OpBranch %34 + %34 = OpLabel + OpLoopMerge %35 %36 None + OpBranch %37 + %37 = OpLabel + %39 = OpLoad %uint %i + %40 = OpULessThan %bool %39 %uint_4 + %38 = OpLogicalNot %bool %40 + OpSelectionMerge %42 None + OpBranchConditional %38 %43 %42 + %43 = OpLabel + OpBranch %35 + %42 = OpLabel + OpStore %var_for_index %val_0 + %47 = OpLoad %uint %i + %49 = OpAccessChain %_ptr_Function_mat4v2float %arr %47 + %51 = OpLoad %uint %i + %53 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %51 + %54 = OpLoad %mat4x2_f32 %53 + %50 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %54 + OpStore %49 %50 + OpBranch %36 + %36 = OpLabel + %55 = OpLoad %uint %i + %57 = OpIAdd %uint %55 %uint_1 + OpStore %i %57 + OpBranch %34 + %35 = OpLabel + %58 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %58 + OpFunctionEnd + %f = OpFunction %void None %59 + %62 = OpLabel + %65 = OpAccessChain %_ptr_StorageBuffer__arr_mat4v2float_uint_4 %s %uint_0 + %68 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %u %uint_0 + %69 = OpLoad %_arr_mat4x2_f32_uint_4 %68 + %66 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %69 + OpStore %65 %66 + %73 = OpAccessChain %_ptr_StorageBuffer_mat4v2float %s %uint_0 %int_1 + %77 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %u %uint_0 %uint_2 + %78 = OpLoad %mat4x2_f32 %77 + %74 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %78 + OpStore %73 %74 + %81 = OpAccessChain %_ptr_StorageBuffer_v2float %s %uint_0 %int_1 %79 + %83 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %33 %uint_1 + %84 = OpLoad %v2float %83 + %85 = OpVectorShuffle %v2float %84 %84 1 0 + OpStore %81 %85 + %87 = OpAccessChain %_ptr_StorageBuffer_float %s %uint_0 %int_1 %79 %uint_0 + %89 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %33 %uint_1 %33 + %90 = OpLoad %float %89 + OpStore %87 %90 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.glsl index 6ca89c7f67..df52a3b977 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.glsl @@ -1,16 +1,37 @@ #version 310 es +struct mat4x2_f32 { + vec2 col0; + vec2 col1; + vec2 col2; + vec2 col3; +}; + struct S { int before; mat4x2 m; int after; }; -layout(binding = 0, std140) uniform u_block_ubo { - mat4x2 inner[4]; +layout(binding = 0, std140) uniform u_block_std140_ubo { + mat4x2_f32 inner[4]; } u; shared mat4x2 w[4]; +mat4x2 conv_mat4x2_f32(mat4x2_f32 val) { + return mat4x2(val.col0, val.col1, val.col2, val.col3); +} + +mat4x2[4] conv_arr4_mat4x2_f32(mat4x2_f32 val[4]) { + mat4x2 arr[4] = mat4x2[4](mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)); + { + for(uint i = 0u; (i < 4u); i = (i + 1u)) { + arr[i] = conv_mat4x2_f32(val[i]); + } + } + return arr; +} + void f(uint local_invocation_index) { { for(uint idx = local_invocation_index; (idx < 4u); idx = (idx + 1u)) { @@ -19,10 +40,10 @@ void f(uint local_invocation_index) { } } barrier(); - w = u.inner; - w[1] = u.inner[2]; - w[1][0] = u.inner[0][1].yx; - w[1][0].x = u.inner[0][1].x; + w = conv_arr4_mat4x2_f32(u.inner); + w[1] = conv_mat4x2_f32(u.inner[2u]); + w[1][0] = u.inner[0u].col1.yx; + w[1][0].x = u.inner[0u].col1[0u]; } layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; diff --git a/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.spvasm index d38bf92da8..4b7fada96a 100644 --- a/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/array/mat4x2/to_workgroup.wgsl.expected.spvasm @@ -1,115 +1,188 @@ ; SPIR-V ; Version: 1.3 ; Generator: Google Tint Compiler; 0 -; Bound: 70 +; Bound: 113 ; Schema: 0 OpCapability Shader OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %f "f" %local_invocation_index_1 OpExecutionMode %f LocalSize 1 1 1 OpName %local_invocation_index_1 "local_invocation_index_1" - OpName %u_block "u_block" - OpMemberName %u_block 0 "inner" + OpName %u_block_std140 "u_block_std140" + OpMemberName %u_block_std140 0 "inner" + OpName %mat4x2_f32 "mat4x2_f32" + OpMemberName %mat4x2_f32 0 "col0" + OpMemberName %mat4x2_f32 1 "col1" + OpMemberName %mat4x2_f32 2 "col2" + OpMemberName %mat4x2_f32 3 "col3" OpName %u "u" OpName %w "w" + OpName %conv_mat4x2_f32 "conv_mat4x2_f32" + OpName %val "val" + OpName %conv_arr4_mat4x2_f32 "conv_arr4_mat4x2_f32" + OpName %val_0 "val" + OpName %arr "arr" + OpName %i "i" + OpName %var_for_index "var_for_index" OpName %f_inner "f_inner" OpName %local_invocation_index "local_invocation_index" OpName %idx "idx" OpName %f "f" OpDecorate %local_invocation_index_1 BuiltIn LocalInvocationIndex - OpDecorate %u_block Block - OpMemberDecorate %u_block 0 Offset 0 - OpMemberDecorate %u_block 0 ColMajor - OpMemberDecorate %u_block 0 MatrixStride 8 - OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 + OpDecorate %u_block_std140 Block + OpMemberDecorate %u_block_std140 0 Offset 0 + OpMemberDecorate %mat4x2_f32 0 Offset 0 + OpMemberDecorate %mat4x2_f32 1 Offset 8 + OpMemberDecorate %mat4x2_f32 2 Offset 16 + OpMemberDecorate %mat4x2_f32 3 Offset 24 + OpDecorate %_arr_mat4x2_f32_uint_4 ArrayStride 32 OpDecorate %u NonWritable OpDecorate %u DescriptorSet 0 OpDecorate %u Binding 0 + OpDecorate %_arr_mat4v2float_uint_4 ArrayStride 32 %uint = OpTypeInt 32 0 %_ptr_Input_uint = OpTypePointer Input %uint %local_invocation_index_1 = OpVariable %_ptr_Input_uint Input %float = OpTypeFloat 32 %v2float = OpTypeVector %float 2 -%mat4v2float = OpTypeMatrix %v2float 4 + %mat4x2_f32 = OpTypeStruct %v2float %v2float %v2float %v2float %uint_4 = OpConstant %uint 4 +%_arr_mat4x2_f32_uint_4 = OpTypeArray %mat4x2_f32 %uint_4 +%u_block_std140 = OpTypeStruct %_arr_mat4x2_f32_uint_4 +%_ptr_Uniform_u_block_std140 = OpTypePointer Uniform %u_block_std140 + %u = OpVariable %_ptr_Uniform_u_block_std140 Uniform +%mat4v2float = OpTypeMatrix %v2float 4 %_arr_mat4v2float_uint_4 = OpTypeArray %mat4v2float %uint_4 - %u_block = OpTypeStruct %_arr_mat4v2float_uint_4 -%_ptr_Uniform_u_block = OpTypePointer Uniform %u_block - %u = OpVariable %_ptr_Uniform_u_block Uniform %_ptr_Workgroup__arr_mat4v2float_uint_4 = OpTypePointer Workgroup %_arr_mat4v2float_uint_4 %w = OpVariable %_ptr_Workgroup__arr_mat4v2float_uint_4 Workgroup - %void = OpTypeVoid - %14 = OpTypeFunction %void %uint + %16 = OpTypeFunction %mat4v2float %mat4x2_f32 + %25 = OpTypeFunction %_arr_mat4v2float_uint_4 %_arr_mat4x2_f32_uint_4 +%_ptr_Function__arr_mat4v2float_uint_4 = OpTypePointer Function %_arr_mat4v2float_uint_4 + %31 = OpConstantNull %_arr_mat4v2float_uint_4 %_ptr_Function_uint = OpTypePointer Function %uint - %21 = OpConstantNull %uint + %34 = OpConstantNull %uint %bool = OpTypeBool -%_ptr_Workgroup_mat4v2float = OpTypePointer Workgroup %mat4v2float - %35 = OpConstantNull %mat4v2float +%_ptr_Function__arr_mat4x2_f32_uint_4 = OpTypePointer Function %_arr_mat4x2_f32_uint_4 + %47 = OpConstantNull %_arr_mat4x2_f32_uint_4 +%_ptr_Function_mat4v2float = OpTypePointer Function %mat4v2float +%_ptr_Function_mat4x2_f32 = OpTypePointer Function %mat4x2_f32 %uint_1 = OpConstant %uint 1 + %void = OpTypeVoid + %60 = OpTypeFunction %void %uint +%_ptr_Workgroup_mat4v2float = OpTypePointer Workgroup %mat4v2float + %78 = OpConstantNull %mat4v2float %uint_2 = OpConstant %uint 2 %uint_264 = OpConstant %uint 264 %uint_0 = OpConstant %uint 0 -%_ptr_Uniform__arr_mat4v2float_uint_4 = OpTypePointer Uniform %_arr_mat4v2float_uint_4 +%_ptr_Uniform__arr_mat4x2_f32_uint_4 = OpTypePointer Uniform %_arr_mat4x2_f32_uint_4 %int = OpTypeInt 32 1 %int_1 = OpConstant %int 1 - %int_2 = OpConstant %int 2 -%_ptr_Uniform_mat4v2float = OpTypePointer Uniform %mat4v2float - %53 = OpConstantNull %int +%_ptr_Uniform_mat4x2_f32 = OpTypePointer Uniform %mat4x2_f32 + %96 = OpConstantNull %int %_ptr_Workgroup_v2float = OpTypePointer Workgroup %v2float %_ptr_Uniform_v2float = OpTypePointer Uniform %v2float %_ptr_Workgroup_float = OpTypePointer Workgroup %float %_ptr_Uniform_float = OpTypePointer Uniform %float - %65 = OpTypeFunction %void - %f_inner = OpFunction %void None %14 + %108 = OpTypeFunction %void +%conv_mat4x2_f32 = OpFunction %mat4v2float None %16 + %val = OpFunctionParameter %mat4x2_f32 + %19 = OpLabel + %20 = OpCompositeExtract %v2float %val 0 + %21 = OpCompositeExtract %v2float %val 1 + %22 = OpCompositeExtract %v2float %val 2 + %23 = OpCompositeExtract %v2float %val 3 + %24 = OpCompositeConstruct %mat4v2float %20 %21 %22 %23 + OpReturnValue %24 + OpFunctionEnd +%conv_arr4_mat4x2_f32 = OpFunction %_arr_mat4v2float_uint_4 None %25 + %val_0 = OpFunctionParameter %_arr_mat4x2_f32_uint_4 + %28 = OpLabel + %arr = OpVariable %_ptr_Function__arr_mat4v2float_uint_4 Function %31 + %i = OpVariable %_ptr_Function_uint Function %34 +%var_for_index = OpVariable %_ptr_Function__arr_mat4x2_f32_uint_4 Function %47 + OpBranch %35 + %35 = OpLabel + OpLoopMerge %36 %37 None + OpBranch %38 + %38 = OpLabel + %40 = OpLoad %uint %i + %41 = OpULessThan %bool %40 %uint_4 + %39 = OpLogicalNot %bool %41 + OpSelectionMerge %43 None + OpBranchConditional %39 %44 %43 + %44 = OpLabel + OpBranch %36 + %43 = OpLabel + OpStore %var_for_index %val_0 + %48 = OpLoad %uint %i + %50 = OpAccessChain %_ptr_Function_mat4v2float %arr %48 + %52 = OpLoad %uint %i + %54 = OpAccessChain %_ptr_Function_mat4x2_f32 %var_for_index %52 + %55 = OpLoad %mat4x2_f32 %54 + %51 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %55 + OpStore %50 %51 + OpBranch %37 + %37 = OpLabel + %56 = OpLoad %uint %i + %58 = OpIAdd %uint %56 %uint_1 + OpStore %i %58 + OpBranch %35 + %36 = OpLabel + %59 = OpLoad %_arr_mat4v2float_uint_4 %arr + OpReturnValue %59 + OpFunctionEnd + %f_inner = OpFunction %void None %60 %local_invocation_index = OpFunctionParameter %uint - %18 = OpLabel - %idx = OpVariable %_ptr_Function_uint Function %21 + %64 = OpLabel + %idx = OpVariable %_ptr_Function_uint Function %34 OpStore %idx %local_invocation_index - OpBranch %22 - %22 = OpLabel - OpLoopMerge %23 %24 None - OpBranch %25 - %25 = OpLabel - %27 = OpLoad %uint %idx - %28 = OpULessThan %bool %27 %uint_4 - %26 = OpLogicalNot %bool %28 - OpSelectionMerge %30 None - OpBranchConditional %26 %31 %30 - %31 = OpLabel - OpBranch %23 - %30 = OpLabel - %32 = OpLoad %uint %idx - %34 = OpAccessChain %_ptr_Workgroup_mat4v2float %w %32 - OpStore %34 %35 - OpBranch %24 - %24 = OpLabel - %36 = OpLoad %uint %idx - %38 = OpIAdd %uint %36 %uint_1 - OpStore %idx %38 - OpBranch %22 - %23 = OpLabel - OpControlBarrier %uint_2 %uint_2 %uint_264 - %44 = OpAccessChain %_ptr_Uniform__arr_mat4v2float_uint_4 %u %uint_0 - %45 = OpLoad %_arr_mat4v2float_uint_4 %44 - OpStore %w %45 - %48 = OpAccessChain %_ptr_Workgroup_mat4v2float %w %int_1 - %51 = OpAccessChain %_ptr_Uniform_mat4v2float %u %uint_0 %int_2 - %52 = OpLoad %mat4v2float %51 - OpStore %48 %52 - %55 = OpAccessChain %_ptr_Workgroup_v2float %w %int_1 %53 - %57 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %53 %int_1 - %58 = OpLoad %v2float %57 - %59 = OpVectorShuffle %v2float %58 %58 1 0 - OpStore %55 %59 - %61 = OpAccessChain %_ptr_Workgroup_float %w %int_1 %53 %uint_0 - %63 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %53 %int_1 %uint_0 - %64 = OpLoad %float %63 - OpStore %61 %64 - OpReturn - OpFunctionEnd - %f = OpFunction %void None %65 + OpBranch %66 + %66 = OpLabel + OpLoopMerge %67 %68 None + OpBranch %69 + %69 = OpLabel + %71 = OpLoad %uint %idx + %72 = OpULessThan %bool %71 %uint_4 + %70 = OpLogicalNot %bool %72 + OpSelectionMerge %73 None + OpBranchConditional %70 %74 %73 + %74 = OpLabel + OpBranch %67 + %73 = OpLabel + %75 = OpLoad %uint %idx + %77 = OpAccessChain %_ptr_Workgroup_mat4v2float %w %75 + OpStore %77 %78 + OpBranch %68 + %68 = OpLabel + %79 = OpLoad %uint %idx + %80 = OpIAdd %uint %79 %uint_1 + OpStore %idx %80 + OpBranch %66 %67 = OpLabel - %69 = OpLoad %uint %local_invocation_index_1 - %68 = OpFunctionCall %void %f_inner %69 + OpControlBarrier %uint_2 %uint_2 %uint_264 + %87 = OpAccessChain %_ptr_Uniform__arr_mat4x2_f32_uint_4 %u %uint_0 + %88 = OpLoad %_arr_mat4x2_f32_uint_4 %87 + %84 = OpFunctionCall %_arr_mat4v2float_uint_4 %conv_arr4_mat4x2_f32 %88 + OpStore %w %84 + %91 = OpAccessChain %_ptr_Workgroup_mat4v2float %w %int_1 + %94 = OpAccessChain %_ptr_Uniform_mat4x2_f32 %u %uint_0 %uint_2 + %95 = OpLoad %mat4x2_f32 %94 + %92 = OpFunctionCall %mat4v2float %conv_mat4x2_f32 %95 + OpStore %91 %92 + %98 = OpAccessChain %_ptr_Workgroup_v2float %w %int_1 %96 + %100 = OpAccessChain %_ptr_Uniform_v2float %u %uint_0 %34 %uint_1 + %101 = OpLoad %v2float %100 + %102 = OpVectorShuffle %v2float %101 %101 1 0 + OpStore %98 %102 + %104 = OpAccessChain %_ptr_Workgroup_float %w %int_1 %96 %uint_0 + %106 = OpAccessChain %_ptr_Uniform_float %u %uint_0 %34 %uint_1 %34 + %107 = OpLoad %float %106 + OpStore %104 %107 + OpReturn + OpFunctionEnd + %f = OpFunction %void None %108 + %110 = OpLabel + %112 = OpLoad %uint %local_invocation_index_1 + %111 = OpFunctionCall %void %f_inner %112 OpReturn OpFunctionEnd diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl index e27a6471de..90e0cf3f7f 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.glsl @@ -31,7 +31,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat2(val.m_0, val.m_1)); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -42,10 +42,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f))))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -96,18 +96,18 @@ float load_a_inner_p0_a_p1_m_p2_p3(uint p0, uint p1, uint p2, uint p3) { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); int tint_symbol = i(); Outer p_a_i = conv_Outer(a.inner[tint_symbol]); - Inner p_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner p_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); int tint_symbol_1 = i(); Inner p_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat2 p_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); int tint_symbol_2 = i(); vec2 p_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_i = conv_Outer(a.inner[tint_symbol]); - Inner l_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner l_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); Inner l_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat2 l_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); vec2 l_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm index 7950eacff3..796a19285f 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/dynamic_index_via_ptr.wgsl.expected.spvasm @@ -21,7 +21,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i_0 "i" @@ -30,7 +30,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_1 "i" @@ -137,7 +137,7 @@ %32 = OpCompositeConstruct %Inner %31 OpReturnValue %32 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %33 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %33 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %37 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %40 @@ -178,11 +178,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %73 = OpLabel %75 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %74 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %75 + %74 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %75 %76 = OpCompositeConstruct %Outer %74 OpReturnValue %76 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %77 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %77 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %81 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %84 @@ -279,13 +279,13 @@ %164 = OpFunctionCall %int %i %167 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %168 = OpLoad %_arr_Outer_std140_uint_4 %167 - %165 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %168 + %165 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %168 %171 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %162 %172 = OpLoad %Outer_std140 %171 %169 = OpFunctionCall %Outer %conv_Outer %172 %175 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %162 %uint_0 %176 = OpLoad %_arr_Inner_std140_uint_4 %175 - %173 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %176 + %173 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %176 %178 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %162 %uint_0 %163 %179 = OpLoad %Inner_std140 %178 %177 = OpFunctionCall %Inner %conv_Inner %179 diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.glsl index f00bbf5a17..3564979580 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.glsl @@ -25,7 +25,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat2(val.m_0, val.m_1)); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -36,10 +36,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat2(0.0f, 0.0f, 0.0f, 0.0f))))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -54,15 +54,15 @@ mat2 load_a_inner_3_a_2_m() { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); Outer p_a_3 = conv_Outer(a.inner[3u]); - Inner p_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner p_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner p_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat2 p_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 p_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_3 = conv_Outer(a.inner[3u]); - Inner l_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner l_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner l_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat2 l_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 l_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.spvasm index 6a3a339a97..de1047ee47 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/static_index_via_ptr.wgsl.expected.spvasm @@ -19,7 +19,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -28,7 +28,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_0 "i" @@ -108,7 +108,7 @@ %21 = OpCompositeConstruct %Inner %20 OpReturnValue %21 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %22 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %22 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %26 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %29 @@ -149,11 +149,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %62 = OpLabel %64 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %63 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %64 + %63 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %64 %65 = OpCompositeConstruct %Outer %63 OpReturnValue %65 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %66 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %66 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %70 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %73 @@ -204,13 +204,13 @@ %118 = OpLabel %121 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %122 = OpLoad %_arr_Outer_std140_uint_4 %121 - %119 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %122 + %119 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %122 %125 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %uint_3 %126 = OpLoad %Outer_std140 %125 %123 = OpFunctionCall %Outer %conv_Outer %126 %129 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %uint_3 %uint_0 %130 = OpLoad %_arr_Inner_std140_uint_4 %129 - %127 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %130 + %127 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %130 %132 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %uint_3 %uint_0 %uint_2 %133 = OpLoad %Inner_std140 %132 %131 = OpFunctionCall %Inner %conv_Inner %133 diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.glsl index 452c603aaa..daaf731be6 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.glsl @@ -40,7 +40,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat2(val.m_0, val.m_1), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -55,7 +55,7 @@ mat2 load_u_inner_2_m() { } void f() { - a(conv_arr_4_S(u.inner)); + a(conv_arr4_S(u.inner)); b(conv_S(u.inner[2u])); c(load_u_inner_2_m()); d(u.inner[0u].m_1.yx); diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.spvasm index 627852bd46..facd977dfb 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_fn.wgsl.expected.spvasm @@ -31,7 +31,7 @@ OpName %f_1 "f_1" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -128,7 +128,7 @@ %44 = OpCompositeConstruct %S %39 %42 %43 OpReturnValue %44 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %45 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %45 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %48 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %51 @@ -179,7 +179,7 @@ %98 = OpLabel %102 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %103 = OpLoad %_arr_S_std140_uint_4 %102 - %100 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %103 + %100 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %103 %99 = OpFunctionCall %void %a %100 %106 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 %107 = OpLoad %S_std140 %106 diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.glsl index ce7f2cef46..9634531ad4 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.glsl @@ -26,7 +26,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat2(val.m_0, val.m_1), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -41,7 +41,7 @@ mat2 load_u_inner_2_m() { } void f() { - p = conv_arr_4_S(u.inner); + p = conv_arr4_S(u.inner); p[1] = conv_S(u.inner[2u]); p[3].m = load_u_inner_2_m(); p[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.spvasm index 118e47614e..57765b4792 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_private.wgsl.expected.spvasm @@ -22,7 +22,7 @@ OpName %p "p" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -97,7 +97,7 @@ %26 = OpCompositeConstruct %S %21 %24 %25 OpReturnValue %26 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %27 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %27 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %30 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %16 @@ -148,7 +148,7 @@ %80 = OpLabel %83 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %84 = OpLoad %_arr_S_std140_uint_4 %83 - %81 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %84 + %81 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %84 OpStore %p %81 %87 = OpAccessChain %_ptr_Private_S %p %int_1 %89 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.glsl index 0fdf832225..ec19f640c2 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.glsl @@ -29,7 +29,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat2(val.m_0, val.m_1), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -44,7 +44,7 @@ mat2 load_u_inner_2_m() { } void f() { - s.inner = conv_arr_4_S(u.inner); + s.inner = conv_arr4_S(u.inner); s.inner[1] = conv_S(u.inner[2u]); s.inner[3].m = load_u_inner_2_m(); s.inner[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.spvasm index 8769096618..6f393c776e 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_storage.wgsl.expected.spvasm @@ -24,7 +24,7 @@ OpName %s "s" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -105,7 +105,7 @@ %26 = OpCompositeConstruct %S %21 %24 %25 OpReturnValue %26 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %27 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %27 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %30 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %33 @@ -157,7 +157,7 @@ %83 = OpAccessChain %_ptr_StorageBuffer__arr_S_uint_4 %s %uint_0 %86 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %87 = OpLoad %_arr_S_std140_uint_4 %86 - %84 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %87 + %84 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %87 OpStore %83 %84 %90 = OpAccessChain %_ptr_StorageBuffer_S %s %uint_0 %int_1 %92 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.glsl index 9204f46935..cdc0450076 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.glsl @@ -26,7 +26,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat2(val.m_0, val.m_1), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat2(0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -49,7 +49,7 @@ void f(uint local_invocation_index) { } } barrier(); - w = conv_arr_4_S(u.inner); + w = conv_arr4_S(u.inner); w[1] = conv_S(u.inner[2u]); w[3].m = load_u_inner_2_m(); w[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.spvasm index 5e253f9518..a6922dc1fc 100644 --- a/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat2x2/to_workgroup.wgsl.expected.spvasm @@ -23,7 +23,7 @@ OpName %w "w" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -107,7 +107,7 @@ %27 = OpCompositeConstruct %S %22 %25 %26 OpReturnValue %27 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %28 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %28 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %31 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %34 @@ -185,7 +185,7 @@ OpControlBarrier %uint_2 %uint_2 %uint_264 %104 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %105 = OpLoad %_arr_S_std140_uint_4 %104 - %102 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %105 + %102 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %105 OpStore %w %102 %107 = OpAccessChain %_ptr_Workgroup_S %w %int_1 %109 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.glsl index accf517b6f..ea06cdda42 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.glsl @@ -52,7 +52,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat3x2(val.m_0, val.m_1, val.m_2), val.pad, val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -63,10 +63,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -125,18 +125,18 @@ float load_a_inner_p0_a_p1_m_p2_p3(uint p0, uint p1, uint p2, uint p3) { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); int tint_symbol = i(); Outer p_a_i = conv_Outer(a.inner[tint_symbol]); - Inner p_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner p_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); int tint_symbol_1 = i(); Inner p_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat3x2 p_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); int tint_symbol_2 = i(); vec2 p_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_i = conv_Outer(a.inner[tint_symbol]); - Inner l_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner l_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); Inner l_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat3x2 l_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); vec2 l_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.spvasm index bb1c3508b9..eb9e73b2dd 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/dynamic_index_via_ptr.wgsl.expected.spvasm @@ -22,7 +22,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i_0 "i" @@ -31,7 +31,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_1 "i" @@ -141,7 +141,7 @@ %33 = OpCompositeConstruct %Inner %32 OpReturnValue %33 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %34 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %34 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %38 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %41 @@ -182,11 +182,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %74 = OpLabel %76 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %75 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %76 + %75 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %76 %77 = OpCompositeConstruct %Outer %75 OpReturnValue %77 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %78 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %78 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %82 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %85 @@ -293,13 +293,13 @@ %175 = OpFunctionCall %int %i %178 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %179 = OpLoad %_arr_Outer_std140_uint_4 %178 - %176 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %179 + %176 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %179 %182 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %173 %183 = OpLoad %Outer_std140 %182 %180 = OpFunctionCall %Outer %conv_Outer %183 %186 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %173 %uint_0 %187 = OpLoad %_arr_Inner_std140_uint_4 %186 - %184 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %187 + %184 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %187 %189 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %173 %uint_0 %174 %190 = OpLoad %Inner_std140 %189 %188 = OpFunctionCall %Inner %conv_Inner %190 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.glsl index 2d72a86a2e..21e940c3bc 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.glsl @@ -46,7 +46,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat3x2(val.m_0, val.m_1, val.m_2), val.pad, val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -57,10 +57,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))), Outer(Inner[4](Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u), Inner(mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -75,15 +75,15 @@ mat3x2 load_a_inner_3_a_2_m() { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); Outer p_a_3 = conv_Outer(a.inner[3u]); - Inner p_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner p_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner p_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat3x2 p_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 p_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_3 = conv_Outer(a.inner[3u]); - Inner l_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner l_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner l_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat3x2 l_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 l_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.spvasm index cfe19266b1..6f790a8b76 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/static_index_via_ptr.wgsl.expected.spvasm @@ -20,7 +20,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -29,7 +29,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_0 "i" @@ -111,7 +111,7 @@ %22 = OpCompositeConstruct %Inner %21 OpReturnValue %22 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %23 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %23 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %27 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %30 @@ -152,11 +152,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %63 = OpLabel %65 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %64 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %65 + %64 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %65 %66 = OpCompositeConstruct %Outer %64 OpReturnValue %66 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %67 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %67 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %71 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %74 @@ -209,13 +209,13 @@ %122 = OpLabel %125 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %126 = OpLoad %_arr_Outer_std140_uint_4 %125 - %123 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %126 + %123 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %126 %129 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %uint_3 %130 = OpLoad %Outer_std140 %129 %127 = OpFunctionCall %Outer %conv_Outer %130 %133 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %uint_3 %uint_0 %134 = OpLoad %_arr_Inner_std140_uint_4 %133 - %131 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %134 + %131 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %134 %136 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %uint_3 %uint_0 %uint_2 %137 = OpLoad %Inner_std140 %136 %135 = OpFunctionCall %Inner %conv_Inner %137 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.glsl index 720e66bcd0..41ff2a8a1f 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.glsl @@ -61,7 +61,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat3x2(val.m_0, val.m_1, val.m_2), val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9, val.pad_10, val.after, val.pad_11); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -76,7 +76,7 @@ mat3x2 load_u_inner_2_m() { } void f() { - a(conv_arr_4_S(u.inner)); + a(conv_arr4_S(u.inner)); b(conv_S(u.inner[2u])); c(load_u_inner_2_m()); d(u.inner[0u].m_1.yx); diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.spvasm index 148b7b6d9d..e7483d22b4 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_fn.wgsl.expected.spvasm @@ -32,7 +32,7 @@ OpName %f_1 "f_1" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -132,7 +132,7 @@ %45 = OpCompositeConstruct %S %39 %43 %44 OpReturnValue %45 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %46 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %46 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %49 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %52 @@ -185,7 +185,7 @@ %103 = OpLabel %107 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %108 = OpLoad %_arr_S_std140_uint_4 %107 - %105 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %108 + %105 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %108 %104 = OpFunctionCall %void %a %105 %111 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 %112 = OpLoad %S_std140 %111 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.glsl index 5fa11e4e82..7c900235ba 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.glsl @@ -47,7 +47,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat3x2(val.m_0, val.m_1, val.m_2), val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9, val.pad_10, val.after, val.pad_11); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -62,7 +62,7 @@ mat3x2 load_u_inner_2_m() { } void f() { - p = conv_arr_4_S(u.inner); + p = conv_arr4_S(u.inner); p[1] = conv_S(u.inner[2u]); p[3].m = load_u_inner_2_m(); p[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.spvasm index 0320931564..4cadc2f923 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_private.wgsl.expected.spvasm @@ -23,7 +23,7 @@ OpName %p "p" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -101,7 +101,7 @@ %27 = OpCompositeConstruct %S %21 %25 %26 OpReturnValue %27 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %28 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %28 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %31 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %16 @@ -154,7 +154,7 @@ %85 = OpLabel %88 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %89 = OpLoad %_arr_S_std140_uint_4 %88 - %86 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %89 + %86 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %89 OpStore %p %86 %92 = OpAccessChain %_ptr_Private_S %p %int_1 %94 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.glsl index ccd6e8815f..4013cf5422 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.glsl @@ -50,7 +50,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat3x2(val.m_0, val.m_1, val.m_2), val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9, val.pad_10, val.after, val.pad_11); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -65,7 +65,7 @@ mat3x2 load_u_inner_2_m() { } void f() { - s.inner = conv_arr_4_S(u.inner); + s.inner = conv_arr4_S(u.inner); s.inner[1] = conv_S(u.inner[2u]); s.inner[3].m = load_u_inner_2_m(); s.inner[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.spvasm index 30329536ef..93ef04fa96 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_storage.wgsl.expected.spvasm @@ -25,7 +25,7 @@ OpName %s "s" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -109,7 +109,7 @@ %27 = OpCompositeConstruct %S %21 %25 %26 OpReturnValue %27 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %28 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %28 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %31 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %34 @@ -163,7 +163,7 @@ %88 = OpAccessChain %_ptr_StorageBuffer__arr_S_uint_4 %s %uint_0 %91 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %92 = OpLoad %_arr_S_std140_uint_4 %91 - %89 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %92 + %89 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %92 OpStore %88 %89 %95 = OpAccessChain %_ptr_StorageBuffer_S %s %uint_0 %int_1 %97 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.glsl index fd14f19bda..9c72f93652 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.glsl @@ -47,7 +47,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat3x2(val.m_0, val.m_1, val.m_2), val.pad_1, val.pad_2, val.pad_3, val.pad_4, val.pad_5, val.pad_6, val.pad_7, val.pad_8, val.pad_9, val.pad_10, val.after, val.pad_11); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u), S(0, 0u, mat3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -70,7 +70,7 @@ void f(uint local_invocation_index) { } } barrier(); - w = conv_arr_4_S(u.inner); + w = conv_arr4_S(u.inner); w[1] = conv_S(u.inner[2u]); w[3].m = load_u_inner_2_m(); w[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.spvasm index 9db5af8d2c..be09c717f6 100644 --- a/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat3x2/to_workgroup.wgsl.expected.spvasm @@ -24,7 +24,7 @@ OpName %w "w" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -111,7 +111,7 @@ %28 = OpCompositeConstruct %S %22 %26 %27 OpReturnValue %28 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %29 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %29 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %32 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %35 @@ -191,7 +191,7 @@ OpControlBarrier %uint_2 %uint_2 %uint_264 %109 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %110 = OpLoad %_arr_S_std140_uint_4 %109 - %107 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %110 + %107 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %110 OpStore %w %107 %112 = OpAccessChain %_ptr_Workgroup_S %w %int_1 %114 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl index 7e60332ae2..4bffcae75e 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.glsl @@ -33,7 +33,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat4x2(val.m_0, val.m_1, val.m_2, val.m_3)); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -44,10 +44,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f))))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -114,18 +114,18 @@ float load_a_inner_p0_a_p1_m_p2_p3(uint p0, uint p1, uint p2, uint p3) { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); int tint_symbol = i(); Outer p_a_i = conv_Outer(a.inner[tint_symbol]); - Inner p_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner p_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); int tint_symbol_1 = i(); Inner p_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat4x2 p_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); int tint_symbol_2 = i(); vec2 p_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_i = conv_Outer(a.inner[tint_symbol]); - Inner l_a_i_a[4] = conv_arr_4_Inner(a.inner[tint_symbol].a); + Inner l_a_i_a[4] = conv_arr4_Inner(a.inner[tint_symbol].a); Inner l_a_i_a_i = conv_Inner(a.inner[tint_symbol].a[tint_symbol_1]); mat4x2 l_a_i_a_i_m = load_a_inner_p0_a_p1_m(uint(tint_symbol), uint(tint_symbol_1)); vec2 l_a_i_a_i_m_i = load_a_inner_p0_a_p1_m_p2(uint(tint_symbol), uint(tint_symbol_1), uint(tint_symbol_2)); diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm index 2a4d2cae56..9a4f081701 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/dynamic_index_via_ptr.wgsl.expected.spvasm @@ -23,7 +23,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i_0 "i" @@ -32,7 +32,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_1 "i" @@ -145,7 +145,7 @@ %34 = OpCompositeConstruct %Inner %33 OpReturnValue %34 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %35 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %35 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %39 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %42 @@ -186,11 +186,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %75 = OpLabel %77 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %76 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %77 + %76 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %77 %78 = OpCompositeConstruct %Outer %76 OpReturnValue %78 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %79 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %79 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %83 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %86 @@ -307,13 +307,13 @@ %186 = OpFunctionCall %int %i %189 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %190 = OpLoad %_arr_Outer_std140_uint_4 %189 - %187 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %190 + %187 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %190 %193 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %184 %194 = OpLoad %Outer_std140 %193 %191 = OpFunctionCall %Outer %conv_Outer %194 %197 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %184 %uint_0 %198 = OpLoad %_arr_Inner_std140_uint_4 %197 - %195 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %198 + %195 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %198 %200 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %184 %uint_0 %185 %201 = OpLoad %Inner_std140 %200 %199 = OpFunctionCall %Inner %conv_Inner %201 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.glsl index c14425b14a..658fe9e18d 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.glsl @@ -27,7 +27,7 @@ Inner conv_Inner(Inner_std140 val) { return Inner(mat4x2(val.m_0, val.m_1, val.m_2, val.m_3)); } -Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { +Inner[4] conv_arr4_Inner(Inner_std140 val[4]) { Inner arr[4] = Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -38,10 +38,10 @@ Inner[4] conv_arr_4_Inner(Inner_std140 val[4]) { } Outer conv_Outer(Outer_std140 val) { - return Outer(conv_arr_4_Inner(val.a)); + return Outer(conv_arr4_Inner(val.a)); } -Outer[4] conv_arr_4_Outer(Outer_std140 val[4]) { +Outer[4] conv_arr4_Outer(Outer_std140 val[4]) { Outer arr[4] = Outer[4](Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)))), Outer(Inner[4](Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f)), Inner(mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f))))); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -56,15 +56,15 @@ mat4x2 load_a_inner_3_a_2_m() { } void f() { - Outer p_a[4] = conv_arr_4_Outer(a.inner); + Outer p_a[4] = conv_arr4_Outer(a.inner); Outer p_a_3 = conv_Outer(a.inner[3u]); - Inner p_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner p_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner p_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat4x2 p_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 p_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; - Outer l_a[4] = conv_arr_4_Outer(a.inner); + Outer l_a[4] = conv_arr4_Outer(a.inner); Outer l_a_3 = conv_Outer(a.inner[3u]); - Inner l_a_3_a[4] = conv_arr_4_Inner(a.inner[3u].a); + Inner l_a_3_a[4] = conv_arr4_Inner(a.inner[3u].a); Inner l_a_3_a_2 = conv_Inner(a.inner[3u].a[2u]); mat4x2 l_a_3_a_2_m = load_a_inner_3_a_2_m(); vec2 l_a_3_a_2_m_1 = a.inner[3u].a[2u].m_1; diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.spvasm index 3cd3ef39d7..730d12b9a7 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/static_index_via_ptr.wgsl.expected.spvasm @@ -21,7 +21,7 @@ OpMemberName %Inner 0 "m" OpName %conv_Inner "conv_Inner" OpName %val "val" - OpName %conv_arr_4_Inner "conv_arr_4_Inner" + OpName %conv_arr4_Inner "conv_arr4_Inner" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -30,7 +30,7 @@ OpMemberName %Outer 0 "a" OpName %conv_Outer "conv_Outer" OpName %val_1 "val" - OpName %conv_arr_4_Outer "conv_arr_4_Outer" + OpName %conv_arr4_Outer "conv_arr4_Outer" OpName %val_2 "val" OpName %arr_0 "arr" OpName %i_0 "i" @@ -114,7 +114,7 @@ %23 = OpCompositeConstruct %Inner %22 OpReturnValue %23 OpFunctionEnd -%conv_arr_4_Inner = OpFunction %_arr_Inner_uint_4 None %24 +%conv_arr4_Inner = OpFunction %_arr_Inner_uint_4 None %24 %val_0 = OpFunctionParameter %_arr_Inner_std140_uint_4 %28 = OpLabel %arr = OpVariable %_ptr_Function__arr_Inner_uint_4 Function %31 @@ -155,11 +155,11 @@ %val_1 = OpFunctionParameter %Outer_std140 %64 = OpLabel %66 = OpCompositeExtract %_arr_Inner_std140_uint_4 %val_1 0 - %65 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %66 + %65 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %66 %67 = OpCompositeConstruct %Outer %65 OpReturnValue %67 OpFunctionEnd -%conv_arr_4_Outer = OpFunction %_arr_Outer_uint_4 None %68 +%conv_arr4_Outer = OpFunction %_arr_Outer_uint_4 None %68 %val_2 = OpFunctionParameter %_arr_Outer_std140_uint_4 %72 = OpLabel %arr_0 = OpVariable %_ptr_Function__arr_Outer_uint_4 Function %75 @@ -214,13 +214,13 @@ %126 = OpLabel %129 = OpAccessChain %_ptr_Uniform__arr_Outer_std140_uint_4 %a %uint_0 %130 = OpLoad %_arr_Outer_std140_uint_4 %129 - %127 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr_4_Outer %130 + %127 = OpFunctionCall %_arr_Outer_uint_4 %conv_arr4_Outer %130 %133 = OpAccessChain %_ptr_Uniform_Outer_std140 %a %uint_0 %uint_3 %134 = OpLoad %Outer_std140 %133 %131 = OpFunctionCall %Outer %conv_Outer %134 %137 = OpAccessChain %_ptr_Uniform__arr_Inner_std140_uint_4 %a %uint_0 %uint_3 %uint_0 %138 = OpLoad %_arr_Inner_std140_uint_4 %137 - %135 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr_4_Inner %138 + %135 = OpFunctionCall %_arr_Inner_uint_4 %conv_arr4_Inner %138 %140 = OpAccessChain %_ptr_Uniform_Inner_std140 %a %uint_0 %uint_3 %uint_0 %uint_2 %141 = OpLoad %Inner_std140 %140 %139 = OpFunctionCall %Inner %conv_Inner %141 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.glsl index 42fa3a1106..43a4f880a9 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.glsl @@ -42,7 +42,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat4x2(val.m_0, val.m_1, val.m_2, val.m_3), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -57,7 +57,7 @@ mat4x2 load_u_inner_2_m() { } void f() { - a(conv_arr_4_S(u.inner)); + a(conv_arr4_S(u.inner)); b(conv_S(u.inner[2u])); c(load_u_inner_2_m()); d(u.inner[0u].m_1.yx); diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.spvasm index 06de1ef522..63abbf39be 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_fn.wgsl.expected.spvasm @@ -33,7 +33,7 @@ OpName %f_1 "f_1" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -135,7 +135,7 @@ %46 = OpCompositeConstruct %S %39 %44 %45 OpReturnValue %46 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %47 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %47 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %50 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %53 @@ -190,7 +190,7 @@ %107 = OpLabel %111 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %112 = OpLoad %_arr_S_std140_uint_4 %111 - %109 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %112 + %109 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %112 %108 = OpFunctionCall %void %a %109 %115 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 %116 = OpLoad %S_std140 %115 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.glsl index 658610ec76..1ff8aa4dc9 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.glsl @@ -28,7 +28,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat4x2(val.m_0, val.m_1, val.m_2, val.m_3), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -43,7 +43,7 @@ mat4x2 load_u_inner_2_m() { } void f() { - p = conv_arr_4_S(u.inner); + p = conv_arr4_S(u.inner); p[1] = conv_S(u.inner[2u]); p[3].m = load_u_inner_2_m(); p[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.spvasm index ea4bf22d0e..e0ac972158 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_private.wgsl.expected.spvasm @@ -24,7 +24,7 @@ OpName %p "p" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -104,7 +104,7 @@ %28 = OpCompositeConstruct %S %21 %26 %27 OpReturnValue %28 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %29 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %29 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %32 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %16 @@ -159,7 +159,7 @@ %89 = OpLabel %92 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %93 = OpLoad %_arr_S_std140_uint_4 %92 - %90 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %93 + %90 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %93 OpStore %p %90 %96 = OpAccessChain %_ptr_Private_S %p %int_1 %98 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.glsl index 90098bd23d..d9b6a9fc03 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.glsl @@ -31,7 +31,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat4x2(val.m_0, val.m_1, val.m_2, val.m_3), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -46,7 +46,7 @@ mat4x2 load_u_inner_2_m() { } void f() { - s.inner = conv_arr_4_S(u.inner); + s.inner = conv_arr4_S(u.inner); s.inner[1] = conv_S(u.inner[2u]); s.inner[3].m = load_u_inner_2_m(); s.inner[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.spvasm index 5d20562179..bcbfadc511 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_storage.wgsl.expected.spvasm @@ -26,7 +26,7 @@ OpName %s "s" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -112,7 +112,7 @@ %28 = OpCompositeConstruct %S %21 %26 %27 OpReturnValue %28 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %29 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %29 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %32 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %35 @@ -168,7 +168,7 @@ %92 = OpAccessChain %_ptr_StorageBuffer__arr_S_uint_4 %s %uint_0 %95 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %96 = OpLoad %_arr_S_std140_uint_4 %95 - %93 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %96 + %93 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %96 OpStore %92 %93 %99 = OpAccessChain %_ptr_StorageBuffer_S %s %uint_0 %int_1 %101 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2 diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.glsl b/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.glsl index 07cabf97cd..2e8a05f0a6 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.glsl +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.glsl @@ -28,7 +28,7 @@ S conv_S(S_std140 val) { return S(val.before, val.pad, mat4x2(val.m_0, val.m_1, val.m_2, val.m_3), val.after, val.pad_1); } -S[4] conv_arr_4_S(S_std140 val[4]) { +S[4] conv_arr4_S(S_std140 val[4]) { S arr[4] = S[4](S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u), S(0, 0u, mat4x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), 0, 0u)); { for(uint i = 0u; (i < 4u); i = (i + 1u)) { @@ -51,7 +51,7 @@ void f(uint local_invocation_index) { } } barrier(); - w = conv_arr_4_S(u.inner); + w = conv_arr4_S(u.inner); w[1] = conv_S(u.inner[2u]); w[3].m = load_u_inner_2_m(); w[1].m[0] = u.inner[0u].m_1.yx; diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.spvasm b/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.spvasm index 80ec01c07e..a690ffcf0d 100644 --- a/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.spvasm +++ b/test/tint/buffer/uniform/std140/struct/mat4x2/to_workgroup.wgsl.expected.spvasm @@ -25,7 +25,7 @@ OpName %w "w" OpName %conv_S "conv_S" OpName %val "val" - OpName %conv_arr_4_S "conv_arr_4_S" + OpName %conv_arr4_S "conv_arr4_S" OpName %val_0 "val" OpName %arr "arr" OpName %i "i" @@ -114,7 +114,7 @@ %29 = OpCompositeConstruct %S %22 %27 %28 OpReturnValue %29 OpFunctionEnd -%conv_arr_4_S = OpFunction %_arr_S_uint_4 None %30 +%conv_arr4_S = OpFunction %_arr_S_uint_4 None %30 %val_0 = OpFunctionParameter %_arr_S_std140_uint_4 %33 = OpLabel %arr = OpVariable %_ptr_Function__arr_S_uint_4 Function %36 @@ -196,7 +196,7 @@ OpControlBarrier %uint_2 %uint_2 %uint_264 %113 = OpAccessChain %_ptr_Uniform__arr_S_std140_uint_4 %u %uint_0 %114 = OpLoad %_arr_S_std140_uint_4 %113 - %111 = OpFunctionCall %_arr_S_uint_4 %conv_arr_4_S %114 + %111 = OpFunctionCall %_arr_S_uint_4 %conv_arr4_S %114 OpStore %w %111 %116 = OpAccessChain %_ptr_Workgroup_S %w %int_1 %118 = OpAccessChain %_ptr_Uniform_S_std140 %u %uint_0 %uint_2