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 <bclayton@google.com>
Reviewed-by: David Neto <dneto@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc
index e6f070b..06b4f5d 100644
--- a/src/tint/transform/std140.cc
+++ b/src/tint/transform/std140.cc
@@ -34,6 +34,14 @@
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 @@
namespace tint::utils {
+/// Hasher specialization for UniformVariable
+template <>
+struct Hasher<UniformVariable> {
+ /// 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<DynamicIndex> {
@@ -69,9 +85,9 @@
/// 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 @@
/// @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<sem::Array>()) {
+ ty = arr->ElemType();
+ }
+ if (auto* mat = ty->As<sem::Matrix>()) {
+ if (MatrixNeedsDecomposing(mat)) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ // Scan structures for members that need forking
for (auto* ty : program->Types()) {
if (auto* str = ty->As<sem::Struct>()) {
if (str->UsedAs(ast::StorageClass::kUniform)) {
for (auto* member : str->Members()) {
- if (auto* mat = member->Type()->As<sem::Matrix>()) {
- 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 @@
/// 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<u32, DynamicIndex, Swizzle>;
+ /// 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<UniformVariable, u32, DynamicIndex, Swizzle>;
/// A vector of AccessIndex.
using AccessIndices = utils::Vector<AccessIndex, 8>;
@@ -182,7 +221,19 @@
// Map of structure member in ctx.src of a matrix type, to list of decomposed column
// members in ctx.dst.
utils::Hashmap<const sem::StructMember*, utils::Vector<const ast::StructMember*, 4>, 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<Symbol, 4> columns;
+ };
+
+ // Map of matrix type in ctx.src, to decomposed column structure in ctx.dst.
+ utils::Hashmap<const sem::Matrix*, Std140Matrix, 8> std140_mats;
/// AccessChain describes a chain of access expressions to uniform buffer variable.
struct AccessChain {
@@ -209,11 +260,11 @@
/// 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 @@
// 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<const ast::StructMember*, 4> column_members;
- for (uint32_t i = 0; i < num_columns; i++) {
- utils::Vector<const ast::Attribute*, 1> 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 @@
if (auto* std140_ty = Std140Type(v->Type()->UnwrapRef())) {
ctx.Replace(global->type, std140_ty);
std140_uniforms.Add(v);
+ continue;
}
}
}
@@ -355,10 +386,11 @@
}
}
- /// @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 @@
}
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<const ast::Attribute*, 1> attrs;
@@ -380,6 +430,46 @@
});
}
+ /// @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<const ast::StructMember*, 4> 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<const ast::StructMember*, 4> out;
+ for (uint32_t i = 0; i < num_columns; i++) {
+ utils::Vector<const ast::Attribute*, 1> 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 @@
[&](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<sem::Pointer>()) {
// 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 @@
},
[&](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<sem::Matrix>();
@@ -440,6 +532,15 @@
access.dynamic_indices.Push(a->Index());
}
expr = a->Object();
+
+ // Is the object a std140 decomposed matrix?
+ if (auto* mat = expr->Type()->UnwrapRef()->As<sem::Matrix>()) {
+ 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 @@
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 @@
/// 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 @@
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<const ast::Expression*, 8> 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 @@
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<const ast::Expression*, 8> 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 @@
/// 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<u32>(access.indices[i]);
- auto* mat_member = ty->As<sem::Struct>()->Members()[mat_member_idx];
- auto mat_columns = *std140_mats.Get(mat_member);
- auto column_idx = std::get<u32>(access.indices[i + 1]);
- expr = b.MemberAccessor(expr, mat_columns[column_idx]->symbol);
- ty = mat_member->Type()->As<sem::Matrix>()->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<u32>(chain.indices[std140_mat_idx + 1]);
+ if (auto* str = tint::As<sem::Struct>(ty)) {
+ // Structure member matrix. The columns are decomposed into the structure.
+ auto mat_member_idx = std::get<u32>(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<sem::Matrix>()->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<sem::Matrix>();
+ auto std140_mat = std140_mats.Get(ty->As<sem::Matrix>());
+ 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 @@
/// 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<DynamicIndex>(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<DynamicIndex>(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<const ast::CaseStatement*, 4> cases;
@@ -716,41 +856,57 @@
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<u32>(access.indices[std140_mat_idx]);
- auto* mat_member = ty->As<sem::Struct>()->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<sem::Matrix>()->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<sem::Struct>(ty)) {
+ // Structure member matrix. The columns are decomposed into the structure.
+ auto mat_member_idx = std::get<u32>(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<sem::Matrix>()->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<sem::Matrix>();
+ auto std140_mat = std140_mats.Get(ty->As<sem::Matrix>());
+ 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 @@
}
// 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 @@
/// 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<const ast::Statement*, 2> stmts;
@@ -811,25 +968,41 @@
auto* let = b.Let("s", b.AddressOf(expr));
stmts.Push(b.Decl(let));
- // Gather the decomposed matrix columns
- auto mat_member_idx = std::get<u32>(access.indices[std140_mat_idx]);
- auto* mat_member = ty->As<sem::Struct>()->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<const ast::MemberAccessorExpression*, 4> columns;
+ if (auto* str = tint::As<sem::Struct>(ty)) {
+ // Structure member matrix. The columns are decomposed into the structure.
+ auto mat_member_idx = std::get<u32>(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<sem::Matrix>();
+ auto std140_mat = std140_mats.Get(ty->As<sem::Matrix>());
+ 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 @@
/// 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<const ast::Expression*(size_t)> dynamic_index) {
+ auto& access = chain.indices[index];
+
+ if (std::get_if<UniformVariable>(&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<DynamicIndex>(&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 f987805..f41b1e3 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<f32>` matrices into `N`x`vec2<f32>` column vectors. Structure types that transitively
-/// use these forked structures as members are also forked. `var<uniform>` variables will use these
-/// forked structures, and expressions loading from these variables will do appropriate conversions
-/// to the regular WGSL types. As `matNx2<f32>` 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<f32>` matrices into `N`x`vec2<f32>` column vectors. Types that transitively use these
+/// forked types are also forked. `var<uniform>` variables will use these forked types, and
+/// expressions loading from these variables will do appropriate conversions to the regular WGSL
+/// types. As `matNx2<f32>` 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<Std140, Transform> {
diff --git a/src/tint/transform/std140_test.cc b/src/tint/transform/std140_test.cc
index 57e23e6..97936ad 100644
--- a/src/tint/transform/std140_test.cc
+++ b/src/tint/transform/std140_test.cc
@@ -109,7 +109,7 @@
src = utils::ReplaceAll(src, "${mat}", GetParam().Mat());
- EXPECT_FALSE(ShouldRun<Std140>(src));
+ EXPECT_EQ(ShouldRun<Std140>(src), GetParam().should_run);
}
INSTANTIATE_TEST_SUITE_P(Std140TestShouldRun,
@@ -129,7 +129,7 @@
TEST_F(Std140Test, EmptyModule) {
auto* src = R"()";
- auto* expect = R"()";
+ auto* expect = src;
auto got = Run<Std140>(src);
@@ -1037,7 +1037,7 @@
return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
}
-fn conv_arr_3_S(val : array<S_std140, 3u>) -> array<S, 3u> {
+fn conv_arr3_S(val : array<S_std140, 3u>) -> array<S, 3u> {
var arr : array<S, 3u>;
for(var i : u32; (i < 3u); i = (i + 1)) {
arr[i] = conv_S(val[i]);
@@ -1046,7 +1046,7 @@
}
fn f() {
- let l = conv_arr_3_S(a);
+ let l = conv_arr3_S(a);
}
)";
@@ -1563,6 +1563,1330 @@
EXPECT_EQ(expect, str(got));
}
+TEST_F(Std140Test, Mat4x2Uniform_LoadMatrix) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> m : mat4x2<f32>;
+
+fn f() {
+ let l = m;
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> m : mat4x2_f32;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn f() {
+ let l = conv_mat4x2_f32(m);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat2x2Uniform_LoadColumn0) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
+
+fn f() {
+ let l = a[0];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat2x2_f32;
+
+fn f() {
+ let l = a.col0;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat4x2Uniform_LoadColumn1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
+
+fn f() {
+ let l = a[1];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat4x2_f32;
+
+fn f() {
+ let l = a.col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat2x2Uniform_LoadColumnI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
+
+fn f() {
+ let I = 1;
+
+ let l = a[I];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat2x2_f32;
+
+fn load_a_p0(p0 : u32) -> vec2<f32> {
+ switch(p0) {
+ case 0u: {
+ return a.col0;
+ }
+ case 1u: {
+ return a.col1;
+ }
+ default: {
+ return vec2<f32>();
+ }
+ }
+}
+
+fn f() {
+ let I = 1;
+ let l = load_a_p0(u32(I));
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Swizzle) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
+
+fn f() {
+ let l = a[1].yx;
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat2x2_f32;
+
+fn f() {
+ let l = a.col1.yx;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat4x2Uniform_LoadColumnISwizzle) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
+
+fn f() {
+ let I = 1;
+
+ let l = a[I].yx;
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat4x2_f32;
+
+fn load_a_p0_yx(p0 : u32) -> vec2<f32> {
+ 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<f32>();
+ }
+ }
+}
+
+fn f() {
+ let I = 1;
+ let l = load_a_p0_yx(u32(I));
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat2x2Uniform_LoadColumn1Element1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat2x2<f32>;
+
+fn f() {
+ let l = a[1][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : mat2x2_f32;
+
+fn f() {
+ let l = a.col1[1u];
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, Mat4x2Uniform_LoadColumnIElementI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : mat4x2<f32>;
+
+fn f() {
+ let I = 1;
+
+ let l = a[I][I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat2x2Uniform_LoadArray) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
+
+fn f() {
+ let l = a;
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+
+fn f() {
+ let l = a[0];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn f() {
+ let l = conv_mat4x2_f32(a[0u]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
+
+fn f() {
+ let l = a[1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+ let l = conv_mat2x2_f32(a[1u]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrixI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+
+fn f() {
+ let I = 1;
+ let l = a[I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn f() {
+ let I = 1;
+ let l = conv_mat4x2_f32(a[I]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrix1Column0) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
+
+fn f() {
+ let l = a[1][0];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
+
+fn f() {
+ let l = a[1u].col0;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix0Column1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+
+fn f() {
+ let l = a[0][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+
+fn f() {
+ let l = a[0u].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat2x2Uniform_LoadMatrixIColumn1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat2x2<f32>, 3>;
+
+fn f() {
+ let I = 1;
+ let l = a[I][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat2x2_f32, 3u>;
+
+fn f() {
+ let I = 1;
+ let l = a[I].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayMat4x2Uniform_LoadMatrix1ColumnI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<mat4x2<f32>, 3>;
+
+fn f() {
+ let I = 1;
+ let l = a[1][I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<mat4x2_f32, 3u>;
+
+fn load_a_1_p0(p0 : u32) -> vec2<f32> {
+ 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<f32>();
+ }
+ }
+}
+
+fn f() {
+ let I = 1;
+ let l = load_a_1_p0(u32(I));
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrays) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+ let l = a;
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<array<mat2x2_f32, 3u>, 4u>) -> array<array<mat2x2<f32>, 3u>, 4u> {
+ var arr : array<array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadArray0) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
+
+fn f() {
+ let l = a[0];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn conv_arr3_mat4x2_f32(val : array<mat4x2_f32, 3u>) -> array<mat4x2<f32>, 3u> {
+ var arr : array<mat4x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArray1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>,4>;
+
+fn f() {
+ let l = a[1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadArrayI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>,4>;
+
+fn f() {
+ let I = 1;
+ let l = a[I];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrix12Column0) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+ let l = a[1][2][0];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+ let l = a[1u][2u].col0;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix2IColumn1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
+
+fn f() {
+ let I = 1;
+ let l = a[2][I][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
+
+fn f() {
+ let I = 1;
+ let l = a[2u][I].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixI2Column1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+ let I = 1;
+ let l = a[I][2][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+ let I = 1;
+ let l = a[I][2u].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat2x2Uniform_LoadMatrixIIColumn1) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2<f32>, 3>, 4>;
+
+fn f() {
+ let I = 1;
+ let l = a[I][I][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat2x2_f32, 3u>, 4u>;
+
+fn f() {
+ let I = 1;
+ let l = a[I][I].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, ArrayArrayMat4x2Uniform_LoadMatrix12ColumnI) {
+ auto* src = R"(
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2<f32>, 3>, 4>;
+
+fn f() {
+ let I = 1;
+ let l = a[1][2][I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> a : array<array<mat4x2_f32, 3u>, 4u>;
+
+fn load_a_1_2_p0(p0 : u32) -> vec2<f32> {
+ 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<f32>();
+ }
+ }
+}
+
+fn f() {
+ let I = 1;
+ let l = load_a_1_2_p0(u32(I));
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadStruct) {
+ auto* src = R"(
+struct S {
+ a : array<mat2x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s;
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat2x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat2x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadArray) {
+ auto* src = R"(
+struct S {
+ a : array<mat2x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s.a;
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat2x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat2x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn conv_arr3_mat2x2_f32(val : array<mat2x2_f32, 3u>) -> array<mat2x2<f32>, 3u> {
+ var arr : array<mat2x2<f32>, 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<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0) {
+ auto* src = R"(
+struct S {
+ a : array<mat4x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s.a[0];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat4x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat4x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn f() {
+ let l = conv_mat4x2_f32(s.a[0u]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1) {
+ auto* src = R"(
+struct S {
+ a : array<mat2x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s.a[1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat2x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat2x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat2x2_f32(val : mat2x2_f32) -> mat2x2<f32> {
+ return mat2x2<f32>(val.col0, val.col1);
+}
+
+fn f() {
+ let l = conv_mat2x2_f32(s.a[1u]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrixI) {
+ auto* src = R"(
+struct S {
+ a : array<mat4x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let I = 1;
+ let l = s.a[I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat4x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat4x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn conv_mat4x2_f32(val : mat4x2_f32) -> mat4x2<f32> {
+ return mat4x2<f32>(val.col0, val.col1, val.col2, val.col3);
+}
+
+fn f() {
+ let I = 1;
+ let l = conv_mat4x2_f32(s.a[I]);
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrix1Column0) {
+ auto* src = R"(
+struct S {
+ a : array<mat2x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s.a[1][0];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat2x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat2x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+ let l = s.a[1u].col0;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix0Column1) {
+ auto* src = R"(
+struct S {
+ a : array<mat4x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let l = s.a[0][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat4x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat4x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+ let l = s.a[0u].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat2x2Uniform_LoadMatrixIColumn1) {
+ auto* src = R"(
+struct S {
+ a : array<mat2x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let I = 1;
+ let l = s.a[I][1];
+}
+)";
+
+ auto* expect = R"(
+struct mat2x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat2x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat2x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn f() {
+ let I = 1;
+ let l = s.a[I].col1;
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
+TEST_F(Std140Test, StructArrayMat4x2Uniform_LoadMatrix1ColumnI) {
+ auto* src = R"(
+struct S {
+ a : array<mat4x2<f32>, 3>,
+};
+
+@group(0) @binding(0) var<uniform> s : S;
+
+fn f() {
+ let I = 1;
+ let l = s.a[1][I];
+}
+)";
+
+ auto* expect = R"(
+struct mat4x2_f32 {
+ col0 : vec2<f32>,
+ col1 : vec2<f32>,
+ col2 : vec2<f32>,
+ col3 : vec2<f32>,
+}
+
+struct S {
+ a : array<mat4x2<f32>, 3>,
+}
+
+struct S_std140 {
+ a : array<mat4x2_f32, 3u>,
+}
+
+@group(0) @binding(0) var<uniform> s : S_std140;
+
+fn load_s_a_1_p0(p0 : u32) -> vec2<f32> {
+ 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<f32>();
+ }
+ }
+}
+
+fn f() {
+ let I = 1;
+ let l = load_s_a_1_p0(u32(I));
+}
+)";
+
+ auto got = Run<Std140>(src);
+
+ EXPECT_EQ(expect, str(got));
+}
+
TEST_F(Std140Test, ArrayStructArrayStructMat4x2Uniform_Loads) {
auto* src = R"(
struct Inner {
@@ -1614,7 +2938,7 @@
return Inner(mat4x2<f32>(val.m_0, val.m_1, val.m_2, val.m_3));
}
-fn conv_arr_4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
var arr : array<Inner, 4u>;
for(var i : u32; (i < 4u); i = (i + 1)) {
arr[i] = conv_Inner(val[i]);
@@ -1623,10 +2947,10 @@
}
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<Outer_std140, 4u>) -> array<Outer, 4u> {
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
var arr : array<Outer, 4u>;
for(var i : u32; (i < 4u); i = (i + 1)) {
arr[i] = conv_Outer(val[i]);
@@ -1641,9 +2965,9 @@
fn f() {
let I = 1;
- let l_a : array<Outer, 4> = conv_arr_4_Outer(a);
+ let l_a : array<Outer, 4> = conv_arr4_Outer(a);
let l_a_1 : Outer = conv_Outer(a[1u]);
- let l_a_2_a : array<Inner, 4> = conv_arr_4_Inner(a[2u].a);
+ let l_a_2_a : array<Inner, 4> = 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<f32> = load_a_0_a_2_m();
let l_a_1_a_3_m_0 : vec2<f32> = a[1u].a[3u].m_0;
@@ -1717,7 +3041,7 @@
return Inner(mat4x2<f32>(val.m_0, val.m_1, val.m_2, val.m_3));
}
-fn conv_arr_4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
+fn conv_arr4_Inner(val : array<Inner_std140, 4u>) -> array<Inner, 4u> {
var arr : array<Inner, 4u>;
for(var i : u32; (i < 4u); i = (i + 1)) {
arr[i] = conv_Inner(val[i]);
@@ -1726,10 +3050,10 @@
}
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<Outer_std140, 4u>) -> array<Outer, 4u> {
+fn conv_arr4_Outer(val : array<Outer_std140, 4u>) -> array<Outer, 4u> {
var arr : array<Outer, 4u>;
for(var i : u32; (i < 4u); i = (i + 1)) {
arr[i] = conv_Outer(val[i]);
@@ -1744,15 +3068,15 @@
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<Outer, 4> = conv_arr_4_Outer(a);
+ let l_a : array<Outer, 4> = conv_arr4_Outer(a);
let l_a_3 : Outer = conv_Outer(a[3u]);
- let l_a_3_a : array<Inner, 4> = conv_arr_4_Inner(a[3u].a);
+ let l_a_3_a : array<Inner, 4> = 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<f32> = load_a_3_a_2_m();
let l_a_3_a_2_m_1 : vec2<f32> = a[3u].a[2u].m_1;
@@ -1801,7 +3125,7 @@
return S(mat3x2<f32>(val.m_0, val.m_1, val.m_2));
}
-fn conv_arr_4_S(val : array<S_std140, 4u>) -> array<S, 4u> {
+fn conv_arr4_S(val : array<S_std140, 4u>) -> array<S, 4u> {
var arr : array<S, 4u>;
for(var i : u32; (i < 4u); i = (i + 1)) {
arr[i] = conv_S(val[i]);
@@ -1810,7 +3134,7 @@
}
fn f() {
- s = conv_arr_4_S(u);
+ s = conv_arr4_S(u);
}
)";
@@ -1827,7 +3151,7 @@
}
@group(0) @binding(0) var<uniform> u : array<S, 4>;
-@group(0) @binding(1) var<workgroup> w : array<S, 4>;
+var<workgroup> w : array<S, 4>;
fn f() {
w[0] = u[1];
@@ -1835,9 +3159,32 @@
)";
auto* expect =
- R"(test:8:38 error: non-resource variables must not have @group or @binding attributes
-@group(0) @binding(1) var<workgroup> w : array<S, 4>;
- ^
+ R"(
+struct S {
+ v : vec4<i32>,
+ @size(64)
+ m : mat3x2<f32>,
+}
+
+struct S_std140 {
+ v : vec4<i32>,
+ m_0 : vec2<f32>,
+ m_1 : vec2<f32>,
+ @size(48)
+ m_2 : vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> u : array<S_std140, 4u>;
+
+var<workgroup> w : array<S, 4>;
+
+fn conv_S(val : S_std140) -> S {
+ return S(val.v, mat3x2<f32>(val.m_0, val.m_1, val.m_2));
+}
+
+fn f() {
+ w[0] = conv_S(u[1u]);
+}
)";
auto got = Run<Std140>(src);
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 5031329..d051981 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -244,8 +244,7 @@
manager.Add<transform::AddEmptyEntryPoint>();
manager.Add<transform::AddBlockAttribute>();
- // Std140 must come after PromoteSideEffectsToDecl and AddBlockAttribute
- // Std140 must come before SimplifyPointers.
+ // Std140 must come after PromoteSideEffectsToDecl and before SimplifyPointers.
manager.Add<transform::Std140>();
manager.Add<transform::SimplifyPointers>();
diff --git a/src/tint/writer/spirv/generator_impl.cc b/src/tint/writer/spirv/generator_impl.cc
index 2a2c25c..bf92bf9 100644
--- a/src/tint/writer/spirv/generator_impl.cc
+++ b/src/tint/writer/spirv/generator_impl.cc
@@ -87,7 +87,8 @@
manager.Add<transform::AddEmptyEntryPoint>();
manager.Add<transform::AddBlockAttribute>();
- // Std140 must come after PromoteSideEffectsToDecl, AddBlockAttribute
+ // Std140 must come after PromoteSideEffectsToDecl.
+ // Std140 must come before VarForDynamicIndex and ForLoopToLoop.
manager.Add<transform::Std140>();
// 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 3b56852..265b946 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 @@
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 b9a3ee9..40ede28 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 a3d6e08..19803ad 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 0e6ccba..1274970 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 ffcbc7c..2bffe0d 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 399fe03..3890b7a 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 bc291fd..ad45982 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 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 8f407ac..cdbf08f 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 59ec729..2118347 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 922f2c7..c91d661 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 2a920f8..c6be613 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 19eba56..1edbc86 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 8dcc07d..e459ce3 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 @@
}
}
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 495667c..e70212f 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
+ OpBranch %64
+ %64 = OpLabel
+ OpLoopMerge %65 %66 None
+ OpBranch %67
+ %67 = OpLabel
+ %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
- %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
+ %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 %65
- %67 = OpLabel
- %69 = OpLoad %uint %local_invocation_index_1
- %68 = OpFunctionCall %void %f_inner %69
+ %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 a71a143..991d478 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 @@
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 11457bd..40c95ac 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 ef740a1..bd894de 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 d69110b..844eddb 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 850d586..7097f20 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 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 8ee216d..17a9c66 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 0b73e75..01b3ece 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 41ac892..f22ef5d 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 7eb1bf5..b7e9977 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 f922154..ed2b150 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 6ca89c7..df52a3b 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 @@
}
}
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 d38bf92..4b7fada 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
+ 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
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
+ %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 %65
- %67 = OpLabel
- %69 = OpLoad %uint %local_invocation_index_1
- %68 = OpFunctionCall %void %f_inner %69
+ %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 e27a647..90e0cf3 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 @@
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 @@
}
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 @@
}
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 7950eac..796a192 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 f00bbf5..3564979 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 @@
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 @@
}
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 @@
}
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 6a3a339..de1047e 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 452c603..daaf731 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 @@
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 @@
}
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 627852b..facd977 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 ce7f2ce..9634531 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 @@
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 @@
}
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 118e476..57765b4 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 0fdf832..ec19f64 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 @@
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 @@
}
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 8769096..6f393c7 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 9204f46..cdc0450 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 @@
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 @@
}
}
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 5e253f9..a6922dc 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 accf517..ea06cdd 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 @@
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 @@
}
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 @@
}
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 bb1c350..eb9e73b 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 2d72a86..21e940c 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 @@
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 @@
}
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 @@
}
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 cfe1926..6f790a8 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 720e66b..41ff2a8 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 @@
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 @@
}
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 148b7b6..e7483d2 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 5fa11e4..7c90023 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 @@
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 @@
}
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 0320931..4cadc2f 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 ccd6e88..4013cf5 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 @@
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 @@
}
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 3032953..93ef04f 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 fd14f19..9c72f93 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 @@
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 @@
}
}
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 9db5af8..be09c71 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 7e60332..4bffcae 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 @@
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 @@
}
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 @@
}
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 2a4d2ca..9a4f081 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 c14425b..658fe9e 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 @@
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 @@
}
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 @@
}
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 3cd3ef3..730d12b 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 42fa3a1..43a4f88 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 @@
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 @@
}
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 06de1ef..63abbf3 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 658610e..1ff8aa4 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 @@
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 @@
}
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 ea4bf22..e0ac972 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 90098bd..d9b6a9f 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 @@
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 @@
}
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 5d20562..bcbfadc5 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 07cabf9..2e8a05f 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 @@
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 @@
}
}
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 80ec01c..a690ffc 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
