encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

tint/transform: Inline HLSL uniform / storage buffers 

Change the DecomposeMemoryAccess to behave more like the DirectVariableAccess transform, in that it'll inline the access of buffer variable into the load / store helper functions, instead of passing the array down.

This avoids large array copies observed with FXC, which can have *severe* performance costs.

Fixed: tint:1819
Change-Id: I52eb3f908813f72ab9da446743e24a2637158309
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/121460
Kokoro: Kokoro <noreply+kokoro@google.com>
Auto-Submit: Ben Clayton <bclayton@google.com>
Reviewed-by: James Price <jrprice@google.com>
Commit-Queue: James Price <jrprice@google.com>
This commit is contained in:
Ben Clayton 2023-02-24 17:16:55 +00:00 committed by Dawn LUCI CQ
parent 7052cb57ff
commit 1a1b5278d5
937 changed files with 9619 additions and 9678 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
src/tint/transform/decompose_memory_access.cc
View File

@ -108,33 +108,29 @@ struct OffsetBinOp : Offset {
/// LoadStoreKey is the unordered map key to a load or store intrinsic. /// LoadStoreKey is the unordered map key to a load or store intrinsic.
struct LoadStoreKey { struct LoadStoreKey {
builtin::AddressSpace const address_space; // buffer address space type::Type const* el_ty = nullptr; // element type
builtin::Access const access; // buffer access Symbol const buffer; // buffer name
type::Type const* buf_ty = nullptr; // buffer type
type::Type const* el_ty = nullptr; // element type
bool operator==(const LoadStoreKey& rhs) const { bool operator==(const LoadStoreKey& rhs) const {
return address_space == rhs.address_space && access == rhs.access && buf_ty == rhs.buf_ty && return el_ty == rhs.el_ty && buffer == rhs.buffer;
el_ty == rhs.el_ty;
} }
struct Hasher { struct Hasher {
inline std::size_t operator()(const LoadStoreKey& u) const { inline std::size_t operator()(const LoadStoreKey& u) const {
return utils::Hash(u.address_space, u.access, u.buf_ty, u.el_ty); return utils::Hash(u.el_ty, u.buffer);
} }
}; };
}; };
/// AtomicKey is the unordered map key to an atomic intrinsic. /// AtomicKey is the unordered map key to an atomic intrinsic.
struct AtomicKey { struct AtomicKey {
builtin::Access const access; // buffer access type::Type const* el_ty = nullptr; // element type
type::Type const* buf_ty = nullptr; // buffer type sem::BuiltinType const op; // atomic op
type::Type const* el_ty = nullptr; // element type Symbol const buffer; // buffer name
sem::BuiltinType const op; // atomic op
bool operator==(const AtomicKey& rhs) const { bool operator==(const AtomicKey& rhs) const {
return access == rhs.access && buf_ty == rhs.buf_ty && el_ty == rhs.el_ty && op == rhs.op; return el_ty == rhs.el_ty && op == rhs.op && buffer == rhs.buffer;
} }
struct Hasher { struct Hasher {
inline std::size_t operator()(const AtomicKey& u) const { inline std::size_t operator()(const AtomicKey& u) const {
return utils::Hash(u.access, u.buf_ty, u.el_ty, u.op); return utils::Hash(u.el_ty, u.op, u.buffer);
} }
}; };
}; };
@ -219,39 +215,41 @@ bool IntrinsicDataTypeFor(const type::Type* ty, DecomposeMemoryAccess::Intrinsic
return false; return false;
} }
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function to
/// to a stub function to load the type `ty`. /// load the type @p ty from the uniform or storage buffer with name @p buffer.
DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder, DecomposeMemoryAccess::Intrinsic* IntrinsicLoadFor(ProgramBuilder* builder,
const type::Type* ty,
builtin::AddressSpace address_space, builtin::AddressSpace address_space,
const type::Type* ty) { const Symbol& buffer) {
DecomposeMemoryAccess::Intrinsic::DataType type; DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) { if (!IntrinsicDataTypeFor(ty, type)) {
return nullptr; return nullptr;
} }
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>( return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
builder->ID(), builder->AllocateNodeID(), DecomposeMemoryAccess::Intrinsic::Op::kLoad, builder->ID(), builder->AllocateNodeID(), DecomposeMemoryAccess::Intrinsic::Op::kLoad, type,
address_space, type); address_space, buffer);
} }
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function to
/// to a stub function to store the type `ty`. /// store the type @p ty to the storage buffer with name @p buffer.
DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder, DecomposeMemoryAccess::Intrinsic* IntrinsicStoreFor(ProgramBuilder* builder,
builtin::AddressSpace address_space, const type::Type* ty,
const type::Type* ty) { const Symbol& buffer) {
DecomposeMemoryAccess::Intrinsic::DataType type; DecomposeMemoryAccess::Intrinsic::DataType type;
if (!IntrinsicDataTypeFor(ty, type)) { if (!IntrinsicDataTypeFor(ty, type)) {
return nullptr; return nullptr;
} }
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>( return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
builder->ID(), builder->AllocateNodeID(), DecomposeMemoryAccess::Intrinsic::Op::kStore, builder->ID(), builder->AllocateNodeID(), DecomposeMemoryAccess::Intrinsic::Op::kStore,
address_space, type); type, builtin::AddressSpace::kStorage, buffer);
} }
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied /// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function for
/// to a stub function for the atomic op and the type `ty`. /// the atomic op and the type @p ty.
DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder, DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
sem::BuiltinType ity, sem::BuiltinType ity,
const type::Type* ty) { const type::Type* ty,
const Symbol& buffer) {
auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad; auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
switch (ity) { switch (ity) {
case sem::BuiltinType::kAtomicLoad: case sem::BuiltinType::kAtomicLoad:
@ -299,15 +297,16 @@ DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
return nullptr; return nullptr;
} }
return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>( return builder->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
builder->ID(), builder->AllocateNodeID(), op, builtin::AddressSpace::kStorage, type); builder->ID(), builder->AllocateNodeID(), op, type, builtin::AddressSpace::kStorage,
buffer);
} }
/// BufferAccess describes a single storage or uniform buffer access /// BufferAccess describes a single storage or uniform buffer access
struct BufferAccess { struct BufferAccess {
sem::ValueExpression const* var = nullptr; // Storage buffer variable sem::GlobalVariable const* var = nullptr; // Storage or uniform buffer variable
Offset const* offset = nullptr; // The byte offset on var Offset const* offset = nullptr; // The byte offset on var
type::Type const* type = nullptr; // The type of the access type::Type const* type = nullptr; // The type of the access
operator bool() const { return var; } // Returns true if valid operator bool() const { return var; } // Returns true if valid
}; };
/// Store describes a single storage or uniform buffer write /// Store describes a single storage or uniform buffer write
@ -452,238 +451,194 @@ struct DecomposeMemoryAccess::State {
return access; return access;
} }
/// LoadFunc() returns a symbol to an intrinsic function that loads an element of type `el_ty` /// LoadFunc() returns a symbol to an intrinsic function that loads an element of type @p el_ty
/// from a storage or uniform buffer of type `buf_ty`. /// from a storage or uniform buffer with name @p buffer.
/// The emitted function has the signature: /// The emitted function has the signature:
/// `fn load(buf : ptr<SC, buf_ty, A>, offset : u32) -> el_ty` /// `fn load(offset : u32) -> el_ty`
/// @param buf_ty the storage or uniform buffer type
/// @param el_ty the storage or uniform buffer element type /// @param el_ty the storage or uniform buffer element type
/// @param var_user the variable user /// @param address_space either kUniform or kStorage
/// @param buffer the symbol of the storage or uniform buffer variable, owned by the target
/// ProgramBuilder.
/// @return the name of the function that performs the load /// @return the name of the function that performs the load
Symbol LoadFunc(const type::Type* buf_ty, Symbol LoadFunc(const type::Type* el_ty,
const type::Type* el_ty, builtin::AddressSpace address_space,
const sem::VariableUser* var_user) { const Symbol& buffer) {
auto address_space = var_user->Variable()->AddressSpace(); return utils::GetOrCreate(load_funcs, LoadStoreKey{el_ty, buffer}, [&] {
auto access = var_user->Variable()->Access(); utils::Vector params{b.Param("offset", b.ty.u32())};
if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(
load_funcs, LoadStoreKey{address_space, access, buf_ty, el_ty}, [&] {
utils::Vector params{
b.Param("buffer",
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), address_space, access),
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
b.Param("offset", b.ty.u32()),
};
auto name = b.Sym(); auto name = b.Symbols().New(ctx.dst->Symbols().NameFor(buffer) + "_load");
if (auto* intrinsic = IntrinsicLoadFor(ctx.dst, address_space, el_ty)) { if (auto* intrinsic = IntrinsicLoadFor(ctx.dst, el_ty, address_space, buffer)) {
auto el_ast_ty = CreateASTTypeFor(ctx, el_ty); auto el_ast_ty = CreateASTTypeFor(ctx, el_ty);
b.Func(name, params, el_ast_ty, nullptr, b.Func(name, params, el_ast_ty, nullptr,
utils::Vector{ utils::Vector{
intrinsic, intrinsic,
b.Disable(ast::DisabledValidation::kFunctionHasNoBody), b.Disable(ast::DisabledValidation::kFunctionHasNoBody),
}); });
} else if (auto* arr_ty = el_ty->As<type::Array>()) { } else if (auto* arr_ty = el_ty->As<type::Array>()) {
// fn load_func(buffer : buf_ty, offset : u32) -> array<T, N> { // fn load_func(buffer : buf_ty, offset : u32) -> array<T, N> {
// var arr : array<T, N>; // var arr : array<T, N>;
// for (var i = 0u; i < array_count; i = i + 1) { // for (var i = 0u; i < array_count; i = i + 1) {
// arr[i] = el_load_func(buffer, offset + i * array_stride) // arr[i] = el_load_func(buffer, offset + i * array_stride)
// } // }
// return arr; // return arr;
// } // }
auto load = LoadFunc(buf_ty, arr_ty->ElemType()->UnwrapRef(), var_user); auto load = LoadFunc(arr_ty->ElemType()->UnwrapRef(), address_space, buffer);
auto* arr = b.Var(b.Symbols().New("arr"), CreateASTTypeFor(ctx, arr_ty)); auto* arr = b.Var(b.Symbols().New("arr"), CreateASTTypeFor(ctx, arr_ty));
auto* i = b.Var(b.Symbols().New("i"), b.Expr(0_u)); auto* i = b.Var(b.Symbols().New("i"), b.Expr(0_u));
auto* for_init = b.Decl(i); auto* for_init = b.Decl(i);
auto arr_cnt = arr_ty->ConstantCount(); auto arr_cnt = arr_ty->ConstantCount();
if (TINT_UNLIKELY(!arr_cnt)) { if (TINT_UNLIKELY(!arr_cnt)) {
// Non-constant counts should not be possible: // Non-constant counts should not be possible:
// * Override-expression counts can only be applied to workgroup arrays, and // * Override-expression counts can only be applied to workgroup arrays, and
// this method only handles storage and uniform. // this method only handles storage and uniform.
// * Runtime-sized arrays are not loadable. // * Runtime-sized arrays are not loadable.
TINT_ICE(Transform, b.Diagnostics()) TINT_ICE(Transform, b.Diagnostics()) << "unexpected non-constant array count";
<< "unexpected non-constant array count"; arr_cnt = 1;
arr_cnt = 1; }
auto* for_cond = b.create<ast::BinaryExpression>(
ast::BinaryOp::kLessThan, b.Expr(i), b.Expr(u32(arr_cnt.value())));
auto* for_cont = b.Assign(i, b.Add(i, 1_u));
auto* arr_el = b.IndexAccessor(arr, i);
auto* el_offset = b.Add(b.Expr("offset"), b.Mul(i, u32(arr_ty->Stride())));
auto* el_val = b.Call(load, el_offset);
auto* for_loop =
b.For(for_init, for_cond, for_cont, b.Block(b.Assign(arr_el, el_val)));
b.Func(name, params, CreateASTTypeFor(ctx, arr_ty),
utils::Vector{
b.Decl(arr),
for_loop,
b.Return(arr),
});
} else {
utils::Vector<const ast::Expression*, 8> values;
if (auto* mat_ty = el_ty->As<type::Matrix>()) {
auto* vec_ty = mat_ty->ColumnType();
Symbol load = LoadFunc(vec_ty, address_space, buffer);
for (uint32_t i = 0; i < mat_ty->columns(); i++) {
auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride()));
values.Push(b.Call(load, offset));
} }
auto* for_cond = b.create<ast::BinaryExpression>( } else if (auto* str = el_ty->As<sem::Struct>()) {
ast::BinaryOp::kLessThan, b.Expr(i), b.Expr(u32(arr_cnt.value()))); for (auto* member : str->Members()) {
auto* for_cont = b.Assign(i, b.Add(i, 1_u)); auto* offset = b.Add("offset", u32(member->Offset()));
auto* arr_el = b.IndexAccessor(arr, i); Symbol load = LoadFunc(member->Type()->UnwrapRef(), address_space, buffer);
auto* el_offset = b.Add(b.Expr("offset"), b.Mul(i, u32(arr_ty->Stride()))); values.Push(b.Call(load, offset));
auto* el_val = b.Call(load, "buffer", el_offset); }
auto* for_loop = }
b.For(for_init, for_cond, for_cont, b.Block(b.Assign(arr_el, el_val))); b.Func(name, params, CreateASTTypeFor(ctx, el_ty),
utils::Vector{
b.Return(b.Call(CreateASTTypeFor(ctx, el_ty), values)),
});
}
return name;
});
}
b.Func(name, params, CreateASTTypeFor(ctx, arr_ty), /// StoreFunc() returns a symbol to an intrinsic function that stores an element of type @p
utils::Vector{ /// el_ty to the storage buffer @p buffer. The function has the signature:
b.Decl(arr), /// `fn store(offset : u32, value : el_ty)`
for_loop, /// @param el_ty the storage buffer element type
b.Return(arr), /// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
}); /// @return the name of the function that performs the store
} else { Symbol StoreFunc(const type::Type* el_ty, const Symbol& buffer) {
utils::Vector<const ast::Expression*, 8> values; return utils::GetOrCreate(store_funcs, LoadStoreKey{el_ty, buffer}, [&] {
if (auto* mat_ty = el_ty->As<type::Matrix>()) { utils::Vector params{
b.Param("offset", b.ty.u32()),
b.Param("value", CreateASTTypeFor(ctx, el_ty)),
};
auto name = b.Symbols().New(ctx.dst->Symbols().NameFor(buffer) + "_store");
if (auto* intrinsic = IntrinsicStoreFor(ctx.dst, el_ty, buffer)) {
b.Func(name, params, b.ty.void_(), nullptr,
utils::Vector{
intrinsic,
b.Disable(ast::DisabledValidation::kFunctionHasNoBody),
});
} else {
auto body = Switch<utils::Vector<const ast::Statement*, 8>>(
el_ty, //
[&](const type::Array* arr_ty) {
// fn store_func(buffer : buf_ty, offset : u32, value : el_ty) {
// var array = value; // No dynamic indexing on constant arrays
// for (var i = 0u; i < array_count; i = i + 1) {
// arr[i] = el_store_func(buffer, offset + i * array_stride,
// value[i])
// }
// return arr;
// }
auto* array = b.Var(b.Symbols().New("array"), b.Expr("value"));
auto store = StoreFunc(arr_ty->ElemType()->UnwrapRef(), buffer);
auto* i = b.Var(b.Symbols().New("i"), b.Expr(0_u));
auto* for_init = b.Decl(i);
auto arr_cnt = arr_ty->ConstantCount();
if (TINT_UNLIKELY(!arr_cnt)) {
// Non-constant counts should not be possible:
// * Override-expression counts can only be applied to workgroup
// arrays, and this method only handles storage and uniform.
// * Runtime-sized arrays are not storable.
TINT_ICE(Transform, b.Diagnostics())
<< "unexpected non-constant array count";
arr_cnt = 1;
}
auto* for_cond = b.create<ast::BinaryExpression>(
ast::BinaryOp::kLessThan, b.Expr(i), b.Expr(u32(arr_cnt.value())));
auto* for_cont = b.Assign(i, b.Add(i, 1_u));
auto* arr_el = b.IndexAccessor(array, i);
auto* el_offset = b.Add(b.Expr("offset"), b.Mul(i, u32(arr_ty->Stride())));
auto* store_stmt = b.CallStmt(b.Call(store, el_offset, arr_el));
auto* for_loop = b.For(for_init, for_cond, for_cont, b.Block(store_stmt));
return utils::Vector{b.Decl(array), for_loop};
},
[&](const type::Matrix* mat_ty) {
auto* vec_ty = mat_ty->ColumnType(); auto* vec_ty = mat_ty->ColumnType();
Symbol load = LoadFunc(buf_ty, vec_ty, var_user); Symbol store = StoreFunc(vec_ty, buffer);
utils::Vector<const ast::Statement*, 4> stmts;
for (uint32_t i = 0; i < mat_ty->columns(); i++) { for (uint32_t i = 0; i < mat_ty->columns(); i++) {
auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride())); auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride()));
values.Push(b.Call(load, "buffer", offset)); auto* element = b.IndexAccessor("value", u32(i));
auto* call = b.Call(store, offset, element);
stmts.Push(b.CallStmt(call));
} }
} else if (auto* str = el_ty->As<sem::Struct>()) { return stmts;
},
[&](const sem::Struct* str) {
utils::Vector<const ast::Statement*, 8> stmts;
for (auto* member : str->Members()) { for (auto* member : str->Members()) {
auto* offset = b.Add("offset", u32(member->Offset())); auto* offset = b.Add("offset", u32(member->Offset()));
Symbol load = LoadFunc(buf_ty, member->Type()->UnwrapRef(), var_user); auto* element = b.MemberAccessor("value", ctx.Clone(member->Name()));
values.Push(b.Call(load, "buffer", offset)); Symbol store = StoreFunc(member->Type()->UnwrapRef(), buffer);
auto* call = b.Call(store, offset, element);
stmts.Push(b.CallStmt(call));
} }
} return stmts;
b.Func(name, params, CreateASTTypeFor(ctx, el_ty), });
utils::Vector{
b.Return(b.Call(CreateASTTypeFor(ctx, el_ty), values)), b.Func(name, params, b.ty.void_(), body);
}); }
}
return name; return name;
}); });
} }
/// StoreFunc() returns a symbol to an intrinsic function that stores an /// AtomicFunc() returns a symbol to an intrinsic function that performs an atomic operation on
/// element of type `el_ty` to a storage buffer of type `buf_ty`. /// the storage buffer @p buffer. The function has the signature:
/// The function has the signature: // `fn atomic_op(offset : u32, ...) -> T`
/// `fn store(buf : ptr<SC, buf_ty, A>, offset : u32, value : el_ty)`
/// @param buf_ty the storage buffer type
/// @param el_ty the storage buffer element type
/// @param var_user the variable user
/// @return the name of the function that performs the store
Symbol StoreFunc(const type::Type* buf_ty,
const type::Type* el_ty,
const sem::VariableUser* var_user) {
auto address_space = var_user->Variable()->AddressSpace();
auto access = var_user->Variable()->Access();
if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(
store_funcs, LoadStoreKey{address_space, access, buf_ty, el_ty}, [&] {
utils::Vector params{
b.Param("buffer",
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), address_space, access),
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
b.Param("offset", b.ty.u32()),
b.Param("value", CreateASTTypeFor(ctx, el_ty)),
};
auto name = b.Sym();
if (auto* intrinsic = IntrinsicStoreFor(ctx.dst, address_space, el_ty)) {
b.Func(name, params, b.ty.void_(), nullptr,
utils::Vector{
intrinsic,
b.Disable(ast::DisabledValidation::kFunctionHasNoBody),
});
} else {
auto body = Switch<utils::Vector<const ast::Statement*, 8>>(
el_ty, //
[&](const type::Array* arr_ty) {
// fn store_func(buffer : buf_ty, offset : u32, value : el_ty) {
// var array = value; // No dynamic indexing on constant arrays
// for (var i = 0u; i < array_count; i = i + 1) {
// arr[i] = el_store_func(buffer, offset + i * array_stride,
// value[i])
// }
// return arr;
// }
auto* array = b.Var(b.Symbols().New("array"), b.Expr("value"));
auto store =
StoreFunc(buf_ty, arr_ty->ElemType()->UnwrapRef(), var_user);
auto* i = b.Var(b.Symbols().New("i"), b.Expr(0_u));
auto* for_init = b.Decl(i);
auto arr_cnt = arr_ty->ConstantCount();
if (TINT_UNLIKELY(!arr_cnt)) {
// Non-constant counts should not be possible:
// * Override-expression counts can only be applied to workgroup
// arrays, and this method only handles storage and uniform.
// * Runtime-sized arrays are not storable.
TINT_ICE(Transform, b.Diagnostics())
<< "unexpected non-constant array count";
arr_cnt = 1;
}
auto* for_cond = b.create<ast::BinaryExpression>(
ast::BinaryOp::kLessThan, b.Expr(i), b.Expr(u32(arr_cnt.value())));
auto* for_cont = b.Assign(i, b.Add(i, 1_u));
auto* arr_el = b.IndexAccessor(array, i);
auto* el_offset =
b.Add(b.Expr("offset"), b.Mul(i, u32(arr_ty->Stride())));
auto* store_stmt =
b.CallStmt(b.Call(store, "buffer", el_offset, arr_el));
auto* for_loop =
b.For(for_init, for_cond, for_cont, b.Block(store_stmt));
return utils::Vector{b.Decl(array), for_loop};
},
[&](const type::Matrix* mat_ty) {
auto* vec_ty = mat_ty->ColumnType();
Symbol store = StoreFunc(buf_ty, vec_ty, var_user);
utils::Vector<const ast::Statement*, 4> stmts;
for (uint32_t i = 0; i < mat_ty->columns(); i++) {
auto* offset = b.Add("offset", u32(i * mat_ty->ColumnStride()));
auto* element = b.IndexAccessor("value", u32(i));
auto* call = b.Call(store, "buffer", offset, element);
stmts.Push(b.CallStmt(call));
}
return stmts;
},
[&](const sem::Struct* str) {
utils::Vector<const ast::Statement*, 8> stmts;
for (auto* member : str->Members()) {
auto* offset = b.Add("offset", u32(member->Offset()));
auto* element =
b.MemberAccessor("value", ctx.Clone(member->Name()));
Symbol store =
StoreFunc(buf_ty, member->Type()->UnwrapRef(), var_user);
auto* call = b.Call(store, "buffer", offset, element);
stmts.Push(b.CallStmt(call));
}
return stmts;
});
b.Func(name, params, b.ty.void_(), body);
}
return name;
});
}
/// AtomicFunc() returns a symbol to an intrinsic function that performs an
/// atomic operation from a storage buffer of type `buf_ty`. The function has
/// the signature:
// `fn atomic_op(buf : ptr<storage, buf_ty, A>, offset : u32, ...) -> T`
/// @param buf_ty the storage buffer type
/// @param el_ty the storage buffer element type /// @param el_ty the storage buffer element type
/// @param intrinsic the atomic intrinsic /// @param intrinsic the atomic intrinsic
/// @param var_user the variable user /// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
/// @return the name of the function that performs the load /// @return the name of the function that performs the load
Symbol AtomicFunc(const type::Type* buf_ty, Symbol AtomicFunc(const type::Type* el_ty,
const type::Type* el_ty,
const sem::Builtin* intrinsic, const sem::Builtin* intrinsic,
const sem::VariableUser* var_user) { const Symbol& buffer) {
auto op = intrinsic->Type(); auto op = intrinsic->Type();
auto address_space = var_user->Variable()->AddressSpace(); return utils::GetOrCreate(atomic_funcs, AtomicKey{el_ty, op, buffer}, [&] {
auto access = var_user->Variable()->Access();
if (address_space != builtin::AddressSpace::kStorage) {
access = builtin::Access::kUndefined;
}
return utils::GetOrCreate(atomic_funcs, AtomicKey{access, buf_ty, el_ty, op}, [&] {
// The first parameter to all WGSL atomics is the expression to the // The first parameter to all WGSL atomics is the expression to the
// atomic. This is replaced with two parameters: the buffer and offset. // atomic. This is replaced with two parameters: the buffer and offset.
utils::Vector params{ utils::Vector params{b.Param("offset", b.ty.u32())};
b.Param("buffer",
b.ty.pointer(CreateASTTypeFor(ctx, buf_ty), builtin::AddressSpace::kStorage,
access),
utils::Vector{b.Disable(ast::DisabledValidation::kFunctionParameter)}),
b.Param("offset", b.ty.u32()),
};
// Other parameters are copied as-is: // Other parameters are copied as-is:
for (size_t i = 1; i < intrinsic->Parameters().Length(); i++) { for (size_t i = 1; i < intrinsic->Parameters().Length(); i++) {
@ -692,7 +647,7 @@ struct DecomposeMemoryAccess::State {
params.Push(b.Param("param_" + std::to_string(i), ty)); params.Push(b.Param("param_" + std::to_string(i), ty));
} }
auto* atomic = IntrinsicAtomicFor(ctx.dst, op, el_ty); auto* atomic = IntrinsicAtomicFor(ctx.dst, op, el_ty, buffer);
if (TINT_UNLIKELY(!atomic)) { if (TINT_UNLIKELY(!atomic)) {
TINT_ICE(Transform, b.Diagnostics()) TINT_ICE(Transform, b.Diagnostics())
<< "IntrinsicAtomicFor() returned nullptr for op " << op << " and type " << "IntrinsicAtomicFor() returned nullptr for op " << op << " and type "
@ -720,7 +675,7 @@ struct DecomposeMemoryAccess::State {
ret_ty = CreateASTTypeFor(ctx, intrinsic->ReturnType()); ret_ty = CreateASTTypeFor(ctx, intrinsic->ReturnType());
} }
auto name = b.Symbols().New(std::string{"tint_"} + intrinsic->str()); auto name = b.Symbols().New(ctx.dst->Symbols().NameFor(buffer) + intrinsic->str());
b.Func(name, std::move(params), ret_ty, nullptr, b.Func(name, std::move(params), ret_ty, nullptr,
utils::Vector{ utils::Vector{
atomic, atomic,
@ -734,9 +689,10 @@ struct DecomposeMemoryAccess::State {
DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid, DecomposeMemoryAccess::Intrinsic::Intrinsic(ProgramID pid,
ast::NodeID nid, ast::NodeID nid,
Op o, Op o,
builtin::AddressSpace sc, DataType ty,
DataType ty) builtin::AddressSpace as,
: Base(pid, nid), op(o), address_space(sc), type(ty) {} const Symbol& buf)
: Base(pid, nid), op(o), type(ty), address_space(as), buffer(buf) {}
DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default; DecomposeMemoryAccess::Intrinsic::~Intrinsic() = default;
std::string DecomposeMemoryAccess::Intrinsic::InternalName() const { std::string DecomposeMemoryAccess::Intrinsic::InternalName() const {
std::stringstream ss; std::stringstream ss;
@ -837,8 +793,9 @@ std::string DecomposeMemoryAccess::Intrinsic::InternalName() const {
const DecomposeMemoryAccess::Intrinsic* DecomposeMemoryAccess::Intrinsic::Clone( const DecomposeMemoryAccess::Intrinsic* DecomposeMemoryAccess::Intrinsic::Clone(
CloneContext* ctx) const { CloneContext* ctx) const {
auto buf = ctx->Clone(buffer);
return ctx->dst->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>( return ctx->dst->ASTNodes().Create<DecomposeMemoryAccess::Intrinsic>(
ctx->dst->ID(), ctx->dst->AllocateNodeID(), op, address_space, type); ctx->dst->ID(), ctx->dst->AllocateNodeID(), op, type, address_space, buf);
} }
bool DecomposeMemoryAccess::Intrinsic::IsAtomic() const { bool DecomposeMemoryAccess::Intrinsic::IsAtomic() const {
@ -872,15 +829,17 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src,
if (auto* ident = node->As<ast::IdentifierExpression>()) { if (auto* ident = node->As<ast::IdentifierExpression>()) {
// X // X
if (auto* sem_ident = sem.GetVal(ident)) { if (auto* sem_ident = sem.GetVal(ident)) {
if (auto* var = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) { if (auto* user = sem_ident->UnwrapLoad()->As<sem::VariableUser>()) {
if (var->Variable()->AddressSpace() == builtin::AddressSpace::kStorage || if (auto* global = user->Variable()->As<sem::GlobalVariable>()) {
var->Variable()->AddressSpace() == builtin::AddressSpace::kUniform) { if (global->AddressSpace() == builtin::AddressSpace::kStorage ||
// Variable to a storage or uniform buffer global->AddressSpace() == builtin::AddressSpace::kUniform) {
state.AddAccess(ident, { // Variable to a storage or uniform buffer
var, state.AddAccess(ident, {
state.ToOffset(0u), global,
var->Type()->UnwrapRef(), state.ToOffset(0u),
}); global->Type()->UnwrapRef(),
});
}
} }
} }
} }
@ -983,15 +942,12 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src,
if (auto access = state.TakeAccess(call_expr->args[0])) { if (auto access = state.TakeAccess(call_expr->args[0])) {
// atomic___(X) // atomic___(X)
ctx.Replace(call_expr, [=, &ctx, &state] { ctx.Replace(call_expr, [=, &ctx, &state] {
auto* buf = access.var->Declaration();
auto* offset = access.offset->Build(ctx); auto* offset = access.offset->Build(ctx);
auto* buf_ty = access.var->Type()->UnwrapRef();
auto* el_ty = access.type->UnwrapRef()->As<type::Atomic>()->Type(); auto* el_ty = access.type->UnwrapRef()->As<type::Atomic>()->Type();
Symbol func = state.AtomicFunc(buf_ty, el_ty, builtin, auto buffer = ctx.Clone(access.var->Declaration()->name->symbol);
access.var->As<sem::VariableUser>()); Symbol func = state.AtomicFunc(el_ty, builtin, buffer);
utils::Vector<const ast::Expression*, 8> args{ utils::Vector<const ast::Expression*, 8> args{offset};
ctx.dst->AddressOf(ctx.Clone(buf)), offset};
for (size_t i = 1; i < call_expr->args.Length(); i++) { for (size_t i = 1; i < call_expr->args.Length(); i++) {
auto* arg = call_expr->args[i]; auto* arg = call_expr->args[i];
args.Push(ctx.Clone(arg)); args.Push(ctx.Clone(arg));
@ -1014,26 +970,23 @@ Transform::ApplyResult DecomposeMemoryAccess::Apply(const Program* src,
} }
BufferAccess access = access_it->second; BufferAccess access = access_it->second;
ctx.Replace(expr, [=, &ctx, &state] { ctx.Replace(expr, [=, &ctx, &state] {
auto* buf = ctx.dst->AddressOf(ctx.CloneWithoutTransform(access.var->Declaration()));
auto* offset = access.offset->Build(ctx); auto* offset = access.offset->Build(ctx);
auto* buf_ty = access.var->Type()->UnwrapRef();
auto* el_ty = access.type->UnwrapRef(); auto* el_ty = access.type->UnwrapRef();
Symbol func = state.LoadFunc(buf_ty, el_ty, access.var->As<sem::VariableUser>()); auto buffer = ctx.Clone(access.var->Declaration()->name->symbol);
return ctx.dst->Call(func, buf, offset); Symbol func = state.LoadFunc(el_ty, access.var->AddressSpace(), buffer);
return ctx.dst->Call(func, offset);
}); });
} }
// And replace all storage and uniform buffer assignments with stores // And replace all storage and uniform buffer assignments with stores
for (auto store : state.stores) { for (auto store : state.stores) {
ctx.Replace(store.assignment, [=, &ctx, &state] { ctx.Replace(store.assignment, [=, &ctx, &state] {
auto* buf =
ctx.dst->AddressOf(ctx.CloneWithoutTransform((store.target.var->Declaration())));
auto* offset = store.target.offset->Build(ctx); auto* offset = store.target.offset->Build(ctx);
auto* buf_ty = store.target.var->Type()->UnwrapRef();
auto* el_ty = store.target.type->UnwrapRef(); auto* el_ty = store.target.type->UnwrapRef();
auto* value = store.assignment->rhs; auto* value = store.assignment->rhs;
Symbol func = state.StoreFunc(buf_ty, el_ty, store.target.var->As<sem::VariableUser>()); auto buffer = ctx.Clone(store.target.var->Declaration()->name->symbol);
auto* call = ctx.dst->Call(func, buf, offset, ctx.Clone(value)); Symbol func = state.StoreFunc(el_ty, buffer);
auto* call = ctx.dst->Call(func, offset, ctx.Clone(value));
return ctx.dst->CallStmt(call); return ctx.dst->CallStmt(call);
}); });
} }

30
src/tint/transform/decompose_memory_access.h
View File

@ -27,13 +27,12 @@ class CloneContext;
namespace tint::transform { namespace tint::transform {
/// DecomposeMemoryAccess is a transform used to replace storage and uniform /// DecomposeMemoryAccess is a transform used to replace storage and uniform buffer accesses with a
/// buffer accesses with a combination of load, store or atomic functions on /// combination of load, store or atomic functions on primitive types.
/// primitive types.
class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Transform> { class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Transform> {
public: public:
/// Intrinsic is an InternalAttribute that's used to decorate a stub function /// Intrinsic is an InternalAttribute that's used to decorate a stub function so that the HLSL
/// so that the HLSL transforms this into calls to /// transforms this into calls to
/// `[RW]ByteAddressBuffer.Load[N]()` or `[RW]ByteAddressBuffer.Store[N]()`, /// `[RW]ByteAddressBuffer.Load[N]()` or `[RW]ByteAddressBuffer.Store[N]()`,
/// with a possible cast. /// with a possible cast.
class Intrinsic final : public Castable<Intrinsic, ast::InternalAttribute> { class Intrinsic final : public Castable<Intrinsic, ast::InternalAttribute> {
@ -79,9 +78,15 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
/// @param pid the identifier of the program that owns this node /// @param pid the identifier of the program that owns this node
/// @param nid the unique node identifier /// @param nid the unique node identifier
/// @param o the op of the intrinsic /// @param o the op of the intrinsic
/// @param sc the address space of the buffer /// @param type the data type of the intrinsic
/// @param ty the data type of the intrinsic /// @param address_space the address space of the buffer
Intrinsic(ProgramID pid, ast::NodeID nid, Op o, builtin::AddressSpace sc, DataType ty); /// @param buffer the storage or uniform buffer name
Intrinsic(ProgramID pid,
ast::NodeID nid,
Op o,
DataType type,
builtin::AddressSpace address_space,
const Symbol& buffer);
/// Destructor /// Destructor
~Intrinsic() override; ~Intrinsic() override;
@ -100,11 +105,14 @@ class DecomposeMemoryAccess final : public Castable<DecomposeMemoryAccess, Trans
/// The op of the intrinsic /// The op of the intrinsic
const Op op; const Op op;
/// The address space of the buffer this intrinsic operates on
builtin::AddressSpace const address_space;
/// The type of the intrinsic /// The type of the intrinsic
const DataType type; const DataType type;
/// The address space of the buffer this intrinsic operates on
const builtin::AddressSpace address_space;
/// The buffer name
const Symbol buffer;
}; };
/// Constructor /// Constructor

2204
src/tint/transform/decompose_memory_access_test.cc
View File

File diff suppressed because it is too large Load Diff

100
src/tint/writer/hlsl/generator_impl.cc
View File

@ -1112,8 +1112,8 @@ bool GeneratorImpl::EmitUniformBufferAccess(
std::ostream& out, std::ostream& out,
const ast::CallExpression* expr, const ast::CallExpression* expr,
const transform::DecomposeMemoryAccess::Intrinsic* intrinsic) { const transform::DecomposeMemoryAccess::Intrinsic* intrinsic) {
const auto& args = expr->args; auto const buffer = program_->Symbols().NameFor(intrinsic->buffer);
auto* offset_arg = builder_.Sem().GetVal(args[1]); auto* const offset = expr->args[0];
// offset in bytes // offset in bytes
uint32_t scalar_offset_bytes = 0; uint32_t scalar_offset_bytes = 0;
@ -1129,7 +1129,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
// If true, use scalar_offset_index, otherwise use scalar_offset_index_expr // If true, use scalar_offset_index, otherwise use scalar_offset_index_expr
bool scalar_offset_constant = false; bool scalar_offset_constant = false;
if (auto* val = offset_arg->ConstantValue()) { if (auto* val = builder_.Sem().GetVal(offset)->ConstantValue()) {
TINT_ASSERT(Writer, val->Type()->Is<type::U32>()); TINT_ASSERT(Writer, val->Type()->Is<type::U32>());
scalar_offset_bytes = static_cast<uint32_t>(val->ValueAs<AInt>()); scalar_offset_bytes = static_cast<uint32_t>(val->ValueAs<AInt>());
scalar_offset_index = scalar_offset_bytes / 4; // bytes -> scalar index scalar_offset_index = scalar_offset_bytes / 4; // bytes -> scalar index
@ -1151,7 +1151,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
{ {
auto pre = line(); auto pre = line();
pre << "const uint " << scalar_offset_bytes_expr << " = ("; pre << "const uint " << scalar_offset_bytes_expr << " = (";
if (!EmitExpression(pre, args[1])) { // offset if (!EmitExpression(pre, offset)) {
return false; return false;
} }
pre << ");"; pre << ");";
@ -1162,7 +1162,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
scalar_offset_index_unified_expr = UniqueIdentifier("scalar_offset"); scalar_offset_index_unified_expr = UniqueIdentifier("scalar_offset");
auto pre = line(); auto pre = line();
pre << "const uint " << scalar_offset_index_unified_expr << " = ("; pre << "const uint " << scalar_offset_index_unified_expr << " = (";
if (!EmitExpression(pre, args[1])) { // offset if (!EmitExpression(pre, offset)) {
return false; return false;
} }
pre << ") / 4;"; pre << ") / 4;";
@ -1182,9 +1182,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
return result; return result;
}; };
auto load_u32_to = [&](std::ostream& target) { auto load_u32_to = [&](std::ostream& target) {
if (!EmitExpression(target, args[0])) { // buffer target << buffer;
return false;
}
if (scalar_offset_constant) { if (scalar_offset_constant) {
target << "[" << (scalar_offset_index / 4) << "]." target << "[" << (scalar_offset_index / 4) << "]."
<< swizzle[scalar_offset_index & 3]; << swizzle[scalar_offset_index & 3];
@ -1198,20 +1196,14 @@ bool GeneratorImpl::EmitUniformBufferAccess(
// Has a minimum alignment of 8 bytes, so is either .xy or .zw // Has a minimum alignment of 8 bytes, so is either .xy or .zw
auto load_vec2_u32_to = [&](std::ostream& target) { auto load_vec2_u32_to = [&](std::ostream& target) {
if (scalar_offset_constant) { if (scalar_offset_constant) {
if (!EmitExpression(target, args[0])) { // buffer target << buffer << "[" << (scalar_offset_index / 4) << "]"
return false; << ((scalar_offset_index & 2) == 0 ? ".xy" : ".zw");
}
target << "[" << (scalar_offset_index / 4) << "]";
target << ((scalar_offset_index & 2) == 0 ? ".xy" : ".zw");
} else { } else {
std::string ubo_load = UniqueIdentifier("ubo_load"); std::string ubo_load = UniqueIdentifier("ubo_load");
{ {
auto pre = line(); auto pre = line();
pre << "uint4 " << ubo_load << " = "; pre << "uint4 " << ubo_load << " = " << buffer << "["
if (!EmitExpression(pre, args[0])) { // buffer << scalar_offset_index_unified_expr << " / 4];";
return false;
}
pre << "[" << scalar_offset_index_unified_expr << " / 4];";
} }
target << "((" << scalar_offset_index_unified_expr << " & 2) ? " << ubo_load target << "((" << scalar_offset_index_unified_expr << " & 2) ? " << ubo_load
<< ".zw : " << ubo_load << ".xy)"; << ".zw : " << ubo_load << ".xy)";
@ -1221,9 +1213,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
auto load_vec2_u32 = [&] { return load_vec2_u32_to(out); }; auto load_vec2_u32 = [&] { return load_vec2_u32_to(out); };
// vec4 has a minimum alignment of 16 bytes, easiest case // vec4 has a minimum alignment of 16 bytes, easiest case
auto load_vec4_u32 = [&] { auto load_vec4_u32 = [&] {
if (!EmitExpression(out, args[0])) { // buffer out << buffer;
return false;
}
if (scalar_offset_constant) { if (scalar_offset_constant) {
out << "[" << (scalar_offset_index / 4) << "]"; out << "[" << (scalar_offset_index / 4) << "]";
} else { } else {
@ -1242,10 +1232,7 @@ bool GeneratorImpl::EmitUniformBufferAccess(
auto load_scalar_f16 = [&] { auto load_scalar_f16 = [&] {
// offset bytes = 4k, ((buffer[index].x) & 0xFFFF) // offset bytes = 4k, ((buffer[index].x) & 0xFFFF)
// offset bytes = 4k+2, ((buffer[index].x >> 16) & 0xFFFF) // offset bytes = 4k+2, ((buffer[index].x >> 16) & 0xFFFF)
out << "float16_t(f16tof32((("; out << "float16_t(f16tof32(((" << buffer;
if (!EmitExpression(out, args[0])) { // buffer
return false;
}
if (scalar_offset_constant) { if (scalar_offset_constant) {
out << "[" << (scalar_offset_index / 4) << "]." out << "[" << (scalar_offset_index / 4) << "]."
<< swizzle[scalar_offset_index & 3]; << swizzle[scalar_offset_index & 3];
@ -1413,7 +1400,9 @@ bool GeneratorImpl::EmitStorageBufferAccess(
std::ostream& out, std::ostream& out,
const ast::CallExpression* expr, const ast::CallExpression* expr,
const transform::DecomposeMemoryAccess::Intrinsic* intrinsic) { const transform::DecomposeMemoryAccess::Intrinsic* intrinsic) {
const auto& args = expr->args; auto const buffer = program_->Symbols().NameFor(intrinsic->buffer);
auto* const offset = expr->args[0];
auto* const value = expr->args[1];
using Op = transform::DecomposeMemoryAccess::Intrinsic::Op; using Op = transform::DecomposeMemoryAccess::Intrinsic::Op;
using DataType = transform::DecomposeMemoryAccess::Intrinsic::DataType; using DataType = transform::DecomposeMemoryAccess::Intrinsic::DataType;
@ -1423,15 +1412,12 @@ bool GeneratorImpl::EmitStorageBufferAccess(
if (cast) { if (cast) {
out << cast << "("; out << cast << "(";
} }
if (!EmitExpression(out, args[0])) { // buffer out << buffer << ".Load";
return false;
}
out << ".Load";
if (n > 1) { if (n > 1) {
out << n; out << n;
} }
ScopedParen sp(out); ScopedParen sp(out);
if (!EmitExpression(out, args[1])) { // offset if (!EmitExpression(out, offset)) {
return false; return false;
} }
if (cast) { if (cast) {
@ -1443,12 +1429,9 @@ bool GeneratorImpl::EmitStorageBufferAccess(
// Used by loading f16 types, e.g. for f16 type, set type parameter to "float16_t" // Used by loading f16 types, e.g. for f16 type, set type parameter to "float16_t"
// to emit `buffer.Load<float16_t>(offset)`. // to emit `buffer.Load<float16_t>(offset)`.
auto templated_load = [&](const char* type) { auto templated_load = [&](const char* type) {
if (!EmitExpression(out, args[0])) { // buffer out << buffer << ".Load<" << type << ">"; // templated load
return false;
}
out << ".Load<" << type << ">"; // templated load
ScopedParen sp(out); ScopedParen sp(out);
if (!EmitExpression(out, args[1])) { // offset if (!EmitExpression(out, offset)) {
return false; return false;
} }
return true; return true;
@ -1495,20 +1478,17 @@ bool GeneratorImpl::EmitStorageBufferAccess(
case Op::kStore: { case Op::kStore: {
auto store = [&](int n) { auto store = [&](int n) {
if (!EmitExpression(out, args[0])) { // buffer out << buffer << ".Store";
return false;
}
out << ".Store";
if (n > 1) { if (n > 1) {
out << n; out << n;
} }
ScopedParen sp1(out); ScopedParen sp1(out);
if (!EmitExpression(out, args[1])) { // offset if (!EmitExpression(out, offset)) {
return false; return false;
} }
out << ", asuint"; out << ", asuint";
ScopedParen sp2(out); ScopedParen sp2(out);
if (!EmitExpression(out, args[2])) { // value if (!EmitExpression(out, value)) {
return false; return false;
} }
return true; return true;
@ -1517,16 +1497,13 @@ bool GeneratorImpl::EmitStorageBufferAccess(
// Used by storing f16 types, e.g. for f16 type, set type parameter to "float16_t" // Used by storing f16 types, e.g. for f16 type, set type parameter to "float16_t"
// to emit `buffer.Store<float16_t>(offset)`. // to emit `buffer.Store<float16_t>(offset)`.
auto templated_store = [&](const char* type) { auto templated_store = [&](const char* type) {
if (!EmitExpression(out, args[0])) { // buffer out << buffer << ".Store<" << type << ">"; // templated store
return false;
}
out << ".Store<" << type << ">"; // templated store
ScopedParen sp1(out); ScopedParen sp1(out);
if (!EmitExpression(out, args[1])) { // offset if (!EmitExpression(out, offset)) {
return false; return false;
} }
out << ", "; out << ", ";
if (!EmitExpression(out, args[2])) { // value if (!EmitExpression(out, value)) {
return false; return false;
} }
return true; return true;
@ -1571,7 +1548,7 @@ bool GeneratorImpl::EmitStorageBufferAccess(
return false; return false;
} }
default: default:
// Break out to error case below/ // Break out to error case below
// Note that atomic intrinsics are generated as functions. // Note that atomic intrinsics are generated as functions.
break; break;
} }
@ -1588,10 +1565,11 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
const sem::Function* sem_func = builder_.Sem().Get(func); const sem::Function* sem_func = builder_.Sem().Get(func);
auto* result_ty = sem_func->ReturnType(); auto* result_ty = sem_func->ReturnType();
const auto& params = sem_func->Parameters();
const auto name = builder_.Symbols().NameFor(func->name->symbol); const auto name = builder_.Symbols().NameFor(func->name->symbol);
auto& buf = *current_buffer_; auto& buf = *current_buffer_;
auto const buffer = program_->Symbols().NameFor(intrinsic->buffer);
auto rmw = [&](const char* hlsl) -> bool { auto rmw = [&](const char* hlsl) -> bool {
{ {
auto fn = line(&buf); auto fn = line(&buf);
@ -1599,7 +1577,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
builtin::Access::kUndefined, name)) { builtin::Access::kUndefined, name)) {
return false; return false;
} }
fn << "(RWByteAddressBuffer buffer, uint offset, "; fn << "(uint offset, ";
if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined, if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) { builtin::Access::kUndefined, "value")) {
return false; return false;
@ -1624,7 +1602,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
} }
{ {
auto l = line(&buf); auto l = line(&buf);
l << "buffer." << hlsl << "(offset, "; l << buffer << "." << hlsl << "(offset, ";
if (intrinsic->op == Op::kAtomicSub) { if (intrinsic->op == Op::kAtomicSub) {
l << "-"; l << "-";
} }
@ -1669,7 +1647,7 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
builtin::Access::kUndefined, name)) { builtin::Access::kUndefined, name)) {
return false; return false;
} }
fn << "(RWByteAddressBuffer buffer, uint offset) {"; fn << "(uint offset) {";
} }
buf.IncrementIndent(); buf.IncrementIndent();
@ -1688,17 +1666,17 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
l << " = 0;"; l << " = 0;";
} }
line(&buf) << "buffer.InterlockedOr(offset, 0, value);"; line(&buf) << buffer << ".InterlockedOr(offset, 0, value);";
line(&buf) << "return value;"; line(&buf) << "return value;";
return true; return true;
} }
case Op::kAtomicStore: { case Op::kAtomicStore: {
auto* const value_ty = sem_func->Parameters()[1]->Type()->UnwrapRef();
// HLSL does not have an InterlockedStore, so we emulate it with // HLSL does not have an InterlockedStore, so we emulate it with
// InterlockedExchange and discard the returned value // InterlockedExchange and discard the returned value
auto* value_ty = params[2]->Type()->UnwrapRef();
{ {
auto fn = line(&buf); auto fn = line(&buf);
fn << "void " << name << "(RWByteAddressBuffer buffer, uint offset, "; fn << "void " << name << "(uint offset, ";
if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined, if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "value")) { builtin::Access::kUndefined, "value")) {
return false; return false;
@ -1721,20 +1699,20 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
} }
l << ";"; l << ";";
} }
line(&buf) << "buffer.InterlockedExchange(offset, value, ignored);"; line(&buf) << buffer << ".InterlockedExchange(offset, value, ignored);";
return true; return true;
} }
case Op::kAtomicCompareExchangeWeak: { case Op::kAtomicCompareExchangeWeak: {
auto* const value_ty = sem_func->Parameters()[1]->Type()->UnwrapRef();
// NOTE: We don't need to emit the return type struct here as DecomposeMemoryAccess // NOTE: We don't need to emit the return type struct here as DecomposeMemoryAccess
// already added it to the AST, and it should have already been emitted by now. // already added it to the AST, and it should have already been emitted by now.
auto* value_ty = params[2]->Type()->UnwrapRef();
{ {
auto fn = line(&buf); auto fn = line(&buf);
if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined, if (!EmitTypeAndName(fn, result_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, name)) { builtin::Access::kUndefined, name)) {
return false; return false;
} }
fn << "(RWByteAddressBuffer buffer, uint offset, "; fn << "(uint offset, ";
if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined, if (!EmitTypeAndName(fn, value_ty, builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, "compare")) { builtin::Access::kUndefined, "compare")) {
return false; return false;
@ -1767,8 +1745,8 @@ bool GeneratorImpl::EmitStorageAtomicIntrinsic(
l << ";"; l << ";";
} }
line(&buf) << "buffer.InterlockedCompareExchange(offset, compare, value, " line(&buf) << buffer
"result.old_value);"; << ".InterlockedCompareExchange(offset, compare, value, result.old_value);";
line(&buf) << "result.exchanged = result.old_value == compare;"; line(&buf) << "result.exchanged = result.old_value == compare;";
line(&buf) << "return result;"; line(&buf) << "return result;";

592
src/tint/writer/hlsl/generator_impl_member_accessor_test.cc
View File

File diff suppressed because it is too large Load Diff

8
src/tint/writer/hlsl/generator_impl_sanitizer_test.cc
View File

@ -159,10 +159,10 @@ ByteAddressBuffer b : register(t1, space2);
ByteAddressBuffer c : register(t2, space2); ByteAddressBuffer c : register(t2, space2);
void a_func() { void a_func() {
uint tint_symbol_4 = 0u; uint tint_symbol_3 = 0u;
b.GetDimensions(tint_symbol_4); b.GetDimensions(tint_symbol_3);
const uint tint_symbol_5 = ((tint_symbol_4 - 0u) / 4u); const uint tint_symbol_4 = ((tint_symbol_3 - 0u) / 4u);
uint len = (tint_symbol_5 + ((tint_symbol_1[1].w - 0u) / 4u)); uint len = (tint_symbol_4 + ((tint_symbol_1[1].w - 0u) / 4u));
return; return;
} }
)"; )";

28
test/tint/array/assign_to_function_var.wgsl.expected.dxc.hlsl
View File

@ -16,33 +16,33 @@ RWByteAddressBuffer src_storage : register(u1, space0);
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -51,8 +51,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
int4 tint_symbol[4] = (int4[4])0; int4 tint_symbol[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -62,8 +62,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int dst_nested[4][3][2] = (int[4][3][2])0; int dst_nested[4][3][2] = (int[4][3][2])0;
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;

28
test/tint/array/assign_to_function_var.wgsl.expected.fxc.hlsl
View File

@ -16,33 +16,33 @@ RWByteAddressBuffer src_storage : register(u1, space0);
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -51,8 +51,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
int4 tint_symbol[4] = (int4[4])0; int4 tint_symbol[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -62,8 +62,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int dst_nested[4][3][2] = (int[4][3][2])0; int dst_nested[4][3][2] = (int[4][3][2])0;
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;

28
test/tint/array/assign_to_private_var.wgsl.expected.dxc.hlsl
View File

@ -18,33 +18,33 @@ static int dst_nested[4][3][2] = (int[4][3][2])0;
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -52,8 +52,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -63,8 +63,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;
} }

28
test/tint/array/assign_to_private_var.wgsl.expected.fxc.hlsl
View File

@ -18,33 +18,33 @@ static int dst_nested[4][3][2] = (int[4][3][2])0;
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -52,8 +52,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -63,8 +63,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;
} }

60
test/tint/array/assign_to_storage_var.wgsl.expected.dxc.hlsl
View File

@ -18,90 +18,90 @@ RWByteAddressBuffer dst_nested : register(u3, space0);
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_13[4] = (int4[4])0; const int4 tint_symbol_3[4] = (int4[4])0;
return tint_symbol_13; return tint_symbol_3;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_14 = (S)0; const S tint_symbol_4 = (S)0;
return tint_symbol_14; return tint_symbol_4;
} }
void tint_symbol_3(RWByteAddressBuffer buffer, uint offset, int4 value[4]) { void tint_symbol_store(uint offset, int4 value[4]) {
int4 array_1[4] = value; int4 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
buffer.Store4((offset + (i * 16u)), asuint(array_1[i])); tint_symbol.Store4((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
typedef int4 tint_symbol_5_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_5_ret tint_symbol_5(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
const uint scalar_offset = ((offset + (i_1 * 16u))) / 4; const uint scalar_offset = ((offset + (i_1 * 16u))) / 4;
arr_1[i_1] = asint(buffer[scalar_offset / 4]); arr_1[i_1] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_7_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_7_ret tint_symbol_7(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = asint(buffer.Load4((offset + (i_2 * 16u)))); arr_2[i_2] = asint(src_storage.Load4((offset + (i_2 * 16u))));
} }
} }
return arr_2; return arr_2;
} }
void tint_symbol_11(RWByteAddressBuffer buffer, uint offset, int value[2]) { void dst_nested_store_2(uint offset, int value[2]) {
int array_4[2] = value; int array_4[2] = value;
{ {
for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) { for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) {
buffer.Store((offset + (i_3 * 4u)), asuint(array_4[i_3])); dst_nested.Store((offset + (i_3 * 4u)), asuint(array_4[i_3]));
} }
} }
} }
void tint_symbol_10(RWByteAddressBuffer buffer, uint offset, int value[3][2]) { void dst_nested_store_1(uint offset, int value[3][2]) {
int array_3[3][2] = value; int array_3[3][2] = value;
{ {
for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) { for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) {
tint_symbol_11(buffer, (offset + (i_4 * 8u)), array_3[i_4]); dst_nested_store_2((offset + (i_4 * 8u)), array_3[i_4]);
} }
} }
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, int value[4][3][2]) { void dst_nested_store(uint offset, int value[4][3][2]) {
int array_2[4][3][2] = value; int array_2[4][3][2] = value;
{ {
for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) { for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) {
tint_symbol_10(buffer, (offset + (i_5 * 24u)), array_2[i_5]); dst_nested_store_1((offset + (i_5 * 24u)), array_2[i_5]);
} }
} }
} }
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_15[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_5[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol_3(tint_symbol, 0u, tint_symbol_15); tint_symbol_store(0u, tint_symbol_5);
tint_symbol_3(tint_symbol, 0u, src_param); tint_symbol_store(0u, src_param);
const int4 tint_symbol_1[4] = ret_arr(); const int4 tint_symbol_1[4] = ret_arr();
tint_symbol_3(tint_symbol, 0u, tint_symbol_1); tint_symbol_store(0u, tint_symbol_1);
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
tint_symbol_3(tint_symbol, 0u, src_let); tint_symbol_store(0u, src_let);
tint_symbol_3(tint_symbol, 0u, src_function); tint_symbol_store(0u, src_function);
tint_symbol_3(tint_symbol, 0u, src_private); tint_symbol_store(0u, src_private);
tint_symbol_3(tint_symbol, 0u, src_workgroup); tint_symbol_store(0u, src_workgroup);
const S tint_symbol_2 = ret_struct_arr(); const S tint_symbol_2 = ret_struct_arr();
tint_symbol_3(tint_symbol, 0u, tint_symbol_2.arr); tint_symbol_store(0u, tint_symbol_2.arr);
tint_symbol_3(tint_symbol, 0u, tint_symbol_5(src_uniform, 0u)); tint_symbol_store(0u, src_uniform_load(0u));
tint_symbol_3(tint_symbol, 0u, tint_symbol_7(src_storage, 0u)); tint_symbol_store(0u, src_storage_load(0u));
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
tint_symbol_9(dst_nested, 0u, src_nested); dst_nested_store(0u, src_nested);
} }

60
test/tint/array/assign_to_storage_var.wgsl.expected.fxc.hlsl
View File

@ -18,90 +18,90 @@ RWByteAddressBuffer dst_nested : register(u3, space0);
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_13[4] = (int4[4])0; const int4 tint_symbol_3[4] = (int4[4])0;
return tint_symbol_13; return tint_symbol_3;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_14 = (S)0; const S tint_symbol_4 = (S)0;
return tint_symbol_14; return tint_symbol_4;
} }
void tint_symbol_3(RWByteAddressBuffer buffer, uint offset, int4 value[4]) { void tint_symbol_store(uint offset, int4 value[4]) {
int4 array_1[4] = value; int4 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
buffer.Store4((offset + (i * 16u)), asuint(array_1[i])); tint_symbol.Store4((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
typedef int4 tint_symbol_5_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_5_ret tint_symbol_5(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
const uint scalar_offset = ((offset + (i_1 * 16u))) / 4; const uint scalar_offset = ((offset + (i_1 * 16u))) / 4;
arr_1[i_1] = asint(buffer[scalar_offset / 4]); arr_1[i_1] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_7_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_7_ret tint_symbol_7(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = asint(buffer.Load4((offset + (i_2 * 16u)))); arr_2[i_2] = asint(src_storage.Load4((offset + (i_2 * 16u))));
} }
} }
return arr_2; return arr_2;
} }
void tint_symbol_11(RWByteAddressBuffer buffer, uint offset, int value[2]) { void dst_nested_store_2(uint offset, int value[2]) {
int array_4[2] = value; int array_4[2] = value;
{ {
for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) { for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) {
buffer.Store((offset + (i_3 * 4u)), asuint(array_4[i_3])); dst_nested.Store((offset + (i_3 * 4u)), asuint(array_4[i_3]));
} }
} }
} }
void tint_symbol_10(RWByteAddressBuffer buffer, uint offset, int value[3][2]) { void dst_nested_store_1(uint offset, int value[3][2]) {
int array_3[3][2] = value; int array_3[3][2] = value;
{ {
for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) { for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) {
tint_symbol_11(buffer, (offset + (i_4 * 8u)), array_3[i_4]); dst_nested_store_2((offset + (i_4 * 8u)), array_3[i_4]);
} }
} }
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, int value[4][3][2]) { void dst_nested_store(uint offset, int value[4][3][2]) {
int array_2[4][3][2] = value; int array_2[4][3][2] = value;
{ {
for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) { for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) {
tint_symbol_10(buffer, (offset + (i_5 * 24u)), array_2[i_5]); dst_nested_store_1((offset + (i_5 * 24u)), array_2[i_5]);
} }
} }
} }
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_15[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_5[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol_3(tint_symbol, 0u, tint_symbol_15); tint_symbol_store(0u, tint_symbol_5);
tint_symbol_3(tint_symbol, 0u, src_param); tint_symbol_store(0u, src_param);
const int4 tint_symbol_1[4] = ret_arr(); const int4 tint_symbol_1[4] = ret_arr();
tint_symbol_3(tint_symbol, 0u, tint_symbol_1); tint_symbol_store(0u, tint_symbol_1);
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
tint_symbol_3(tint_symbol, 0u, src_let); tint_symbol_store(0u, src_let);
tint_symbol_3(tint_symbol, 0u, src_function); tint_symbol_store(0u, src_function);
tint_symbol_3(tint_symbol, 0u, src_private); tint_symbol_store(0u, src_private);
tint_symbol_3(tint_symbol, 0u, src_workgroup); tint_symbol_store(0u, src_workgroup);
const S tint_symbol_2 = ret_struct_arr(); const S tint_symbol_2 = ret_struct_arr();
tint_symbol_3(tint_symbol, 0u, tint_symbol_2.arr); tint_symbol_store(0u, tint_symbol_2.arr);
tint_symbol_3(tint_symbol, 0u, tint_symbol_5(src_uniform, 0u)); tint_symbol_store(0u, src_uniform_load(0u));
tint_symbol_3(tint_symbol, 0u, tint_symbol_7(src_storage, 0u)); tint_symbol_store(0u, src_storage_load(0u));
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
tint_symbol_9(dst_nested, 0u, src_nested); dst_nested_store(0u, src_nested);
} }

28
test/tint/array/assign_to_workgroup_var.wgsl.expected.dxc.hlsl
View File

@ -18,33 +18,33 @@ groupshared int dst_nested[4][3][2];
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -52,8 +52,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -63,8 +63,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;
} }

28
test/tint/array/assign_to_workgroup_var.wgsl.expected.fxc.hlsl
View File

@ -18,33 +18,33 @@ groupshared int dst_nested[4][3][2];
typedef int4 ret_arr_ret[4]; typedef int4 ret_arr_ret[4];
ret_arr_ret ret_arr() { ret_arr_ret ret_arr() {
const int4 tint_symbol_6[4] = (int4[4])0; const int4 tint_symbol_2[4] = (int4[4])0;
return tint_symbol_6; return tint_symbol_2;
} }
S ret_struct_arr() { S ret_struct_arr() {
const S tint_symbol_7 = (S)0; const S tint_symbol_3 = (S)0;
return tint_symbol_7; return tint_symbol_3;
} }
typedef int4 tint_symbol_2_ret[4]; typedef int4 src_uniform_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { src_uniform_load_ret src_uniform_load(uint offset) {
int4 arr_1[4] = (int4[4])0; int4 arr_1[4] = (int4[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
const uint scalar_offset = ((offset + (i * 16u))) / 4; const uint scalar_offset = ((offset + (i * 16u))) / 4;
arr_1[i] = asint(buffer[scalar_offset / 4]); arr_1[i] = asint(src_uniform[scalar_offset / 4]);
} }
} }
return arr_1; return arr_1;
} }
typedef int4 tint_symbol_4_ret[4]; typedef int4 src_storage_load_ret[4];
tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { src_storage_load_ret src_storage_load(uint offset) {
int4 arr_2[4] = (int4[4])0; int4 arr_2[4] = (int4[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = asint(buffer.Load4((offset + (i_1 * 16u)))); arr_2[i_1] = asint(src_storage.Load4((offset + (i_1 * 16u))));
} }
} }
return arr_2; return arr_2;
@ -52,8 +52,8 @@ tint_symbol_4_ret tint_symbol_4(RWByteAddressBuffer buffer, uint offset) {
void foo(int4 src_param[4]) { void foo(int4 src_param[4]) {
int4 src_function[4] = (int4[4])0; int4 src_function[4] = (int4[4])0;
const int4 tint_symbol_8[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx}; const int4 tint_symbol_4[4] = {(1).xxxx, (2).xxxx, (3).xxxx, (3).xxxx};
tint_symbol = tint_symbol_8; tint_symbol = tint_symbol_4;
tint_symbol = src_param; tint_symbol = src_param;
tint_symbol = ret_arr(); tint_symbol = ret_arr();
const int4 src_let[4] = (int4[4])0; const int4 src_let[4] = (int4[4])0;
@ -63,8 +63,8 @@ void foo(int4 src_param[4]) {
tint_symbol = src_workgroup; tint_symbol = src_workgroup;
const S tint_symbol_1 = ret_struct_arr(); const S tint_symbol_1 = ret_struct_arr();
tint_symbol = tint_symbol_1.arr; tint_symbol = tint_symbol_1.arr;
tint_symbol = tint_symbol_2(src_uniform, 0u); tint_symbol = src_uniform_load(0u);
tint_symbol = tint_symbol_4(src_storage, 0u); tint_symbol = src_storage_load(0u);
int src_nested[4][3][2] = (int[4][3][2])0; int src_nested[4][3][2] = (int[4][3][2])0;
dst_nested = src_nested; dst_nested = src_nested;
} }

60
test/tint/array/strides.spvasm.expected.dxc.hlsl
View File

@ -7,91 +7,91 @@ struct strided_arr_1 {
RWByteAddressBuffer s : register(u0, space0); RWByteAddressBuffer s : register(u0, space0);
strided_arr tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { strided_arr s_load_4(uint offset) {
const strided_arr tint_symbol_12 = {asfloat(buffer.Load((offset + 0u)))}; const strided_arr tint_symbol = {asfloat(s.Load((offset + 0u)))};
return tint_symbol_12; return tint_symbol;
} }
typedef strided_arr tint_symbol_3_ret[2]; typedef strided_arr s_load_3_ret[2];
tint_symbol_3_ret tint_symbol_3(RWByteAddressBuffer buffer, uint offset) { s_load_3_ret s_load_3(uint offset) {
strided_arr arr[2] = (strided_arr[2])0; strided_arr arr[2] = (strided_arr[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr[i] = tint_symbol_4(buffer, (offset + (i * 8u))); arr[i] = s_load_4((offset + (i * 8u)));
} }
} }
return arr; return arr;
} }
typedef strided_arr tint_symbol_2_ret[3][2]; typedef strided_arr s_load_2_ret[3][2];
tint_symbol_2_ret tint_symbol_2(RWByteAddressBuffer buffer, uint offset) { s_load_2_ret s_load_2(uint offset) {
strided_arr arr_1[3][2] = (strided_arr[3][2])0; strided_arr arr_1[3][2] = (strided_arr[3][2])0;
{ {
for(uint i_1 = 0u; (i_1 < 3u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 3u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_3(buffer, (offset + (i_1 * 16u))); arr_1[i_1] = s_load_3((offset + (i_1 * 16u)));
} }
} }
return arr_1; return arr_1;
} }
strided_arr_1 tint_symbol_1(RWByteAddressBuffer buffer, uint offset) { strided_arr_1 s_load_1(uint offset) {
const strided_arr_1 tint_symbol_13 = {tint_symbol_2(buffer, (offset + 0u))}; const strided_arr_1 tint_symbol_1 = {s_load_2((offset + 0u))};
return tint_symbol_13; return tint_symbol_1;
} }
typedef strided_arr_1 tint_symbol_ret[4]; typedef strided_arr_1 s_load_ret[4];
tint_symbol_ret tint_symbol(RWByteAddressBuffer buffer, uint offset) { s_load_ret s_load(uint offset) {
strided_arr_1 arr_2[4] = (strided_arr_1[4])0; strided_arr_1 arr_2[4] = (strided_arr_1[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = tint_symbol_1(buffer, (offset + (i_2 * 128u))); arr_2[i_2] = s_load_1((offset + (i_2 * 128u)));
} }
} }
return arr_2; return arr_2;
} }
void tint_symbol_10(RWByteAddressBuffer buffer, uint offset, strided_arr value) { void s_store_4(uint offset, strided_arr value) {
buffer.Store((offset + 0u), asuint(value.el)); s.Store((offset + 0u), asuint(value.el));
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, strided_arr value[2]) { void s_store_3(uint offset, strided_arr value[2]) {
strided_arr array_3[2] = value; strided_arr array_3[2] = value;
{ {
for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) { for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) {
tint_symbol_10(buffer, (offset + (i_3 * 8u)), array_3[i_3]); s_store_4((offset + (i_3 * 8u)), array_3[i_3]);
} }
} }
} }
void tint_symbol_8(RWByteAddressBuffer buffer, uint offset, strided_arr value[3][2]) { void s_store_2(uint offset, strided_arr value[3][2]) {
strided_arr array_2[3][2] = value; strided_arr array_2[3][2] = value;
{ {
for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) { for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) {
tint_symbol_9(buffer, (offset + (i_4 * 16u)), array_2[i_4]); s_store_3((offset + (i_4 * 16u)), array_2[i_4]);
} }
} }
} }
void tint_symbol_7(RWByteAddressBuffer buffer, uint offset, strided_arr_1 value) { void s_store_1(uint offset, strided_arr_1 value) {
tint_symbol_8(buffer, (offset + 0u), value.el); s_store_2((offset + 0u), value.el);
} }
void tint_symbol_6(RWByteAddressBuffer buffer, uint offset, strided_arr_1 value[4]) { void s_store(uint offset, strided_arr_1 value[4]) {
strided_arr_1 array_1[4] = value; strided_arr_1 array_1[4] = value;
{ {
for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) { for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) {
tint_symbol_7(buffer, (offset + (i_5 * 128u)), array_1[i_5]); s_store_1((offset + (i_5 * 128u)), array_1[i_5]);
} }
} }
} }
void f_1() { void f_1() {
const strided_arr_1 x_19[4] = tint_symbol(s, 0u); const strided_arr_1 x_19[4] = s_load(0u);
const strided_arr x_24[3][2] = tint_symbol_2(s, 384u); const strided_arr x_24[3][2] = s_load_2(384u);
const strided_arr x_28[2] = tint_symbol_3(s, 416u); const strided_arr x_28[2] = s_load_3(416u);
const float x_32 = asfloat(s.Load(424u)); const float x_32 = asfloat(s.Load(424u));
const strided_arr_1 tint_symbol_14[4] = (strided_arr_1[4])0; const strided_arr_1 tint_symbol_2[4] = (strided_arr_1[4])0;
tint_symbol_6(s, 0u, tint_symbol_14); s_store(0u, tint_symbol_2);
s.Store(424u, asuint(5.0f)); s.Store(424u, asuint(5.0f));
return; return;
} }

60
test/tint/array/strides.spvasm.expected.fxc.hlsl
View File

@ -7,91 +7,91 @@ struct strided_arr_1 {
RWByteAddressBuffer s : register(u0, space0); RWByteAddressBuffer s : register(u0, space0);
strided_arr tint_symbol_4(RWByteAddressBuffer buffer, uint offset) { strided_arr s_load_4(uint offset) {
const strided_arr tint_symbol_12 = {asfloat(buffer.Load((offset + 0u)))}; const strided_arr tint_symbol = {asfloat(s.Load((offset + 0u)))};
return tint_symbol_12; return tint_symbol;
} }
typedef strided_arr tint_symbol_3_ret[2]; typedef strided_arr s_load_3_ret[2];
tint_symbol_3_ret tint_symbol_3(RWByteAddressBuffer buffer, uint offset) { s_load_3_ret s_load_3(uint offset) {
strided_arr arr[2] = (strided_arr[2])0; strided_arr arr[2] = (strided_arr[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr[i] = tint_symbol_4(buffer, (offset + (i * 8u))); arr[i] = s_load_4((offset + (i * 8u)));
} }
} }
return arr; return arr;
} }
typedef strided_arr tint_symbol_2_ret[3][2]; typedef strided_arr s_load_2_ret[3][2];
tint_symbol_2_ret tint_symbol_2(RWByteAddressBuffer buffer, uint offset) { s_load_2_ret s_load_2(uint offset) {
strided_arr arr_1[3][2] = (strided_arr[3][2])0; strided_arr arr_1[3][2] = (strided_arr[3][2])0;
{ {
for(uint i_1 = 0u; (i_1 < 3u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 3u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_3(buffer, (offset + (i_1 * 16u))); arr_1[i_1] = s_load_3((offset + (i_1 * 16u)));
} }
} }
return arr_1; return arr_1;
} }
strided_arr_1 tint_symbol_1(RWByteAddressBuffer buffer, uint offset) { strided_arr_1 s_load_1(uint offset) {
const strided_arr_1 tint_symbol_13 = {tint_symbol_2(buffer, (offset + 0u))}; const strided_arr_1 tint_symbol_1 = {s_load_2((offset + 0u))};
return tint_symbol_13; return tint_symbol_1;
} }
typedef strided_arr_1 tint_symbol_ret[4]; typedef strided_arr_1 s_load_ret[4];
tint_symbol_ret tint_symbol(RWByteAddressBuffer buffer, uint offset) { s_load_ret s_load(uint offset) {
strided_arr_1 arr_2[4] = (strided_arr_1[4])0; strided_arr_1 arr_2[4] = (strided_arr_1[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = tint_symbol_1(buffer, (offset + (i_2 * 128u))); arr_2[i_2] = s_load_1((offset + (i_2 * 128u)));
} }
} }
return arr_2; return arr_2;
} }
void tint_symbol_10(RWByteAddressBuffer buffer, uint offset, strided_arr value) { void s_store_4(uint offset, strided_arr value) {
buffer.Store((offset + 0u), asuint(value.el)); s.Store((offset + 0u), asuint(value.el));
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, strided_arr value[2]) { void s_store_3(uint offset, strided_arr value[2]) {
strided_arr array_3[2] = value; strided_arr array_3[2] = value;
{ {
for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) { for(uint i_3 = 0u; (i_3 < 2u); i_3 = (i_3 + 1u)) {
tint_symbol_10(buffer, (offset + (i_3 * 8u)), array_3[i_3]); s_store_4((offset + (i_3 * 8u)), array_3[i_3]);
} }
} }
} }
void tint_symbol_8(RWByteAddressBuffer buffer, uint offset, strided_arr value[3][2]) { void s_store_2(uint offset, strided_arr value[3][2]) {
strided_arr array_2[3][2] = value; strided_arr array_2[3][2] = value;
{ {
for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) { for(uint i_4 = 0u; (i_4 < 3u); i_4 = (i_4 + 1u)) {
tint_symbol_9(buffer, (offset + (i_4 * 16u)), array_2[i_4]); s_store_3((offset + (i_4 * 16u)), array_2[i_4]);
} }
} }
} }
void tint_symbol_7(RWByteAddressBuffer buffer, uint offset, strided_arr_1 value) { void s_store_1(uint offset, strided_arr_1 value) {
tint_symbol_8(buffer, (offset + 0u), value.el); s_store_2((offset + 0u), value.el);
} }
void tint_symbol_6(RWByteAddressBuffer buffer, uint offset, strided_arr_1 value[4]) { void s_store(uint offset, strided_arr_1 value[4]) {
strided_arr_1 array_1[4] = value; strided_arr_1 array_1[4] = value;
{ {
for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) { for(uint i_5 = 0u; (i_5 < 4u); i_5 = (i_5 + 1u)) {
tint_symbol_7(buffer, (offset + (i_5 * 128u)), array_1[i_5]); s_store_1((offset + (i_5 * 128u)), array_1[i_5]);
} }
} }
} }
void f_1() { void f_1() {
const strided_arr_1 x_19[4] = tint_symbol(s, 0u); const strided_arr_1 x_19[4] = s_load(0u);
const strided_arr x_24[3][2] = tint_symbol_2(s, 384u); const strided_arr x_24[3][2] = s_load_2(384u);
const strided_arr x_28[2] = tint_symbol_3(s, 416u); const strided_arr x_28[2] = s_load_3(416u);
const float x_32 = asfloat(s.Load(424u)); const float x_32 = asfloat(s.Load(424u));
const strided_arr_1 tint_symbol_14[4] = (strided_arr_1[4])0; const strided_arr_1 tint_symbol_2[4] = (strided_arr_1[4])0;
tint_symbol_6(s, 0u, tint_symbol_14); s_store(0u, tint_symbol_2);
s.Store(424u, asuint(5.0f)); s.Store(424u, asuint(5.0f));
return; return;
} }

62
test/tint/buffer/storage/dynamic_index/read.wgsl.expected.dxc.hlsl
View File

@ -4,48 +4,48 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_14(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_12(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_15(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_13(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_16(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_14(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_17(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_15(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_16(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_17(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_18(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_21(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_19(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_22(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_20(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
typedef float3 tint_symbol_23_ret[2]; typedef float3 sb_load_21_ret[2];
tint_symbol_23_ret tint_symbol_23(ByteAddressBuffer buffer, uint offset) { sb_load_21_ret sb_load_21(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr_1[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr_1[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr_1; return arr_1;
@ -64,16 +64,16 @@ void main_inner(uint idx) {
const float4 vec4_f32 = asfloat(sb.Load4(((544u * idx) + 96u))); const float4 vec4_f32 = asfloat(sb.Load4(((544u * idx) + 96u)));
const int4 vec4_i32 = asint(sb.Load4(((544u * idx) + 112u))); const int4 vec4_i32 = asint(sb.Load4(((544u * idx) + 112u)));
const uint4 vec4_u32 = sb.Load4(((544u * idx) + 128u)); const uint4 vec4_u32 = sb.Load4(((544u * idx) + 128u));
const float2x2 mat2x2_f32 = tint_symbol_14(sb, ((544u * idx) + 144u)); const float2x2 mat2x2_f32 = sb_load_12(((544u * idx) + 144u));
const float2x3 mat2x3_f32 = tint_symbol_15(sb, ((544u * idx) + 160u)); const float2x3 mat2x3_f32 = sb_load_13(((544u * idx) + 160u));
const float2x4 mat2x4_f32 = tint_symbol_16(sb, ((544u * idx) + 192u)); const float2x4 mat2x4_f32 = sb_load_14(((544u * idx) + 192u));
const float3x2 mat3x2_f32 = tint_symbol_17(sb, ((544u * idx) + 224u)); const float3x2 mat3x2_f32 = sb_load_15(((544u * idx) + 224u));
const float3x3 mat3x3_f32 = tint_symbol_18(sb, ((544u * idx) + 256u)); const float3x3 mat3x3_f32 = sb_load_16(((544u * idx) + 256u));
const float3x4 mat3x4_f32 = tint_symbol_19(sb, ((544u * idx) + 304u)); const float3x4 mat3x4_f32 = sb_load_17(((544u * idx) + 304u));
const float4x2 mat4x2_f32 = tint_symbol_20(sb, ((544u * idx) + 352u)); const float4x2 mat4x2_f32 = sb_load_18(((544u * idx) + 352u));
const float4x3 mat4x3_f32 = tint_symbol_21(sb, ((544u * idx) + 384u)); const float4x3 mat4x3_f32 = sb_load_19(((544u * idx) + 384u));
const float4x4 mat4x4_f32 = tint_symbol_22(sb, ((544u * idx) + 448u)); const float4x4 mat4x4_f32 = sb_load_20(((544u * idx) + 448u));
const float3 arr2_vec3_f32[2] = tint_symbol_23(sb, ((544u * idx) + 512u)); const float3 arr2_vec3_f32[2] = sb_load_21(((544u * idx) + 512u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

62
test/tint/buffer/storage/dynamic_index/read.wgsl.expected.fxc.hlsl
View File

@ -4,48 +4,48 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_14(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_12(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_15(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_13(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_16(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_14(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_17(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_15(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_16(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_17(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_18(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_21(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_19(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_22(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_20(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
typedef float3 tint_symbol_23_ret[2]; typedef float3 sb_load_21_ret[2];
tint_symbol_23_ret tint_symbol_23(ByteAddressBuffer buffer, uint offset) { sb_load_21_ret sb_load_21(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr_1[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr_1[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr_1; return arr_1;
@ -64,16 +64,16 @@ void main_inner(uint idx) {
const float4 vec4_f32 = asfloat(sb.Load4(((544u * idx) + 96u))); const float4 vec4_f32 = asfloat(sb.Load4(((544u * idx) + 96u)));
const int4 vec4_i32 = asint(sb.Load4(((544u * idx) + 112u))); const int4 vec4_i32 = asint(sb.Load4(((544u * idx) + 112u)));
const uint4 vec4_u32 = sb.Load4(((544u * idx) + 128u)); const uint4 vec4_u32 = sb.Load4(((544u * idx) + 128u));
const float2x2 mat2x2_f32 = tint_symbol_14(sb, ((544u * idx) + 144u)); const float2x2 mat2x2_f32 = sb_load_12(((544u * idx) + 144u));
const float2x3 mat2x3_f32 = tint_symbol_15(sb, ((544u * idx) + 160u)); const float2x3 mat2x3_f32 = sb_load_13(((544u * idx) + 160u));
const float2x4 mat2x4_f32 = tint_symbol_16(sb, ((544u * idx) + 192u)); const float2x4 mat2x4_f32 = sb_load_14(((544u * idx) + 192u));
const float3x2 mat3x2_f32 = tint_symbol_17(sb, ((544u * idx) + 224u)); const float3x2 mat3x2_f32 = sb_load_15(((544u * idx) + 224u));
const float3x3 mat3x3_f32 = tint_symbol_18(sb, ((544u * idx) + 256u)); const float3x3 mat3x3_f32 = sb_load_16(((544u * idx) + 256u));
const float3x4 mat3x4_f32 = tint_symbol_19(sb, ((544u * idx) + 304u)); const float3x4 mat3x4_f32 = sb_load_17(((544u * idx) + 304u));
const float4x2 mat4x2_f32 = tint_symbol_20(sb, ((544u * idx) + 352u)); const float4x2 mat4x2_f32 = sb_load_18(((544u * idx) + 352u));
const float4x3 mat4x3_f32 = tint_symbol_21(sb, ((544u * idx) + 384u)); const float4x3 mat4x3_f32 = sb_load_19(((544u * idx) + 384u));
const float4x4 mat4x4_f32 = tint_symbol_22(sb, ((544u * idx) + 448u)); const float4x4 mat4x4_f32 = sb_load_20(((544u * idx) + 448u));
const float3 arr2_vec3_f32[2] = tint_symbol_23(sb, ((544u * idx) + 512u)); const float3 arr2_vec3_f32[2] = sb_load_21(((544u * idx) + 512u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

124
test/tint/buffer/storage/dynamic_index/read_f16.wgsl.expected.dxc.hlsl
View File

@ -4,95 +4,95 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_16(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_17(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_18(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_21(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_19(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_22(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_20(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_23(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_21(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_24(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_22(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_25(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_23(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_26(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_24(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
matrix<float16_t, 2, 2> tint_symbol_27(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 2> sb_load_25(uint offset) {
return matrix<float16_t, 2, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u))); return matrix<float16_t, 2, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)));
} }
matrix<float16_t, 2, 3> tint_symbol_28(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 3> sb_load_26(uint offset) {
return matrix<float16_t, 2, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u))); return matrix<float16_t, 2, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)));
} }
matrix<float16_t, 2, 4> tint_symbol_29(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 4> sb_load_27(uint offset) {
return matrix<float16_t, 2, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u))); return matrix<float16_t, 2, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)));
} }
matrix<float16_t, 3, 2> tint_symbol_30(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 2> sb_load_28(uint offset) {
return matrix<float16_t, 3, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u))); return matrix<float16_t, 3, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)), sb.Load<vector<float16_t, 2> >((offset + 8u)));
} }
matrix<float16_t, 3, 3> tint_symbol_31(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 3> sb_load_29(uint offset) {
return matrix<float16_t, 3, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u))); return matrix<float16_t, 3, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)), sb.Load<vector<float16_t, 3> >((offset + 16u)));
} }
matrix<float16_t, 3, 4> tint_symbol_32(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 4> sb_load_30(uint offset) {
return matrix<float16_t, 3, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u))); return matrix<float16_t, 3, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)), sb.Load<vector<float16_t, 4> >((offset + 16u)));
} }
matrix<float16_t, 4, 2> tint_symbol_33(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 2> sb_load_31(uint offset) {
return matrix<float16_t, 4, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u)), buffer.Load<vector<float16_t, 2> >((offset + 12u))); return matrix<float16_t, 4, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)), sb.Load<vector<float16_t, 2> >((offset + 8u)), sb.Load<vector<float16_t, 2> >((offset + 12u)));
} }
matrix<float16_t, 4, 3> tint_symbol_34(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 3> sb_load_32(uint offset) {
return matrix<float16_t, 4, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u)), buffer.Load<vector<float16_t, 3> >((offset + 24u))); return matrix<float16_t, 4, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)), sb.Load<vector<float16_t, 3> >((offset + 16u)), sb.Load<vector<float16_t, 3> >((offset + 24u)));
} }
matrix<float16_t, 4, 4> tint_symbol_35(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 4> sb_load_33(uint offset) {
return matrix<float16_t, 4, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u)), buffer.Load<vector<float16_t, 4> >((offset + 24u))); return matrix<float16_t, 4, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)), sb.Load<vector<float16_t, 4> >((offset + 16u)), sb.Load<vector<float16_t, 4> >((offset + 24u)));
} }
typedef float3 tint_symbol_36_ret[2]; typedef float3 sb_load_34_ret[2];
tint_symbol_36_ret tint_symbol_36(ByteAddressBuffer buffer, uint offset) { sb_load_34_ret sb_load_34(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr_1[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr_1[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr_1; return arr_1;
} }
typedef matrix<float16_t, 4, 2> tint_symbol_37_ret[2]; typedef matrix<float16_t, 4, 2> sb_load_35_ret[2];
tint_symbol_37_ret tint_symbol_37(ByteAddressBuffer buffer, uint offset) { sb_load_35_ret sb_load_35(uint offset) {
matrix<float16_t, 4, 2> arr_2[2] = (matrix<float16_t, 4, 2>[2])0; matrix<float16_t, 4, 2> arr_2[2] = (matrix<float16_t, 4, 2>[2])0;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = tint_symbol_33(buffer, (offset + (i_1 * 16u))); arr_2[i_1] = sb_load_31((offset + (i_1 * 16u)));
} }
} }
return arr_2; return arr_2;
@ -115,26 +115,26 @@ void main_inner(uint idx) {
const int4 vec4_i32 = asint(sb.Load4(((800u * idx) + 128u))); const int4 vec4_i32 = asint(sb.Load4(((800u * idx) + 128u)));
const uint4 vec4_u32 = sb.Load4(((800u * idx) + 144u)); const uint4 vec4_u32 = sb.Load4(((800u * idx) + 144u));
const vector<float16_t, 4> vec4_f16 = sb.Load<vector<float16_t, 4> >(((800u * idx) + 160u)); const vector<float16_t, 4> vec4_f16 = sb.Load<vector<float16_t, 4> >(((800u * idx) + 160u));
const float2x2 mat2x2_f32 = tint_symbol_18(sb, ((800u * idx) + 168u)); const float2x2 mat2x2_f32 = sb_load_16(((800u * idx) + 168u));
const float2x3 mat2x3_f32 = tint_symbol_19(sb, ((800u * idx) + 192u)); const float2x3 mat2x3_f32 = sb_load_17(((800u * idx) + 192u));
const float2x4 mat2x4_f32 = tint_symbol_20(sb, ((800u * idx) + 224u)); const float2x4 mat2x4_f32 = sb_load_18(((800u * idx) + 224u));
const float3x2 mat3x2_f32 = tint_symbol_21(sb, ((800u * idx) + 256u)); const float3x2 mat3x2_f32 = sb_load_19(((800u * idx) + 256u));
const float3x3 mat3x3_f32 = tint_symbol_22(sb, ((800u * idx) + 288u)); const float3x3 mat3x3_f32 = sb_load_20(((800u * idx) + 288u));
const float3x4 mat3x4_f32 = tint_symbol_23(sb, ((800u * idx) + 336u)); const float3x4 mat3x4_f32 = sb_load_21(((800u * idx) + 336u));
const float4x2 mat4x2_f32 = tint_symbol_24(sb, ((800u * idx) + 384u)); const float4x2 mat4x2_f32 = sb_load_22(((800u * idx) + 384u));
const float4x3 mat4x3_f32 = tint_symbol_25(sb, ((800u * idx) + 416u)); const float4x3 mat4x3_f32 = sb_load_23(((800u * idx) + 416u));
const float4x4 mat4x4_f32 = tint_symbol_26(sb, ((800u * idx) + 480u)); const float4x4 mat4x4_f32 = sb_load_24(((800u * idx) + 480u));
const matrix<float16_t, 2, 2> mat2x2_f16 = tint_symbol_27(sb, ((800u * idx) + 544u)); const matrix<float16_t, 2, 2> mat2x2_f16 = sb_load_25(((800u * idx) + 544u));
const matrix<float16_t, 2, 3> mat2x3_f16 = tint_symbol_28(sb, ((800u * idx) + 552u)); const matrix<float16_t, 2, 3> mat2x3_f16 = sb_load_26(((800u * idx) + 552u));
const matrix<float16_t, 2, 4> mat2x4_f16 = tint_symbol_29(sb, ((800u * idx) + 568u)); const matrix<float16_t, 2, 4> mat2x4_f16 = sb_load_27(((800u * idx) + 568u));
const matrix<float16_t, 3, 2> mat3x2_f16 = tint_symbol_30(sb, ((800u * idx) + 584u)); const matrix<float16_t, 3, 2> mat3x2_f16 = sb_load_28(((800u * idx) + 584u));
const matrix<float16_t, 3, 3> mat3x3_f16 = tint_symbol_31(sb, ((800u * idx) + 600u)); const matrix<float16_t, 3, 3> mat3x3_f16 = sb_load_29(((800u * idx) + 600u));
const matrix<float16_t, 3, 4> mat3x4_f16 = tint_symbol_32(sb, ((800u * idx) + 624u)); const matrix<float16_t, 3, 4> mat3x4_f16 = sb_load_30(((800u * idx) + 624u));
const matrix<float16_t, 4, 2> mat4x2_f16 = tint_symbol_33(sb, ((800u * idx) + 648u)); const matrix<float16_t, 4, 2> mat4x2_f16 = sb_load_31(((800u * idx) + 648u));
const matrix<float16_t, 4, 3> mat4x3_f16 = tint_symbol_34(sb, ((800u * idx) + 664u)); const matrix<float16_t, 4, 3> mat4x3_f16 = sb_load_32(((800u * idx) + 664u));
const matrix<float16_t, 4, 4> mat4x4_f16 = tint_symbol_35(sb, ((800u * idx) + 696u)); const matrix<float16_t, 4, 4> mat4x4_f16 = sb_load_33(((800u * idx) + 696u));
const float3 arr2_vec3_f32[2] = tint_symbol_36(sb, ((800u * idx) + 736u)); const float3 arr2_vec3_f32[2] = sb_load_34(((800u * idx) + 736u));
const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = tint_symbol_37(sb, ((800u * idx) + 768u)); const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = sb_load_35(((800u * idx) + 768u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

98
test/tint/buffer/storage/dynamic_index/write.wgsl.expected.dxc.hlsl
View File

@ -4,65 +4,65 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
void tint_symbol_14(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_12(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_15(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_13(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_16(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_14(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_17(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_15(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_16(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_17(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_18(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_19(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_20(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_21(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
@ -80,17 +80,17 @@ void main_inner(uint idx) {
sb.Store4(((544u * idx) + 96u), asuint((0.0f).xxxx)); sb.Store4(((544u * idx) + 96u), asuint((0.0f).xxxx));
sb.Store4(((544u * idx) + 112u), asuint((0).xxxx)); sb.Store4(((544u * idx) + 112u), asuint((0).xxxx));
sb.Store4(((544u * idx) + 128u), asuint((0u).xxxx)); sb.Store4(((544u * idx) + 128u), asuint((0u).xxxx));
tint_symbol_14(sb, ((544u * idx) + 144u), float2x2((0.0f).xx, (0.0f).xx)); sb_store_12(((544u * idx) + 144u), float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_15(sb, ((544u * idx) + 160u), float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_13(((544u * idx) + 160u), float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_16(sb, ((544u * idx) + 192u), float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_14(((544u * idx) + 192u), float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_17(sb, ((544u * idx) + 224u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_15(((544u * idx) + 224u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_18(sb, ((544u * idx) + 256u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_16(((544u * idx) + 256u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_19(sb, ((544u * idx) + 304u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_17(((544u * idx) + 304u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_20(sb, ((544u * idx) + 352u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_18(((544u * idx) + 352u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_21(sb, ((544u * idx) + 384u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_19(((544u * idx) + 384u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_22(sb, ((544u * idx) + 448u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_20(((544u * idx) + 448u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
const float3 tint_symbol_24[2] = (float3[2])0; const float3 tint_symbol_2[2] = (float3[2])0;
tint_symbol_23(sb, ((544u * idx) + 512u), tint_symbol_24); sb_store_21(((544u * idx) + 512u), tint_symbol_2);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

98
test/tint/buffer/storage/dynamic_index/write.wgsl.expected.fxc.hlsl
View File

@ -4,65 +4,65 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
void tint_symbol_14(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_12(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_15(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_13(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_16(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_14(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_17(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_15(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_16(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_17(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_18(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_19(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_20(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_21(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
@ -80,17 +80,17 @@ void main_inner(uint idx) {
sb.Store4(((544u * idx) + 96u), asuint((0.0f).xxxx)); sb.Store4(((544u * idx) + 96u), asuint((0.0f).xxxx));
sb.Store4(((544u * idx) + 112u), asuint((0).xxxx)); sb.Store4(((544u * idx) + 112u), asuint((0).xxxx));
sb.Store4(((544u * idx) + 128u), asuint((0u).xxxx)); sb.Store4(((544u * idx) + 128u), asuint((0u).xxxx));
tint_symbol_14(sb, ((544u * idx) + 144u), float2x2((0.0f).xx, (0.0f).xx)); sb_store_12(((544u * idx) + 144u), float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_15(sb, ((544u * idx) + 160u), float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_13(((544u * idx) + 160u), float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_16(sb, ((544u * idx) + 192u), float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_14(((544u * idx) + 192u), float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_17(sb, ((544u * idx) + 224u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_15(((544u * idx) + 224u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_18(sb, ((544u * idx) + 256u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_16(((544u * idx) + 256u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_19(sb, ((544u * idx) + 304u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_17(((544u * idx) + 304u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_20(sb, ((544u * idx) + 352u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_18(((544u * idx) + 352u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_21(sb, ((544u * idx) + 384u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_19(((544u * idx) + 384u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_22(sb, ((544u * idx) + 448u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_20(((544u * idx) + 448u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
const float3 tint_symbol_24[2] = (float3[2])0; const float3 tint_symbol_2[2] = (float3[2])0;
tint_symbol_23(sb, ((544u * idx) + 512u), tint_symbol_24); sb_store_21(((544u * idx) + 512u), tint_symbol_2);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

196
test/tint/buffer/storage/dynamic_index/write_f16.wgsl.expected.dxc.hlsl
View File

@ -4,128 +4,128 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_16(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_17(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_18(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_19(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_20(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_21(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_24(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_22(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_25(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_23(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_26(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_24(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_27(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 2> value) { void sb_store_25(uint offset, matrix<float16_t, 2, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
} }
void tint_symbol_28(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 3> value) { void sb_store_26(uint offset, matrix<float16_t, 2, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
} }
void tint_symbol_29(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 4> value) { void sb_store_27(uint offset, matrix<float16_t, 2, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
} }
void tint_symbol_30(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 2> value) { void sb_store_28(uint offset, matrix<float16_t, 3, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); sb.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
} }
void tint_symbol_31(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 3> value) { void sb_store_29(uint offset, matrix<float16_t, 3, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
} }
void tint_symbol_32(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 4> value) { void sb_store_30(uint offset, matrix<float16_t, 3, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
} }
void tint_symbol_33(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 2> value) { void sb_store_31(uint offset, matrix<float16_t, 4, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); sb.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
buffer.Store<vector<float16_t, 2> >((offset + 12u), value[3u]); sb.Store<vector<float16_t, 2> >((offset + 12u), value[3u]);
} }
void tint_symbol_34(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 3> value) { void sb_store_32(uint offset, matrix<float16_t, 4, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 3> >((offset + 24u), value[3u]); sb.Store<vector<float16_t, 3> >((offset + 24u), value[3u]);
} }
void tint_symbol_35(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 4> value) { void sb_store_33(uint offset, matrix<float16_t, 4, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 4> >((offset + 24u), value[3u]); sb.Store<vector<float16_t, 4> >((offset + 24u), value[3u]);
} }
void tint_symbol_36(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_34(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
void tint_symbol_37(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 2> value[2]) { void sb_store_35(uint offset, matrix<float16_t, 4, 2> value[2]) {
matrix<float16_t, 4, 2> array_2[2] = value; matrix<float16_t, 4, 2> array_2[2] = value;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
tint_symbol_33(buffer, (offset + (i_1 * 16u)), array_2[i_1]); sb_store_31((offset + (i_1 * 16u)), array_2[i_1]);
} }
} }
} }
@ -147,28 +147,28 @@ void main_inner(uint idx) {
sb.Store4(((800u * idx) + 128u), asuint((0).xxxx)); sb.Store4(((800u * idx) + 128u), asuint((0).xxxx));
sb.Store4(((800u * idx) + 144u), asuint((0u).xxxx)); sb.Store4(((800u * idx) + 144u), asuint((0u).xxxx));
sb.Store<vector<float16_t, 4> >(((800u * idx) + 160u), (float16_t(0.0h)).xxxx); sb.Store<vector<float16_t, 4> >(((800u * idx) + 160u), (float16_t(0.0h)).xxxx);
tint_symbol_18(sb, ((800u * idx) + 168u), float2x2((0.0f).xx, (0.0f).xx)); sb_store_16(((800u * idx) + 168u), float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_19(sb, ((800u * idx) + 192u), float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_17(((800u * idx) + 192u), float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_20(sb, ((800u * idx) + 224u), float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_18(((800u * idx) + 224u), float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_21(sb, ((800u * idx) + 256u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_19(((800u * idx) + 256u), float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_22(sb, ((800u * idx) + 288u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_20(((800u * idx) + 288u), float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_23(sb, ((800u * idx) + 336u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_21(((800u * idx) + 336u), float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_24(sb, ((800u * idx) + 384u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_22(((800u * idx) + 384u), float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_25(sb, ((800u * idx) + 416u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_23(((800u * idx) + 416u), float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_26(sb, ((800u * idx) + 480u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_24(((800u * idx) + 480u), float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_27(sb, ((800u * idx) + 544u), matrix<float16_t, 2, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_25(((800u * idx) + 544u), matrix<float16_t, 2, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_28(sb, ((800u * idx) + 552u), matrix<float16_t, 2, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_26(((800u * idx) + 552u), matrix<float16_t, 2, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_29(sb, ((800u * idx) + 568u), matrix<float16_t, 2, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_27(((800u * idx) + 568u), matrix<float16_t, 2, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
tint_symbol_30(sb, ((800u * idx) + 584u), matrix<float16_t, 3, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_28(((800u * idx) + 584u), matrix<float16_t, 3, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_31(sb, ((800u * idx) + 600u), matrix<float16_t, 3, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_29(((800u * idx) + 600u), matrix<float16_t, 3, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_32(sb, ((800u * idx) + 624u), matrix<float16_t, 3, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_30(((800u * idx) + 624u), matrix<float16_t, 3, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
tint_symbol_33(sb, ((800u * idx) + 648u), matrix<float16_t, 4, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_31(((800u * idx) + 648u), matrix<float16_t, 4, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_34(sb, ((800u * idx) + 664u), matrix<float16_t, 4, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_32(((800u * idx) + 664u), matrix<float16_t, 4, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_35(sb, ((800u * idx) + 696u), matrix<float16_t, 4, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_33(((800u * idx) + 696u), matrix<float16_t, 4, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
const float3 tint_symbol_38[2] = (float3[2])0; const float3 tint_symbol_2[2] = (float3[2])0;
tint_symbol_36(sb, ((800u * idx) + 736u), tint_symbol_38); sb_store_34(((800u * idx) + 736u), tint_symbol_2);
const matrix<float16_t, 4, 2> tint_symbol_39[2] = (matrix<float16_t, 4, 2>[2])0; const matrix<float16_t, 4, 2> tint_symbol_3[2] = (matrix<float16_t, 4, 2>[2])0;
tint_symbol_37(sb, ((800u * idx) + 768u), tint_symbol_39); sb_store_35(((800u * idx) + 768u), tint_symbol_3);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

78
test/tint/buffer/storage/static_index/read.wgsl.expected.dxc.hlsl
View File

@ -5,64 +5,64 @@ struct Inner {
ByteAddressBuffer sb : register(t0, space0); ByteAddressBuffer sb : register(t0, space0);
float2x2 tint_symbol_12(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_12(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_13(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_13(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_14(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_14(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_15(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_15(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_16(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_16(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_17(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_17(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_18(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_19(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_20(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
typedef float3 tint_symbol_21_ret[2]; typedef float3 sb_load_21_ret[2];
tint_symbol_21_ret tint_symbol_21(ByteAddressBuffer buffer, uint offset) { sb_load_21_ret sb_load_21(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr; return arr;
} }
Inner tint_symbol_22(ByteAddressBuffer buffer, uint offset) { Inner sb_load_22(uint offset) {
const Inner tint_symbol_24 = {asint(buffer.Load((offset + 0u))), asfloat(buffer.Load((offset + 4u)))}; const Inner tint_symbol = {asint(sb.Load((offset + 0u))), asfloat(sb.Load((offset + 4u)))};
return tint_symbol_24; return tint_symbol;
} }
typedef Inner tint_symbol_23_ret[4]; typedef Inner sb_load_23_ret[4];
tint_symbol_23_ret tint_symbol_23(ByteAddressBuffer buffer, uint offset) { sb_load_23_ret sb_load_23(uint offset) {
Inner arr_1[4] = (Inner[4])0; Inner arr_1[4] = (Inner[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_22(buffer, (offset + (i_1 * 8u))); arr_1[i_1] = sb_load_22((offset + (i_1 * 8u)));
} }
} }
return arr_1; return arr_1;
@ -82,17 +82,17 @@ void main() {
const float4 vec4_f32 = asfloat(sb.Load4(96u)); const float4 vec4_f32 = asfloat(sb.Load4(96u));
const int4 vec4_i32 = asint(sb.Load4(112u)); const int4 vec4_i32 = asint(sb.Load4(112u));
const uint4 vec4_u32 = sb.Load4(128u); const uint4 vec4_u32 = sb.Load4(128u);
const float2x2 mat2x2_f32 = tint_symbol_12(sb, 144u); const float2x2 mat2x2_f32 = sb_load_12(144u);
const float2x3 mat2x3_f32 = tint_symbol_13(sb, 160u); const float2x3 mat2x3_f32 = sb_load_13(160u);
const float2x4 mat2x4_f32 = tint_symbol_14(sb, 192u); const float2x4 mat2x4_f32 = sb_load_14(192u);
const float3x2 mat3x2_f32 = tint_symbol_15(sb, 224u); const float3x2 mat3x2_f32 = sb_load_15(224u);
const float3x3 mat3x3_f32 = tint_symbol_16(sb, 256u); const float3x3 mat3x3_f32 = sb_load_16(256u);
const float3x4 mat3x4_f32 = tint_symbol_17(sb, 304u); const float3x4 mat3x4_f32 = sb_load_17(304u);
const float4x2 mat4x2_f32 = tint_symbol_18(sb, 352u); const float4x2 mat4x2_f32 = sb_load_18(352u);
const float4x3 mat4x3_f32 = tint_symbol_19(sb, 384u); const float4x3 mat4x3_f32 = sb_load_19(384u);
const float4x4 mat4x4_f32 = tint_symbol_20(sb, 448u); const float4x4 mat4x4_f32 = sb_load_20(448u);
const float3 arr2_vec3_f32[2] = tint_symbol_21(sb, 512u); const float3 arr2_vec3_f32[2] = sb_load_21(512u);
const Inner struct_inner = tint_symbol_22(sb, 544u); const Inner struct_inner = sb_load_22(544u);
const Inner array_struct_inner[4] = tint_symbol_23(sb, 552u); const Inner array_struct_inner[4] = sb_load_23(552u);
return; return;
} }

78
test/tint/buffer/storage/static_index/read.wgsl.expected.fxc.hlsl
View File

@ -5,64 +5,64 @@ struct Inner {
ByteAddressBuffer sb : register(t0, space0); ByteAddressBuffer sb : register(t0, space0);
float2x2 tint_symbol_12(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_12(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_13(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_13(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_14(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_14(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_15(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_15(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_16(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_16(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_17(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_17(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_18(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_19(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_20(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
typedef float3 tint_symbol_21_ret[2]; typedef float3 sb_load_21_ret[2];
tint_symbol_21_ret tint_symbol_21(ByteAddressBuffer buffer, uint offset) { sb_load_21_ret sb_load_21(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr; return arr;
} }
Inner tint_symbol_22(ByteAddressBuffer buffer, uint offset) { Inner sb_load_22(uint offset) {
const Inner tint_symbol_24 = {asint(buffer.Load((offset + 0u))), asfloat(buffer.Load((offset + 4u)))}; const Inner tint_symbol = {asint(sb.Load((offset + 0u))), asfloat(sb.Load((offset + 4u)))};
return tint_symbol_24; return tint_symbol;
} }
typedef Inner tint_symbol_23_ret[4]; typedef Inner sb_load_23_ret[4];
tint_symbol_23_ret tint_symbol_23(ByteAddressBuffer buffer, uint offset) { sb_load_23_ret sb_load_23(uint offset) {
Inner arr_1[4] = (Inner[4])0; Inner arr_1[4] = (Inner[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_22(buffer, (offset + (i_1 * 8u))); arr_1[i_1] = sb_load_22((offset + (i_1 * 8u)));
} }
} }
return arr_1; return arr_1;
@ -82,17 +82,17 @@ void main() {
const float4 vec4_f32 = asfloat(sb.Load4(96u)); const float4 vec4_f32 = asfloat(sb.Load4(96u));
const int4 vec4_i32 = asint(sb.Load4(112u)); const int4 vec4_i32 = asint(sb.Load4(112u));
const uint4 vec4_u32 = sb.Load4(128u); const uint4 vec4_u32 = sb.Load4(128u);
const float2x2 mat2x2_f32 = tint_symbol_12(sb, 144u); const float2x2 mat2x2_f32 = sb_load_12(144u);
const float2x3 mat2x3_f32 = tint_symbol_13(sb, 160u); const float2x3 mat2x3_f32 = sb_load_13(160u);
const float2x4 mat2x4_f32 = tint_symbol_14(sb, 192u); const float2x4 mat2x4_f32 = sb_load_14(192u);
const float3x2 mat3x2_f32 = tint_symbol_15(sb, 224u); const float3x2 mat3x2_f32 = sb_load_15(224u);
const float3x3 mat3x3_f32 = tint_symbol_16(sb, 256u); const float3x3 mat3x3_f32 = sb_load_16(256u);
const float3x4 mat3x4_f32 = tint_symbol_17(sb, 304u); const float3x4 mat3x4_f32 = sb_load_17(304u);
const float4x2 mat4x2_f32 = tint_symbol_18(sb, 352u); const float4x2 mat4x2_f32 = sb_load_18(352u);
const float4x3 mat4x3_f32 = tint_symbol_19(sb, 384u); const float4x3 mat4x3_f32 = sb_load_19(384u);
const float4x4 mat4x4_f32 = tint_symbol_20(sb, 448u); const float4x4 mat4x4_f32 = sb_load_20(448u);
const float3 arr2_vec3_f32[2] = tint_symbol_21(sb, 512u); const float3 arr2_vec3_f32[2] = sb_load_21(512u);
const Inner struct_inner = tint_symbol_22(sb, 544u); const Inner struct_inner = sb_load_22(544u);
const Inner array_struct_inner[4] = tint_symbol_23(sb, 552u); const Inner array_struct_inner[4] = sb_load_23(552u);
return; return;
} }

140
test/tint/buffer/storage/static_index/read_f16.wgsl.expected.dxc.hlsl
View File

@ -6,111 +6,111 @@ struct Inner {
ByteAddressBuffer sb : register(t0, space0); ByteAddressBuffer sb : register(t0, space0);
float2x2 tint_symbol_16(ByteAddressBuffer buffer, uint offset) { float2x2 sb_load_16(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))));
} }
float2x3 tint_symbol_17(ByteAddressBuffer buffer, uint offset) { float2x3 sb_load_17(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))));
} }
float2x4 tint_symbol_18(ByteAddressBuffer buffer, uint offset) { float2x4 sb_load_18(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))));
} }
float3x2 tint_symbol_19(ByteAddressBuffer buffer, uint offset) { float3x2 sb_load_19(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))));
} }
float3x3 tint_symbol_20(ByteAddressBuffer buffer, uint offset) { float3x3 sb_load_20(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))));
} }
float3x4 tint_symbol_21(ByteAddressBuffer buffer, uint offset) { float3x4 sb_load_21(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))));
} }
float4x2 tint_symbol_22(ByteAddressBuffer buffer, uint offset) { float4x2 sb_load_22(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(sb.Load2((offset + 0u))), asfloat(sb.Load2((offset + 8u))), asfloat(sb.Load2((offset + 16u))), asfloat(sb.Load2((offset + 24u))));
} }
float4x3 tint_symbol_23(ByteAddressBuffer buffer, uint offset) { float4x3 sb_load_23(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(sb.Load3((offset + 0u))), asfloat(sb.Load3((offset + 16u))), asfloat(sb.Load3((offset + 32u))), asfloat(sb.Load3((offset + 48u))));
} }
float4x4 tint_symbol_24(ByteAddressBuffer buffer, uint offset) { float4x4 sb_load_24(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(sb.Load4((offset + 0u))), asfloat(sb.Load4((offset + 16u))), asfloat(sb.Load4((offset + 32u))), asfloat(sb.Load4((offset + 48u))));
} }
matrix<float16_t, 2, 2> tint_symbol_25(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 2> sb_load_25(uint offset) {
return matrix<float16_t, 2, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u))); return matrix<float16_t, 2, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)));
} }
matrix<float16_t, 2, 3> tint_symbol_26(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 3> sb_load_26(uint offset) {
return matrix<float16_t, 2, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u))); return matrix<float16_t, 2, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)));
} }
matrix<float16_t, 2, 4> tint_symbol_27(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 4> sb_load_27(uint offset) {
return matrix<float16_t, 2, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u))); return matrix<float16_t, 2, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)));
} }
matrix<float16_t, 3, 2> tint_symbol_28(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 2> sb_load_28(uint offset) {
return matrix<float16_t, 3, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u))); return matrix<float16_t, 3, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)), sb.Load<vector<float16_t, 2> >((offset + 8u)));
} }
matrix<float16_t, 3, 3> tint_symbol_29(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 3> sb_load_29(uint offset) {
return matrix<float16_t, 3, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u))); return matrix<float16_t, 3, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)), sb.Load<vector<float16_t, 3> >((offset + 16u)));
} }
matrix<float16_t, 3, 4> tint_symbol_30(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 4> sb_load_30(uint offset) {
return matrix<float16_t, 3, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u))); return matrix<float16_t, 3, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)), sb.Load<vector<float16_t, 4> >((offset + 16u)));
} }
matrix<float16_t, 4, 2> tint_symbol_31(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 2> sb_load_31(uint offset) {
return matrix<float16_t, 4, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u)), buffer.Load<vector<float16_t, 2> >((offset + 12u))); return matrix<float16_t, 4, 2>(sb.Load<vector<float16_t, 2> >((offset + 0u)), sb.Load<vector<float16_t, 2> >((offset + 4u)), sb.Load<vector<float16_t, 2> >((offset + 8u)), sb.Load<vector<float16_t, 2> >((offset + 12u)));
} }
matrix<float16_t, 4, 3> tint_symbol_32(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 3> sb_load_32(uint offset) {
return matrix<float16_t, 4, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u)), buffer.Load<vector<float16_t, 3> >((offset + 24u))); return matrix<float16_t, 4, 3>(sb.Load<vector<float16_t, 3> >((offset + 0u)), sb.Load<vector<float16_t, 3> >((offset + 8u)), sb.Load<vector<float16_t, 3> >((offset + 16u)), sb.Load<vector<float16_t, 3> >((offset + 24u)));
} }
matrix<float16_t, 4, 4> tint_symbol_33(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 4> sb_load_33(uint offset) {
return matrix<float16_t, 4, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u)), buffer.Load<vector<float16_t, 4> >((offset + 24u))); return matrix<float16_t, 4, 4>(sb.Load<vector<float16_t, 4> >((offset + 0u)), sb.Load<vector<float16_t, 4> >((offset + 8u)), sb.Load<vector<float16_t, 4> >((offset + 16u)), sb.Load<vector<float16_t, 4> >((offset + 24u)));
} }
typedef float3 tint_symbol_34_ret[2]; typedef float3 sb_load_34_ret[2];
tint_symbol_34_ret tint_symbol_34(ByteAddressBuffer buffer, uint offset) { sb_load_34_ret sb_load_34(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
arr[i] = asfloat(buffer.Load3((offset + (i * 16u)))); arr[i] = asfloat(sb.Load3((offset + (i * 16u))));
} }
} }
return arr; return arr;
} }
typedef matrix<float16_t, 4, 2> tint_symbol_35_ret[2]; typedef matrix<float16_t, 4, 2> sb_load_35_ret[2];
tint_symbol_35_ret tint_symbol_35(ByteAddressBuffer buffer, uint offset) { sb_load_35_ret sb_load_35(uint offset) {
matrix<float16_t, 4, 2> arr_1[2] = (matrix<float16_t, 4, 2>[2])0; matrix<float16_t, 4, 2> arr_1[2] = (matrix<float16_t, 4, 2>[2])0;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_31(buffer, (offset + (i_1 * 16u))); arr_1[i_1] = sb_load_31((offset + (i_1 * 16u)));
} }
} }
return arr_1; return arr_1;
} }
Inner tint_symbol_36(ByteAddressBuffer buffer, uint offset) { Inner sb_load_36(uint offset) {
const Inner tint_symbol_38 = {asint(buffer.Load((offset + 0u))), asfloat(buffer.Load((offset + 4u))), buffer.Load<float16_t>((offset + 8u))}; const Inner tint_symbol = {asint(sb.Load((offset + 0u))), asfloat(sb.Load((offset + 4u))), sb.Load<float16_t>((offset + 8u))};
return tint_symbol_38; return tint_symbol;
} }
typedef Inner tint_symbol_37_ret[4]; typedef Inner sb_load_37_ret[4];
tint_symbol_37_ret tint_symbol_37(ByteAddressBuffer buffer, uint offset) { sb_load_37_ret sb_load_37(uint offset) {
Inner arr_2[4] = (Inner[4])0; Inner arr_2[4] = (Inner[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = tint_symbol_36(buffer, (offset + (i_2 * 12u))); arr_2[i_2] = sb_load_36((offset + (i_2 * 12u)));
} }
} }
return arr_2; return arr_2;
@ -134,27 +134,27 @@ void main() {
const int4 vec4_i32 = asint(sb.Load4(128u)); const int4 vec4_i32 = asint(sb.Load4(128u));
const uint4 vec4_u32 = sb.Load4(144u); const uint4 vec4_u32 = sb.Load4(144u);
const vector<float16_t, 4> vec4_f16 = sb.Load<vector<float16_t, 4> >(160u); const vector<float16_t, 4> vec4_f16 = sb.Load<vector<float16_t, 4> >(160u);
const float2x2 mat2x2_f32 = tint_symbol_16(sb, 168u); const float2x2 mat2x2_f32 = sb_load_16(168u);
const float2x3 mat2x3_f32 = tint_symbol_17(sb, 192u); const float2x3 mat2x3_f32 = sb_load_17(192u);
const float2x4 mat2x4_f32 = tint_symbol_18(sb, 224u); const float2x4 mat2x4_f32 = sb_load_18(224u);
const float3x2 mat3x2_f32 = tint_symbol_19(sb, 256u); const float3x2 mat3x2_f32 = sb_load_19(256u);
const float3x3 mat3x3_f32 = tint_symbol_20(sb, 288u); const float3x3 mat3x3_f32 = sb_load_20(288u);
const float3x4 mat3x4_f32 = tint_symbol_21(sb, 336u); const float3x4 mat3x4_f32 = sb_load_21(336u);
const float4x2 mat4x2_f32 = tint_symbol_22(sb, 384u); const float4x2 mat4x2_f32 = sb_load_22(384u);
const float4x3 mat4x3_f32 = tint_symbol_23(sb, 416u); const float4x3 mat4x3_f32 = sb_load_23(416u);
const float4x4 mat4x4_f32 = tint_symbol_24(sb, 480u); const float4x4 mat4x4_f32 = sb_load_24(480u);
const matrix<float16_t, 2, 2> mat2x2_f16 = tint_symbol_25(sb, 544u); const matrix<float16_t, 2, 2> mat2x2_f16 = sb_load_25(544u);
const matrix<float16_t, 2, 3> mat2x3_f16 = tint_symbol_26(sb, 552u); const matrix<float16_t, 2, 3> mat2x3_f16 = sb_load_26(552u);
const matrix<float16_t, 2, 4> mat2x4_f16 = tint_symbol_27(sb, 568u); const matrix<float16_t, 2, 4> mat2x4_f16 = sb_load_27(568u);
const matrix<float16_t, 3, 2> mat3x2_f16 = tint_symbol_28(sb, 584u); const matrix<float16_t, 3, 2> mat3x2_f16 = sb_load_28(584u);
const matrix<float16_t, 3, 3> mat3x3_f16 = tint_symbol_29(sb, 600u); const matrix<float16_t, 3, 3> mat3x3_f16 = sb_load_29(600u);
const matrix<float16_t, 3, 4> mat3x4_f16 = tint_symbol_30(sb, 624u); const matrix<float16_t, 3, 4> mat3x4_f16 = sb_load_30(624u);
const matrix<float16_t, 4, 2> mat4x2_f16 = tint_symbol_31(sb, 648u); const matrix<float16_t, 4, 2> mat4x2_f16 = sb_load_31(648u);
const matrix<float16_t, 4, 3> mat4x3_f16 = tint_symbol_32(sb, 664u); const matrix<float16_t, 4, 3> mat4x3_f16 = sb_load_32(664u);
const matrix<float16_t, 4, 4> mat4x4_f16 = tint_symbol_33(sb, 696u); const matrix<float16_t, 4, 4> mat4x4_f16 = sb_load_33(696u);
const float3 arr2_vec3_f32[2] = tint_symbol_34(sb, 736u); const float3 arr2_vec3_f32[2] = sb_load_34(736u);
const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = tint_symbol_35(sb, 768u); const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = sb_load_35(768u);
const Inner struct_inner = tint_symbol_36(sb, 800u); const Inner struct_inner = sb_load_36(800u);
const Inner array_struct_inner[4] = tint_symbol_37(sb, 812u); const Inner array_struct_inner[4] = sb_load_37(812u);
return; return;
} }

116
test/tint/buffer/storage/static_index/write.wgsl.expected.dxc.hlsl
View File

@ -5,79 +5,79 @@ struct Inner {
RWByteAddressBuffer sb : register(u0, space0); RWByteAddressBuffer sb : register(u0, space0);
void tint_symbol_12(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_12(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_13(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_13(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_14(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_14(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_15(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_15(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_16(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_16(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_17(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_17(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_18(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_19(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_20(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_21(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, Inner value) { void sb_store_22(uint offset, Inner value) {
buffer.Store((offset + 0u), asuint(value.scalar_i32)); sb.Store((offset + 0u), asuint(value.scalar_i32));
buffer.Store((offset + 4u), asuint(value.scalar_f32)); sb.Store((offset + 4u), asuint(value.scalar_f32));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, Inner value[4]) { void sb_store_23(uint offset, Inner value[4]) {
Inner array_2[4] = value; Inner array_2[4] = value;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
tint_symbol_22(buffer, (offset + (i_1 * 8u)), array_2[i_1]); sb_store_22((offset + (i_1 * 8u)), array_2[i_1]);
} }
} }
} }
@ -96,20 +96,20 @@ void main() {
sb.Store4(96u, asuint((0.0f).xxxx)); sb.Store4(96u, asuint((0.0f).xxxx));
sb.Store4(112u, asuint((0).xxxx)); sb.Store4(112u, asuint((0).xxxx));
sb.Store4(128u, asuint((0u).xxxx)); sb.Store4(128u, asuint((0u).xxxx));
tint_symbol_12(sb, 144u, float2x2((0.0f).xx, (0.0f).xx)); sb_store_12(144u, float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_13(sb, 160u, float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_13(160u, float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_14(sb, 192u, float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_14(192u, float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_15(sb, 224u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_15(224u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_16(sb, 256u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_16(256u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_17(sb, 304u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_17(304u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_18(sb, 352u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_18(352u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_19(sb, 384u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_19(384u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_20(sb, 448u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_20(448u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
const float3 tint_symbol_24[2] = (float3[2])0; const float3 tint_symbol[2] = (float3[2])0;
tint_symbol_21(sb, 512u, tint_symbol_24); sb_store_21(512u, tint_symbol);
const Inner tint_symbol_25 = (Inner)0; const Inner tint_symbol_1 = (Inner)0;
tint_symbol_22(sb, 544u, tint_symbol_25); sb_store_22(544u, tint_symbol_1);
const Inner tint_symbol_26[4] = (Inner[4])0; const Inner tint_symbol_2[4] = (Inner[4])0;
tint_symbol_23(sb, 552u, tint_symbol_26); sb_store_23(552u, tint_symbol_2);
return; return;
} }

116
test/tint/buffer/storage/static_index/write.wgsl.expected.fxc.hlsl
View File

@ -5,79 +5,79 @@ struct Inner {
RWByteAddressBuffer sb : register(u0, space0); RWByteAddressBuffer sb : register(u0, space0);
void tint_symbol_12(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_12(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_13(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_13(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_14(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_14(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_15(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_15(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_16(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_16(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_17(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_17(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_18(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_19(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_20(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_21(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, Inner value) { void sb_store_22(uint offset, Inner value) {
buffer.Store((offset + 0u), asuint(value.scalar_i32)); sb.Store((offset + 0u), asuint(value.scalar_i32));
buffer.Store((offset + 4u), asuint(value.scalar_f32)); sb.Store((offset + 4u), asuint(value.scalar_f32));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, Inner value[4]) { void sb_store_23(uint offset, Inner value[4]) {
Inner array_2[4] = value; Inner array_2[4] = value;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
tint_symbol_22(buffer, (offset + (i_1 * 8u)), array_2[i_1]); sb_store_22((offset + (i_1 * 8u)), array_2[i_1]);
} }
} }
} }
@ -96,20 +96,20 @@ void main() {
sb.Store4(96u, asuint((0.0f).xxxx)); sb.Store4(96u, asuint((0.0f).xxxx));
sb.Store4(112u, asuint((0).xxxx)); sb.Store4(112u, asuint((0).xxxx));
sb.Store4(128u, asuint((0u).xxxx)); sb.Store4(128u, asuint((0u).xxxx));
tint_symbol_12(sb, 144u, float2x2((0.0f).xx, (0.0f).xx)); sb_store_12(144u, float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_13(sb, 160u, float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_13(160u, float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_14(sb, 192u, float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_14(192u, float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_15(sb, 224u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_15(224u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_16(sb, 256u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_16(256u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_17(sb, 304u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_17(304u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_18(sb, 352u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_18(352u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_19(sb, 384u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_19(384u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_20(sb, 448u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_20(448u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
const float3 tint_symbol_24[2] = (float3[2])0; const float3 tint_symbol[2] = (float3[2])0;
tint_symbol_21(sb, 512u, tint_symbol_24); sb_store_21(512u, tint_symbol);
const Inner tint_symbol_25 = (Inner)0; const Inner tint_symbol_1 = (Inner)0;
tint_symbol_22(sb, 544u, tint_symbol_25); sb_store_22(544u, tint_symbol_1);
const Inner tint_symbol_26[4] = (Inner[4])0; const Inner tint_symbol_2[4] = (Inner[4])0;
tint_symbol_23(sb, 552u, tint_symbol_26); sb_store_23(552u, tint_symbol_2);
return; return;
} }

216
test/tint/buffer/storage/static_index/write_f16.wgsl.expected.dxc.hlsl
View File

@ -6,143 +6,143 @@ struct Inner {
RWByteAddressBuffer sb : register(u0, space0); RWByteAddressBuffer sb : register(u0, space0);
void tint_symbol_16(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void sb_store_16(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol_17(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void sb_store_17(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_18(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void sb_store_18(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_19(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void sb_store_19(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
} }
void tint_symbol_20(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void sb_store_20(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_21(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void sb_store_21(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
} }
void tint_symbol_22(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void sb_store_22(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); sb.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); sb.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); sb.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); sb.Store2((offset + 24u), asuint(value[3u]));
} }
void tint_symbol_23(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void sb_store_23(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); sb.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); sb.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); sb.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); sb.Store3((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_24(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void sb_store_24(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); sb.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); sb.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); sb.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); sb.Store4((offset + 48u), asuint(value[3u]));
} }
void tint_symbol_25(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 2> value) { void sb_store_25(uint offset, matrix<float16_t, 2, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
} }
void tint_symbol_26(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 3> value) { void sb_store_26(uint offset, matrix<float16_t, 2, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
} }
void tint_symbol_27(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 4> value) { void sb_store_27(uint offset, matrix<float16_t, 2, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
} }
void tint_symbol_28(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 2> value) { void sb_store_28(uint offset, matrix<float16_t, 3, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); sb.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
} }
void tint_symbol_29(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 3> value) { void sb_store_29(uint offset, matrix<float16_t, 3, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
} }
void tint_symbol_30(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 4> value) { void sb_store_30(uint offset, matrix<float16_t, 3, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
} }
void tint_symbol_31(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 2> value) { void sb_store_31(uint offset, matrix<float16_t, 4, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); sb.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); sb.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
buffer.Store<vector<float16_t, 2> >((offset + 12u), value[3u]); sb.Store<vector<float16_t, 2> >((offset + 12u), value[3u]);
} }
void tint_symbol_32(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 3> value) { void sb_store_32(uint offset, matrix<float16_t, 4, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 3> >((offset + 24u), value[3u]); sb.Store<vector<float16_t, 3> >((offset + 24u), value[3u]);
} }
void tint_symbol_33(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 4> value) { void sb_store_33(uint offset, matrix<float16_t, 4, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); sb.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); sb.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); sb.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 4> >((offset + 24u), value[3u]); sb.Store<vector<float16_t, 4> >((offset + 24u), value[3u]);
} }
void tint_symbol_34(RWByteAddressBuffer buffer, uint offset, float3 value[2]) { void sb_store_34(uint offset, float3 value[2]) {
float3 array_1[2] = value; float3 array_1[2] = value;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
buffer.Store3((offset + (i * 16u)), asuint(array_1[i])); sb.Store3((offset + (i * 16u)), asuint(array_1[i]));
} }
} }
} }
void tint_symbol_35(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 2> value[2]) { void sb_store_35(uint offset, matrix<float16_t, 4, 2> value[2]) {
matrix<float16_t, 4, 2> array_2[2] = value; matrix<float16_t, 4, 2> array_2[2] = value;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
tint_symbol_31(buffer, (offset + (i_1 * 16u)), array_2[i_1]); sb_store_31((offset + (i_1 * 16u)), array_2[i_1]);
} }
} }
} }
void tint_symbol_36(RWByteAddressBuffer buffer, uint offset, Inner value) { void sb_store_36(uint offset, Inner value) {
buffer.Store((offset + 0u), asuint(value.scalar_i32)); sb.Store((offset + 0u), asuint(value.scalar_i32));
buffer.Store((offset + 4u), asuint(value.scalar_f32)); sb.Store((offset + 4u), asuint(value.scalar_f32));
buffer.Store<float16_t>((offset + 8u), value.scalar_f16); sb.Store<float16_t>((offset + 8u), value.scalar_f16);
} }
void tint_symbol_37(RWByteAddressBuffer buffer, uint offset, Inner value[4]) { void sb_store_37(uint offset, Inner value[4]) {
Inner array_3[4] = value; Inner array_3[4] = value;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
tint_symbol_36(buffer, (offset + (i_2 * 12u)), array_3[i_2]); sb_store_36((offset + (i_2 * 12u)), array_3[i_2]);
} }
} }
} }
@ -165,31 +165,31 @@ void main() {
sb.Store4(128u, asuint((0).xxxx)); sb.Store4(128u, asuint((0).xxxx));
sb.Store4(144u, asuint((0u).xxxx)); sb.Store4(144u, asuint((0u).xxxx));
sb.Store<vector<float16_t, 4> >(160u, (float16_t(0.0h)).xxxx); sb.Store<vector<float16_t, 4> >(160u, (float16_t(0.0h)).xxxx);
tint_symbol_16(sb, 168u, float2x2((0.0f).xx, (0.0f).xx)); sb_store_16(168u, float2x2((0.0f).xx, (0.0f).xx));
tint_symbol_17(sb, 192u, float2x3((0.0f).xxx, (0.0f).xxx)); sb_store_17(192u, float2x3((0.0f).xxx, (0.0f).xxx));
tint_symbol_18(sb, 224u, float2x4((0.0f).xxxx, (0.0f).xxxx)); sb_store_18(224u, float2x4((0.0f).xxxx, (0.0f).xxxx));
tint_symbol_19(sb, 256u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_19(256u, float3x2((0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_20(sb, 288u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_20(288u, float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_21(sb, 336u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_21(336u, float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_22(sb, 384u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx)); sb_store_22(384u, float4x2((0.0f).xx, (0.0f).xx, (0.0f).xx, (0.0f).xx));
tint_symbol_23(sb, 416u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx)); sb_store_23(416u, float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx));
tint_symbol_24(sb, 480u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)); sb_store_24(480u, float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx));
tint_symbol_25(sb, 544u, matrix<float16_t, 2, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_25(544u, matrix<float16_t, 2, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_26(sb, 552u, matrix<float16_t, 2, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_26(552u, matrix<float16_t, 2, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_27(sb, 568u, matrix<float16_t, 2, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_27(568u, matrix<float16_t, 2, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
tint_symbol_28(sb, 584u, matrix<float16_t, 3, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_28(584u, matrix<float16_t, 3, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_29(sb, 600u, matrix<float16_t, 3, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_29(600u, matrix<float16_t, 3, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_30(sb, 624u, matrix<float16_t, 3, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_30(624u, matrix<float16_t, 3, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
tint_symbol_31(sb, 648u, matrix<float16_t, 4, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx)); sb_store_31(648u, matrix<float16_t, 4, 2>((float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx, (float16_t(0.0h)).xx));
tint_symbol_32(sb, 664u, matrix<float16_t, 4, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx)); sb_store_32(664u, matrix<float16_t, 4, 3>((float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx, (float16_t(0.0h)).xxx));
tint_symbol_33(sb, 696u, matrix<float16_t, 4, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx)); sb_store_33(696u, matrix<float16_t, 4, 4>((float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx, (float16_t(0.0h)).xxxx));
const float3 tint_symbol_38[2] = (float3[2])0; const float3 tint_symbol[2] = (float3[2])0;
tint_symbol_34(sb, 736u, tint_symbol_38); sb_store_34(736u, tint_symbol);
const matrix<float16_t, 4, 2> tint_symbol_39[2] = (matrix<float16_t, 4, 2>[2])0; const matrix<float16_t, 4, 2> tint_symbol_1[2] = (matrix<float16_t, 4, 2>[2])0;
tint_symbol_35(sb, 768u, tint_symbol_39); sb_store_35(768u, tint_symbol_1);
const Inner tint_symbol_40 = (Inner)0; const Inner tint_symbol_2 = (Inner)0;
tint_symbol_36(sb, 800u, tint_symbol_40); sb_store_36(800u, tint_symbol_2);
const Inner tint_symbol_41[4] = (Inner[4])0; const Inner tint_symbol_3[4] = (Inner[4])0;
tint_symbol_37(sb, 812u, tint_symbol_41); sb_store_37(812u, tint_symbol_3);
return; return;
} }

12
test/tint/buffer/storage/types/array4_f16.wgsl.expected.dxc.hlsl
View File

@ -1,21 +1,21 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float16_t value[4]) { void tint_symbol_1_store(uint offset, float16_t value[4]) {
float16_t array_1[4] = value; float16_t array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
buffer.Store<float16_t>((offset + (i * 2u)), array_1[i]); tint_symbol_1.Store<float16_t>((offset + (i * 2u)), array_1[i]);
} }
} }
} }
typedef float16_t tint_symbol_4_ret[4]; typedef float16_t tint_symbol_load_ret[4];
tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) { tint_symbol_load_ret tint_symbol_load(uint offset) {
float16_t arr[4] = (float16_t[4])0; float16_t arr[4] = (float16_t[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = buffer.Load<float16_t>((offset + (i_1 * 2u))); arr[i_1] = tint_symbol.Load<float16_t>((offset + (i_1 * 2u)));
} }
} }
return arr; return arr;
@ -23,6 +23,6 @@ tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/array4_f32.wgsl.expected.dxc.hlsl
View File

@ -1,21 +1,21 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float value[4]) { void tint_symbol_1_store(uint offset, float value[4]) {
float array_1[4] = value; float array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
buffer.Store((offset + (i * 4u)), asuint(array_1[i])); tint_symbol_1.Store((offset + (i * 4u)), asuint(array_1[i]));
} }
} }
} }
typedef float tint_symbol_4_ret[4]; typedef float tint_symbol_load_ret[4];
tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) { tint_symbol_load_ret tint_symbol_load(uint offset) {
float arr[4] = (float[4])0; float arr[4] = (float[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = asfloat(buffer.Load((offset + (i_1 * 4u)))); arr[i_1] = asfloat(tint_symbol.Load((offset + (i_1 * 4u))));
} }
} }
return arr; return arr;
@ -23,6 +23,6 @@ tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/array4_f32.wgsl.expected.fxc.hlsl
View File

@ -1,21 +1,21 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float value[4]) { void tint_symbol_1_store(uint offset, float value[4]) {
float array_1[4] = value; float array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
buffer.Store((offset + (i * 4u)), asuint(array_1[i])); tint_symbol_1.Store((offset + (i * 4u)), asuint(array_1[i]));
} }
} }
} }
typedef float tint_symbol_4_ret[4]; typedef float tint_symbol_load_ret[4];
tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) { tint_symbol_load_ret tint_symbol_load(uint offset) {
float arr[4] = (float[4])0; float arr[4] = (float[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = asfloat(buffer.Load((offset + (i_1 * 4u)))); arr[i_1] = asfloat(tint_symbol.Load((offset + (i_1 * 4u))));
} }
} }
return arr; return arr;
@ -23,6 +23,6 @@ tint_symbol_4_ret tint_symbol_4(ByteAddressBuffer buffer, uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x2_f16.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 2> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 2, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
} }
matrix<float16_t, 2, 2> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 2> tint_symbol_load(uint offset) {
return matrix<float16_t, 2, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u))); return matrix<float16_t, 2, 2>(tint_symbol.Load<vector<float16_t, 2> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 4u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x2_f32.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void tint_symbol_1_store(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
} }
float2x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x2 tint_symbol_load(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x2_f32.wgsl.expected.fxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void tint_symbol_1_store(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
} }
float2x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x2 tint_symbol_load(uint offset) {
return float2x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u)))); return float2x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x3_f16.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 3> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 2, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
} }
matrix<float16_t, 2, 3> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 3> tint_symbol_load(uint offset) {
return matrix<float16_t, 2, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u))); return matrix<float16_t, 2, 3>(tint_symbol.Load<vector<float16_t, 3> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 8u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x3_f32.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void tint_symbol_1_store(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
} }
float2x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x3 tint_symbol_load(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x3_f32.wgsl.expected.fxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void tint_symbol_1_store(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
} }
float2x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x3 tint_symbol_load(uint offset) {
return float2x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u)))); return float2x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x4_f16.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 4> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 2, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
} }
matrix<float16_t, 2, 4> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 4> tint_symbol_load(uint offset) {
return matrix<float16_t, 2, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u))); return matrix<float16_t, 2, 4>(tint_symbol.Load<vector<float16_t, 4> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 8u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x4_f32.wgsl.expected.dxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void tint_symbol_1_store(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
} }
float2x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x4 tint_symbol_load(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

12
test/tint/buffer/storage/types/mat2x4_f32.wgsl.expected.fxc.hlsl
View File

@ -1,17 +1,17 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void tint_symbol_1_store(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
} }
float2x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float2x4 tint_symbol_load(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x2_f16.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 2> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 3, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
} }
matrix<float16_t, 3, 2> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 2> tint_symbol_load(uint offset) {
return matrix<float16_t, 3, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u))); return matrix<float16_t, 3, 2>(tint_symbol.Load<vector<float16_t, 2> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 4u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 8u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x2_f32.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void tint_symbol_1_store(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); tint_symbol_1.Store2((offset + 16u), asuint(value[2u]));
} }
float3x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x2 tint_symbol_load(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))), asfloat(tint_symbol.Load2((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x2_f32.wgsl.expected.fxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x2 value) { void tint_symbol_1_store(uint offset, float3x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); tint_symbol_1.Store2((offset + 16u), asuint(value[2u]));
} }
float3x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x2 tint_symbol_load(uint offset) {
return float3x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u)))); return float3x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))), asfloat(tint_symbol.Load2((offset + 16u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x3_f16.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 3> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 3, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
} }
matrix<float16_t, 3, 3> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 3> tint_symbol_load(uint offset) {
return matrix<float16_t, 3, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u))); return matrix<float16_t, 3, 3>(tint_symbol.Load<vector<float16_t, 3> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 8u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 16u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x3_f32.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void tint_symbol_1_store(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); tint_symbol_1.Store3((offset + 32u), asuint(value[2u]));
} }
float3x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x3 tint_symbol_load(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), asfloat(tint_symbol.Load3((offset + 32u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x3_f32.wgsl.expected.fxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x3 value) { void tint_symbol_1_store(uint offset, float3x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); tint_symbol_1.Store3((offset + 32u), asuint(value[2u]));
} }
float3x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x3 tint_symbol_load(uint offset) {
return float3x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u)))); return float3x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), asfloat(tint_symbol.Load3((offset + 32u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x4_f16.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 3, 4> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 3, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
} }
matrix<float16_t, 3, 4> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 3, 4> tint_symbol_load(uint offset) {
return matrix<float16_t, 3, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u))); return matrix<float16_t, 3, 4>(tint_symbol.Load<vector<float16_t, 4> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 8u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 16u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x4_f32.wgsl.expected.dxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void tint_symbol_1_store(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); tint_symbol_1.Store4((offset + 32u), asuint(value[2u]));
} }
float3x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x4 tint_symbol_load(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))), asfloat(tint_symbol.Load4((offset + 32u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

14
test/tint/buffer/storage/types/mat3x4_f32.wgsl.expected.fxc.hlsl
View File

@ -1,18 +1,18 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float3x4 value) { void tint_symbol_1_store(uint offset, float3x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); tint_symbol_1.Store4((offset + 32u), asuint(value[2u]));
} }
float3x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float3x4 tint_symbol_load(uint offset) {
return float3x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u)))); return float3x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))), asfloat(tint_symbol.Load4((offset + 32u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x2_f16.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 2> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 4, 2> value) {
buffer.Store<vector<float16_t, 2> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 2> >((offset + 4u), value[1u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 4u), value[1u]);
buffer.Store<vector<float16_t, 2> >((offset + 8u), value[2u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 8u), value[2u]);
buffer.Store<vector<float16_t, 2> >((offset + 12u), value[3u]); tint_symbol_1.Store<vector<float16_t, 2> >((offset + 12u), value[3u]);
} }
matrix<float16_t, 4, 2> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 2> tint_symbol_load(uint offset) {
return matrix<float16_t, 4, 2>(buffer.Load<vector<float16_t, 2> >((offset + 0u)), buffer.Load<vector<float16_t, 2> >((offset + 4u)), buffer.Load<vector<float16_t, 2> >((offset + 8u)), buffer.Load<vector<float16_t, 2> >((offset + 12u))); return matrix<float16_t, 4, 2>(tint_symbol.Load<vector<float16_t, 2> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 4u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 8u)), tint_symbol.Load<vector<float16_t, 2> >((offset + 12u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x2_f32.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void tint_symbol_1_store(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); tint_symbol_1.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); tint_symbol_1.Store2((offset + 24u), asuint(value[3u]));
} }
float4x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x2 tint_symbol_load(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))), asfloat(tint_symbol.Load2((offset + 16u))), asfloat(tint_symbol.Load2((offset + 24u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x2_f32.wgsl.expected.fxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x2 value) { void tint_symbol_1_store(uint offset, float4x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); tint_symbol_1.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); tint_symbol_1.Store2((offset + 8u), asuint(value[1u]));
buffer.Store2((offset + 16u), asuint(value[2u])); tint_symbol_1.Store2((offset + 16u), asuint(value[2u]));
buffer.Store2((offset + 24u), asuint(value[3u])); tint_symbol_1.Store2((offset + 24u), asuint(value[3u]));
} }
float4x2 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x2 tint_symbol_load(uint offset) {
return float4x2(asfloat(buffer.Load2((offset + 0u))), asfloat(buffer.Load2((offset + 8u))), asfloat(buffer.Load2((offset + 16u))), asfloat(buffer.Load2((offset + 24u)))); return float4x2(asfloat(tint_symbol.Load2((offset + 0u))), asfloat(tint_symbol.Load2((offset + 8u))), asfloat(tint_symbol.Load2((offset + 16u))), asfloat(tint_symbol.Load2((offset + 24u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x3_f16.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 3> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 4, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 3> >((offset + 16u), value[2u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 3> >((offset + 24u), value[3u]); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 24u), value[3u]);
} }
matrix<float16_t, 4, 3> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 3> tint_symbol_load(uint offset) {
return matrix<float16_t, 4, 3>(buffer.Load<vector<float16_t, 3> >((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), buffer.Load<vector<float16_t, 3> >((offset + 16u)), buffer.Load<vector<float16_t, 3> >((offset + 24u))); return matrix<float16_t, 4, 3>(tint_symbol.Load<vector<float16_t, 3> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 8u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 16u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 24u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x3_f32.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void tint_symbol_1_store(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); tint_symbol_1.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); tint_symbol_1.Store3((offset + 48u), asuint(value[3u]));
} }
float4x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x3 tint_symbol_load(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), asfloat(tint_symbol.Load3((offset + 32u))), asfloat(tint_symbol.Load3((offset + 48u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x3_f32.wgsl.expected.fxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x3 value) { void tint_symbol_1_store(uint offset, float4x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); tint_symbol_1.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); tint_symbol_1.Store3((offset + 16u), asuint(value[1u]));
buffer.Store3((offset + 32u), asuint(value[2u])); tint_symbol_1.Store3((offset + 32u), asuint(value[2u]));
buffer.Store3((offset + 48u), asuint(value[3u])); tint_symbol_1.Store3((offset + 48u), asuint(value[3u]));
} }
float4x3 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x3 tint_symbol_load(uint offset) {
return float4x3(asfloat(buffer.Load3((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), asfloat(buffer.Load3((offset + 32u))), asfloat(buffer.Load3((offset + 48u)))); return float4x3(asfloat(tint_symbol.Load3((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), asfloat(tint_symbol.Load3((offset + 32u))), asfloat(tint_symbol.Load3((offset + 48u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x4_f16.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 4, 4> value) { void tint_symbol_1_store(uint offset, matrix<float16_t, 4, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
buffer.Store<vector<float16_t, 4> >((offset + 16u), value[2u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 16u), value[2u]);
buffer.Store<vector<float16_t, 4> >((offset + 24u), value[3u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 24u), value[3u]);
} }
matrix<float16_t, 4, 4> tint_symbol_4(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 4, 4> tint_symbol_load(uint offset) {
return matrix<float16_t, 4, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u)), buffer.Load<vector<float16_t, 4> >((offset + 16u)), buffer.Load<vector<float16_t, 4> >((offset + 24u))); return matrix<float16_t, 4, 4>(tint_symbol.Load<vector<float16_t, 4> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 8u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 16u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 24u)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x4_f32.wgsl.expected.dxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void tint_symbol_1_store(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); tint_symbol_1.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); tint_symbol_1.Store4((offset + 48u), asuint(value[3u]));
} }
float4x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x4 tint_symbol_load(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))), asfloat(tint_symbol.Load4((offset + 32u))), asfloat(tint_symbol.Load4((offset + 48u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

16
test/tint/buffer/storage/types/mat4x4_f32.wgsl.expected.fxc.hlsl
View File

@ -1,19 +1,19 @@
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
void tint_symbol_2(RWByteAddressBuffer buffer, uint offset, float4x4 value) { void tint_symbol_1_store(uint offset, float4x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
buffer.Store4((offset + 32u), asuint(value[2u])); tint_symbol_1.Store4((offset + 32u), asuint(value[2u]));
buffer.Store4((offset + 48u), asuint(value[3u])); tint_symbol_1.Store4((offset + 48u), asuint(value[3u]));
} }
float4x4 tint_symbol_4(ByteAddressBuffer buffer, uint offset) { float4x4 tint_symbol_load(uint offset) {
return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u)))); return float4x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))), asfloat(tint_symbol.Load4((offset + 32u))), asfloat(tint_symbol.Load4((offset + 48u))));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
tint_symbol_2(tint_symbol_1, 0u, tint_symbol_4(tint_symbol, 0u)); tint_symbol_1_store(0u, tint_symbol_load(0u));
return; return;
} }

38
test/tint/buffer/storage/types/struct_f16.wgsl.expected.dxc.hlsl
View File

@ -10,38 +10,38 @@ struct S {
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
matrix<float16_t, 2, 4> tint_symbol_6(ByteAddressBuffer buffer, uint offset) { matrix<float16_t, 2, 4> tint_symbol_load_4(uint offset) {
return matrix<float16_t, 2, 4>(buffer.Load<vector<float16_t, 4> >((offset + 0u)), buffer.Load<vector<float16_t, 4> >((offset + 8u))); return matrix<float16_t, 2, 4>(tint_symbol.Load<vector<float16_t, 4> >((offset + 0u)), tint_symbol.Load<vector<float16_t, 4> >((offset + 8u)));
} }
Inner tint_symbol_3(ByteAddressBuffer buffer, uint offset) { Inner tint_symbol_load_1(uint offset) {
const Inner tint_symbol_14 = {buffer.Load<float16_t>((offset + 0u)), buffer.Load<vector<float16_t, 3> >((offset + 8u)), tint_symbol_6(buffer, (offset + 16u))}; const Inner tint_symbol_2 = {tint_symbol.Load<float16_t>((offset + 0u)), tint_symbol.Load<vector<float16_t, 3> >((offset + 8u)), tint_symbol_load_4((offset + 16u))};
return tint_symbol_14; return tint_symbol_2;
} }
S tint_symbol_2(ByteAddressBuffer buffer, uint offset) { S tint_symbol_load(uint offset) {
const S tint_symbol_15 = {tint_symbol_3(buffer, (offset + 0u))}; const S tint_symbol_3 = {tint_symbol_load_1((offset + 0u))};
return tint_symbol_15; return tint_symbol_3;
} }
void tint_symbol_12(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 4> value) { void tint_symbol_1_store_4(uint offset, matrix<float16_t, 2, 4> value) {
buffer.Store<vector<float16_t, 4> >((offset + 0u), value[0u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 4> >((offset + 8u), value[1u]); tint_symbol_1.Store<vector<float16_t, 4> >((offset + 8u), value[1u]);
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, Inner value) { void tint_symbol_1_store_1(uint offset, Inner value) {
buffer.Store<float16_t>((offset + 0u), value.scalar_f16); tint_symbol_1.Store<float16_t>((offset + 0u), value.scalar_f16);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value.vec3_f16); tint_symbol_1.Store<vector<float16_t, 3> >((offset + 8u), value.vec3_f16);
tint_symbol_12(buffer, (offset + 16u), value.mat2x4_f16); tint_symbol_1_store_4((offset + 16u), value.mat2x4_f16);
} }
void tint_symbol_8(RWByteAddressBuffer buffer, uint offset, S value) { void tint_symbol_1_store(uint offset, S value) {
tint_symbol_9(buffer, (offset + 0u), value.inner); tint_symbol_1_store_1((offset + 0u), value.inner);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
const S t = tint_symbol_2(tint_symbol, 0u); const S t = tint_symbol_load(0u);
tint_symbol_8(tint_symbol_1, 0u, t); tint_symbol_1_store(0u, t);
return; return;
} }

38
test/tint/buffer/storage/types/struct_f32.wgsl.expected.dxc.hlsl
View File

@ -10,38 +10,38 @@ struct S {
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
float2x4 tint_symbol_6(ByteAddressBuffer buffer, uint offset) { float2x4 tint_symbol_load_4(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))));
} }
Inner tint_symbol_3(ByteAddressBuffer buffer, uint offset) { Inner tint_symbol_load_1(uint offset) {
const Inner tint_symbol_14 = {asfloat(buffer.Load((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), tint_symbol_6(buffer, (offset + 32u))}; const Inner tint_symbol_2 = {asfloat(tint_symbol.Load((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), tint_symbol_load_4((offset + 32u))};
return tint_symbol_14; return tint_symbol_2;
} }
S tint_symbol_2(ByteAddressBuffer buffer, uint offset) { S tint_symbol_load(uint offset) {
const S tint_symbol_15 = {tint_symbol_3(buffer, (offset + 0u))}; const S tint_symbol_3 = {tint_symbol_load_1((offset + 0u))};
return tint_symbol_15; return tint_symbol_3;
} }
void tint_symbol_12(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void tint_symbol_1_store_4(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, Inner value) { void tint_symbol_1_store_1(uint offset, Inner value) {
buffer.Store((offset + 0u), asuint(value.scalar_f32)); tint_symbol_1.Store((offset + 0u), asuint(value.scalar_f32));
buffer.Store3((offset + 16u), asuint(value.vec3_f32)); tint_symbol_1.Store3((offset + 16u), asuint(value.vec3_f32));
tint_symbol_12(buffer, (offset + 32u), value.mat2x4_f32); tint_symbol_1_store_4((offset + 32u), value.mat2x4_f32);
} }
void tint_symbol_8(RWByteAddressBuffer buffer, uint offset, S value) { void tint_symbol_1_store(uint offset, S value) {
tint_symbol_9(buffer, (offset + 0u), value.inner); tint_symbol_1_store_1((offset + 0u), value.inner);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
const S t = tint_symbol_2(tint_symbol, 0u); const S t = tint_symbol_load(0u);
tint_symbol_8(tint_symbol_1, 0u, t); tint_symbol_1_store(0u, t);
return; return;
} }

38
test/tint/buffer/storage/types/struct_f32.wgsl.expected.fxc.hlsl
View File

@ -10,38 +10,38 @@ struct S {
ByteAddressBuffer tint_symbol : register(t0, space0); ByteAddressBuffer tint_symbol : register(t0, space0);
RWByteAddressBuffer tint_symbol_1 : register(u1, space0); RWByteAddressBuffer tint_symbol_1 : register(u1, space0);
float2x4 tint_symbol_6(ByteAddressBuffer buffer, uint offset) { float2x4 tint_symbol_load_4(uint offset) {
return float2x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u)))); return float2x4(asfloat(tint_symbol.Load4((offset + 0u))), asfloat(tint_symbol.Load4((offset + 16u))));
} }
Inner tint_symbol_3(ByteAddressBuffer buffer, uint offset) { Inner tint_symbol_load_1(uint offset) {
const Inner tint_symbol_14 = {asfloat(buffer.Load((offset + 0u))), asfloat(buffer.Load3((offset + 16u))), tint_symbol_6(buffer, (offset + 32u))}; const Inner tint_symbol_2 = {asfloat(tint_symbol.Load((offset + 0u))), asfloat(tint_symbol.Load3((offset + 16u))), tint_symbol_load_4((offset + 32u))};
return tint_symbol_14; return tint_symbol_2;
} }
S tint_symbol_2(ByteAddressBuffer buffer, uint offset) { S tint_symbol_load(uint offset) {
const S tint_symbol_15 = {tint_symbol_3(buffer, (offset + 0u))}; const S tint_symbol_3 = {tint_symbol_load_1((offset + 0u))};
return tint_symbol_15; return tint_symbol_3;
} }
void tint_symbol_12(RWByteAddressBuffer buffer, uint offset, float2x4 value) { void tint_symbol_1_store_4(uint offset, float2x4 value) {
buffer.Store4((offset + 0u), asuint(value[0u])); tint_symbol_1.Store4((offset + 0u), asuint(value[0u]));
buffer.Store4((offset + 16u), asuint(value[1u])); tint_symbol_1.Store4((offset + 16u), asuint(value[1u]));
} }
void tint_symbol_9(RWByteAddressBuffer buffer, uint offset, Inner value) { void tint_symbol_1_store_1(uint offset, Inner value) {
buffer.Store((offset + 0u), asuint(value.scalar_f32)); tint_symbol_1.Store((offset + 0u), asuint(value.scalar_f32));
buffer.Store3((offset + 16u), asuint(value.vec3_f32)); tint_symbol_1.Store3((offset + 16u), asuint(value.vec3_f32));
tint_symbol_12(buffer, (offset + 32u), value.mat2x4_f32); tint_symbol_1_store_4((offset + 32u), value.mat2x4_f32);
} }
void tint_symbol_8(RWByteAddressBuffer buffer, uint offset, S value) { void tint_symbol_1_store(uint offset, S value) {
tint_symbol_9(buffer, (offset + 0u), value.inner); tint_symbol_1_store_1((offset + 0u), value.inner);
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
const S t = tint_symbol_2(tint_symbol, 0u); const S t = tint_symbol_load(0u);
tint_symbol_8(tint_symbol_1, 0u, t); tint_symbol_1_store(0u, t);
return; return;
} }

74
test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.dxc.hlsl
View File

@ -6,85 +6,85 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_14(uint4 buffer[272], uint offset) { float2x2 ub_load_12(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_15(uint4 buffer[272], uint offset) { float2x3 ub_load_13(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_16(uint4 buffer[272], uint offset) { float2x4 ub_load_14(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_17(uint4 buffer[272], uint offset) { float3x2 ub_load_15(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_18(uint4 buffer[272], uint offset) { float3x3 ub_load_16(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_19(uint4 buffer[272], uint offset) { float3x4 ub_load_17(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_20(uint4 buffer[272], uint offset) { float4x2 ub_load_18(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_21(uint4 buffer[272], uint offset) { float4x3 ub_load_19(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_22(uint4 buffer[272], uint offset) { float4x4 ub_load_20(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
typedef float3 tint_symbol_23_ret[2]; typedef float3 ub_load_21_ret[2];
tint_symbol_23_ret tint_symbol_23(uint4 buffer[272], uint offset) { ub_load_21_ret ub_load_21(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_27 = ((offset + (i * 16u))) / 4; const uint scalar_offset_27 = ((offset + (i * 16u))) / 4;
arr_1[i] = asfloat(buffer[scalar_offset_27 / 4].xyz); arr_1[i] = asfloat(ub[scalar_offset_27 / 4].xyz);
} }
} }
return arr_1; return arr_1;
@ -118,16 +118,16 @@ void main_inner(uint idx) {
const int4 vec4_i32 = asint(ub[scalar_offset_38 / 4]); const int4 vec4_i32 = asint(ub[scalar_offset_38 / 4]);
const uint scalar_offset_39 = (((544u * idx) + 128u)) / 4; const uint scalar_offset_39 = (((544u * idx) + 128u)) / 4;
const uint4 vec4_u32 = ub[scalar_offset_39 / 4]; const uint4 vec4_u32 = ub[scalar_offset_39 / 4];
const float2x2 mat2x2_f32 = tint_symbol_14(ub, ((544u * idx) + 144u)); const float2x2 mat2x2_f32 = ub_load_12(((544u * idx) + 144u));
const float2x3 mat2x3_f32 = tint_symbol_15(ub, ((544u * idx) + 160u)); const float2x3 mat2x3_f32 = ub_load_13(((544u * idx) + 160u));
const float2x4 mat2x4_f32 = tint_symbol_16(ub, ((544u * idx) + 192u)); const float2x4 mat2x4_f32 = ub_load_14(((544u * idx) + 192u));
const float3x2 mat3x2_f32 = tint_symbol_17(ub, ((544u * idx) + 224u)); const float3x2 mat3x2_f32 = ub_load_15(((544u * idx) + 224u));
const float3x3 mat3x3_f32 = tint_symbol_18(ub, ((544u * idx) + 256u)); const float3x3 mat3x3_f32 = ub_load_16(((544u * idx) + 256u));
const float3x4 mat3x4_f32 = tint_symbol_19(ub, ((544u * idx) + 304u)); const float3x4 mat3x4_f32 = ub_load_17(((544u * idx) + 304u));
const float4x2 mat4x2_f32 = tint_symbol_20(ub, ((544u * idx) + 352u)); const float4x2 mat4x2_f32 = ub_load_18(((544u * idx) + 352u));
const float4x3 mat4x3_f32 = tint_symbol_21(ub, ((544u * idx) + 384u)); const float4x3 mat4x3_f32 = ub_load_19(((544u * idx) + 384u));
const float4x4 mat4x4_f32 = tint_symbol_22(ub, ((544u * idx) + 448u)); const float4x4 mat4x4_f32 = ub_load_20(((544u * idx) + 448u));
const float3 arr2_vec3_f32[2] = tint_symbol_23(ub, ((544u * idx) + 512u)); const float3 arr2_vec3_f32[2] = ub_load_21(((544u * idx) + 512u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

74
test/tint/buffer/uniform/dynamic_index/read.wgsl.expected.fxc.hlsl
View File

@ -6,85 +6,85 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_14(uint4 buffer[272], uint offset) { float2x2 ub_load_12(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_15(uint4 buffer[272], uint offset) { float2x3 ub_load_13(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_16(uint4 buffer[272], uint offset) { float2x4 ub_load_14(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_17(uint4 buffer[272], uint offset) { float3x2 ub_load_15(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_18(uint4 buffer[272], uint offset) { float3x3 ub_load_16(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_19(uint4 buffer[272], uint offset) { float3x4 ub_load_17(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_20(uint4 buffer[272], uint offset) { float4x2 ub_load_18(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_21(uint4 buffer[272], uint offset) { float4x3 ub_load_19(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_22(uint4 buffer[272], uint offset) { float4x4 ub_load_20(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
typedef float3 tint_symbol_23_ret[2]; typedef float3 ub_load_21_ret[2];
tint_symbol_23_ret tint_symbol_23(uint4 buffer[272], uint offset) { ub_load_21_ret ub_load_21(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_27 = ((offset + (i * 16u))) / 4; const uint scalar_offset_27 = ((offset + (i * 16u))) / 4;
arr_1[i] = asfloat(buffer[scalar_offset_27 / 4].xyz); arr_1[i] = asfloat(ub[scalar_offset_27 / 4].xyz);
} }
} }
return arr_1; return arr_1;
@ -118,16 +118,16 @@ void main_inner(uint idx) {
const int4 vec4_i32 = asint(ub[scalar_offset_38 / 4]); const int4 vec4_i32 = asint(ub[scalar_offset_38 / 4]);
const uint scalar_offset_39 = (((544u * idx) + 128u)) / 4; const uint scalar_offset_39 = (((544u * idx) + 128u)) / 4;
const uint4 vec4_u32 = ub[scalar_offset_39 / 4]; const uint4 vec4_u32 = ub[scalar_offset_39 / 4];
const float2x2 mat2x2_f32 = tint_symbol_14(ub, ((544u * idx) + 144u)); const float2x2 mat2x2_f32 = ub_load_12(((544u * idx) + 144u));
const float2x3 mat2x3_f32 = tint_symbol_15(ub, ((544u * idx) + 160u)); const float2x3 mat2x3_f32 = ub_load_13(((544u * idx) + 160u));
const float2x4 mat2x4_f32 = tint_symbol_16(ub, ((544u * idx) + 192u)); const float2x4 mat2x4_f32 = ub_load_14(((544u * idx) + 192u));
const float3x2 mat3x2_f32 = tint_symbol_17(ub, ((544u * idx) + 224u)); const float3x2 mat3x2_f32 = ub_load_15(((544u * idx) + 224u));
const float3x3 mat3x3_f32 = tint_symbol_18(ub, ((544u * idx) + 256u)); const float3x3 mat3x3_f32 = ub_load_16(((544u * idx) + 256u));
const float3x4 mat3x4_f32 = tint_symbol_19(ub, ((544u * idx) + 304u)); const float3x4 mat3x4_f32 = ub_load_17(((544u * idx) + 304u));
const float4x2 mat4x2_f32 = tint_symbol_20(ub, ((544u * idx) + 352u)); const float4x2 mat4x2_f32 = ub_load_18(((544u * idx) + 352u));
const float4x3 mat4x3_f32 = tint_symbol_21(ub, ((544u * idx) + 384u)); const float4x3 mat4x3_f32 = ub_load_19(((544u * idx) + 384u));
const float4x4 mat4x4_f32 = tint_symbol_22(ub, ((544u * idx) + 448u)); const float4x4 mat4x4_f32 = ub_load_20(((544u * idx) + 448u));
const float3 arr2_vec3_f32[2] = tint_symbol_23(ub, ((544u * idx) + 512u)); const float3 arr2_vec3_f32[2] = ub_load_21(((544u * idx) + 512u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

172
test/tint/buffer/uniform/dynamic_index/read_f16.wgsl.expected.dxc.hlsl
View File

@ -6,240 +6,240 @@ struct tint_symbol_1 {
uint idx : SV_GroupIndex; uint idx : SV_GroupIndex;
}; };
float2x2 tint_symbol_18(uint4 buffer[400], uint offset) { float2x2 ub_load_16(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_19(uint4 buffer[400], uint offset) { float2x3 ub_load_17(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_20(uint4 buffer[400], uint offset) { float2x4 ub_load_18(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_21(uint4 buffer[400], uint offset) { float3x2 ub_load_19(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_22(uint4 buffer[400], uint offset) { float3x3 ub_load_20(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_23(uint4 buffer[400], uint offset) { float3x4 ub_load_21(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_24(uint4 buffer[400], uint offset) { float4x2 ub_load_22(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_25(uint4 buffer[400], uint offset) { float4x3 ub_load_23(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_26(uint4 buffer[400], uint offset) { float4x4 ub_load_24(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
matrix<float16_t, 2, 2> tint_symbol_27(uint4 buffer[400], uint offset) { matrix<float16_t, 2, 2> ub_load_25(uint offset) {
const uint scalar_offset_27 = ((offset + 0u)) / 4; const uint scalar_offset_27 = ((offset + 0u)) / 4;
uint ubo_load_9 = buffer[scalar_offset_27 / 4][scalar_offset_27 % 4]; uint ubo_load_9 = ub[scalar_offset_27 / 4][scalar_offset_27 % 4];
const uint scalar_offset_28 = ((offset + 4u)) / 4; const uint scalar_offset_28 = ((offset + 4u)) / 4;
uint ubo_load_10 = buffer[scalar_offset_28 / 4][scalar_offset_28 % 4]; uint ubo_load_10 = ub[scalar_offset_28 / 4][scalar_offset_28 % 4];
return matrix<float16_t, 2, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_9 & 0xFFFF)), float16_t(f16tof32(ubo_load_9 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_10 & 0xFFFF)), float16_t(f16tof32(ubo_load_10 >> 16)))); return matrix<float16_t, 2, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_9 & 0xFFFF)), float16_t(f16tof32(ubo_load_9 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_10 & 0xFFFF)), float16_t(f16tof32(ubo_load_10 >> 16))));
} }
matrix<float16_t, 2, 3> tint_symbol_28(uint4 buffer[400], uint offset) { matrix<float16_t, 2, 3> ub_load_26(uint offset) {
const uint scalar_offset_29 = ((offset + 0u)) / 4; const uint scalar_offset_29 = ((offset + 0u)) / 4;
uint4 ubo_load_12 = buffer[scalar_offset_29 / 4]; uint4 ubo_load_12 = ub[scalar_offset_29 / 4];
uint2 ubo_load_11 = ((scalar_offset_29 & 2) ? ubo_load_12.zw : ubo_load_12.xy); uint2 ubo_load_11 = ((scalar_offset_29 & 2) ? ubo_load_12.zw : ubo_load_12.xy);
vector<float16_t, 2> ubo_load_11_xz = vector<float16_t, 2>(f16tof32(ubo_load_11 & 0xFFFF)); vector<float16_t, 2> ubo_load_11_xz = vector<float16_t, 2>(f16tof32(ubo_load_11 & 0xFFFF));
float16_t ubo_load_11_y = f16tof32(ubo_load_11[0] >> 16); float16_t ubo_load_11_y = f16tof32(ubo_load_11[0] >> 16);
const uint scalar_offset_30 = ((offset + 8u)) / 4; const uint scalar_offset_30 = ((offset + 8u)) / 4;
uint4 ubo_load_14 = buffer[scalar_offset_30 / 4]; uint4 ubo_load_14 = ub[scalar_offset_30 / 4];
uint2 ubo_load_13 = ((scalar_offset_30 & 2) ? ubo_load_14.zw : ubo_load_14.xy); uint2 ubo_load_13 = ((scalar_offset_30 & 2) ? ubo_load_14.zw : ubo_load_14.xy);
vector<float16_t, 2> ubo_load_13_xz = vector<float16_t, 2>(f16tof32(ubo_load_13 & 0xFFFF)); vector<float16_t, 2> ubo_load_13_xz = vector<float16_t, 2>(f16tof32(ubo_load_13 & 0xFFFF));
float16_t ubo_load_13_y = f16tof32(ubo_load_13[0] >> 16); float16_t ubo_load_13_y = f16tof32(ubo_load_13[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_11_xz[0], ubo_load_11_y, ubo_load_11_xz[1]), vector<float16_t, 3>(ubo_load_13_xz[0], ubo_load_13_y, ubo_load_13_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_11_xz[0], ubo_load_11_y, ubo_load_11_xz[1]), vector<float16_t, 3>(ubo_load_13_xz[0], ubo_load_13_y, ubo_load_13_xz[1]));
} }
matrix<float16_t, 2, 4> tint_symbol_29(uint4 buffer[400], uint offset) { matrix<float16_t, 2, 4> ub_load_27(uint offset) {
const uint scalar_offset_31 = ((offset + 0u)) / 4; const uint scalar_offset_31 = ((offset + 0u)) / 4;
uint4 ubo_load_16 = buffer[scalar_offset_31 / 4]; uint4 ubo_load_16 = ub[scalar_offset_31 / 4];
uint2 ubo_load_15 = ((scalar_offset_31 & 2) ? ubo_load_16.zw : ubo_load_16.xy); uint2 ubo_load_15 = ((scalar_offset_31 & 2) ? ubo_load_16.zw : ubo_load_16.xy);
vector<float16_t, 2> ubo_load_15_xz = vector<float16_t, 2>(f16tof32(ubo_load_15 & 0xFFFF)); vector<float16_t, 2> ubo_load_15_xz = vector<float16_t, 2>(f16tof32(ubo_load_15 & 0xFFFF));
vector<float16_t, 2> ubo_load_15_yw = vector<float16_t, 2>(f16tof32(ubo_load_15 >> 16)); vector<float16_t, 2> ubo_load_15_yw = vector<float16_t, 2>(f16tof32(ubo_load_15 >> 16));
const uint scalar_offset_32 = ((offset + 8u)) / 4; const uint scalar_offset_32 = ((offset + 8u)) / 4;
uint4 ubo_load_18 = buffer[scalar_offset_32 / 4]; uint4 ubo_load_18 = ub[scalar_offset_32 / 4];
uint2 ubo_load_17 = ((scalar_offset_32 & 2) ? ubo_load_18.zw : ubo_load_18.xy); uint2 ubo_load_17 = ((scalar_offset_32 & 2) ? ubo_load_18.zw : ubo_load_18.xy);
vector<float16_t, 2> ubo_load_17_xz = vector<float16_t, 2>(f16tof32(ubo_load_17 & 0xFFFF)); vector<float16_t, 2> ubo_load_17_xz = vector<float16_t, 2>(f16tof32(ubo_load_17 & 0xFFFF));
vector<float16_t, 2> ubo_load_17_yw = vector<float16_t, 2>(f16tof32(ubo_load_17 >> 16)); vector<float16_t, 2> ubo_load_17_yw = vector<float16_t, 2>(f16tof32(ubo_load_17 >> 16));
return matrix<float16_t, 2, 4>(vector<float16_t, 4>(ubo_load_15_xz[0], ubo_load_15_yw[0], ubo_load_15_xz[1], ubo_load_15_yw[1]), vector<float16_t, 4>(ubo_load_17_xz[0], ubo_load_17_yw[0], ubo_load_17_xz[1], ubo_load_17_yw[1])); return matrix<float16_t, 2, 4>(vector<float16_t, 4>(ubo_load_15_xz[0], ubo_load_15_yw[0], ubo_load_15_xz[1], ubo_load_15_yw[1]), vector<float16_t, 4>(ubo_load_17_xz[0], ubo_load_17_yw[0], ubo_load_17_xz[1], ubo_load_17_yw[1]));
} }
matrix<float16_t, 3, 2> tint_symbol_30(uint4 buffer[400], uint offset) { matrix<float16_t, 3, 2> ub_load_28(uint offset) {
const uint scalar_offset_33 = ((offset + 0u)) / 4; const uint scalar_offset_33 = ((offset + 0u)) / 4;
uint ubo_load_19 = buffer[scalar_offset_33 / 4][scalar_offset_33 % 4]; uint ubo_load_19 = ub[scalar_offset_33 / 4][scalar_offset_33 % 4];
const uint scalar_offset_34 = ((offset + 4u)) / 4; const uint scalar_offset_34 = ((offset + 4u)) / 4;
uint ubo_load_20 = buffer[scalar_offset_34 / 4][scalar_offset_34 % 4]; uint ubo_load_20 = ub[scalar_offset_34 / 4][scalar_offset_34 % 4];
const uint scalar_offset_35 = ((offset + 8u)) / 4; const uint scalar_offset_35 = ((offset + 8u)) / 4;
uint ubo_load_21 = buffer[scalar_offset_35 / 4][scalar_offset_35 % 4]; uint ubo_load_21 = ub[scalar_offset_35 / 4][scalar_offset_35 % 4];
return matrix<float16_t, 3, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_19 & 0xFFFF)), float16_t(f16tof32(ubo_load_19 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_20 & 0xFFFF)), float16_t(f16tof32(ubo_load_20 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_21 & 0xFFFF)), float16_t(f16tof32(ubo_load_21 >> 16)))); return matrix<float16_t, 3, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_19 & 0xFFFF)), float16_t(f16tof32(ubo_load_19 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_20 & 0xFFFF)), float16_t(f16tof32(ubo_load_20 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_21 & 0xFFFF)), float16_t(f16tof32(ubo_load_21 >> 16))));
} }
matrix<float16_t, 3, 3> tint_symbol_31(uint4 buffer[400], uint offset) { matrix<float16_t, 3, 3> ub_load_29(uint offset) {
const uint scalar_offset_36 = ((offset + 0u)) / 4; const uint scalar_offset_36 = ((offset + 0u)) / 4;
uint4 ubo_load_23 = buffer[scalar_offset_36 / 4]; uint4 ubo_load_23 = ub[scalar_offset_36 / 4];
uint2 ubo_load_22 = ((scalar_offset_36 & 2) ? ubo_load_23.zw : ubo_load_23.xy); uint2 ubo_load_22 = ((scalar_offset_36 & 2) ? ubo_load_23.zw : ubo_load_23.xy);
vector<float16_t, 2> ubo_load_22_xz = vector<float16_t, 2>(f16tof32(ubo_load_22 & 0xFFFF)); vector<float16_t, 2> ubo_load_22_xz = vector<float16_t, 2>(f16tof32(ubo_load_22 & 0xFFFF));
float16_t ubo_load_22_y = f16tof32(ubo_load_22[0] >> 16); float16_t ubo_load_22_y = f16tof32(ubo_load_22[0] >> 16);
const uint scalar_offset_37 = ((offset + 8u)) / 4; const uint scalar_offset_37 = ((offset + 8u)) / 4;
uint4 ubo_load_25 = buffer[scalar_offset_37 / 4]; uint4 ubo_load_25 = ub[scalar_offset_37 / 4];
uint2 ubo_load_24 = ((scalar_offset_37 & 2) ? ubo_load_25.zw : ubo_load_25.xy); uint2 ubo_load_24 = ((scalar_offset_37 & 2) ? ubo_load_25.zw : ubo_load_25.xy);
vector<float16_t, 2> ubo_load_24_xz = vector<float16_t, 2>(f16tof32(ubo_load_24 & 0xFFFF)); vector<float16_t, 2> ubo_load_24_xz = vector<float16_t, 2>(f16tof32(ubo_load_24 & 0xFFFF));
float16_t ubo_load_24_y = f16tof32(ubo_load_24[0] >> 16); float16_t ubo_load_24_y = f16tof32(ubo_load_24[0] >> 16);
const uint scalar_offset_38 = ((offset + 16u)) / 4; const uint scalar_offset_38 = ((offset + 16u)) / 4;
uint4 ubo_load_27 = buffer[scalar_offset_38 / 4]; uint4 ubo_load_27 = ub[scalar_offset_38 / 4];
uint2 ubo_load_26 = ((scalar_offset_38 & 2) ? ubo_load_27.zw : ubo_load_27.xy); uint2 ubo_load_26 = ((scalar_offset_38 & 2) ? ubo_load_27.zw : ubo_load_27.xy);
vector<float16_t, 2> ubo_load_26_xz = vector<float16_t, 2>(f16tof32(ubo_load_26 & 0xFFFF)); vector<float16_t, 2> ubo_load_26_xz = vector<float16_t, 2>(f16tof32(ubo_load_26 & 0xFFFF));
float16_t ubo_load_26_y = f16tof32(ubo_load_26[0] >> 16); float16_t ubo_load_26_y = f16tof32(ubo_load_26[0] >> 16);
return matrix<float16_t, 3, 3>(vector<float16_t, 3>(ubo_load_22_xz[0], ubo_load_22_y, ubo_load_22_xz[1]), vector<float16_t, 3>(ubo_load_24_xz[0], ubo_load_24_y, ubo_load_24_xz[1]), vector<float16_t, 3>(ubo_load_26_xz[0], ubo_load_26_y, ubo_load_26_xz[1])); return matrix<float16_t, 3, 3>(vector<float16_t, 3>(ubo_load_22_xz[0], ubo_load_22_y, ubo_load_22_xz[1]), vector<float16_t, 3>(ubo_load_24_xz[0], ubo_load_24_y, ubo_load_24_xz[1]), vector<float16_t, 3>(ubo_load_26_xz[0], ubo_load_26_y, ubo_load_26_xz[1]));
} }
matrix<float16_t, 3, 4> tint_symbol_32(uint4 buffer[400], uint offset) { matrix<float16_t, 3, 4> ub_load_30(uint offset) {
const uint scalar_offset_39 = ((offset + 0u)) / 4; const uint scalar_offset_39 = ((offset + 0u)) / 4;
uint4 ubo_load_29 = buffer[scalar_offset_39 / 4]; uint4 ubo_load_29 = ub[scalar_offset_39 / 4];
uint2 ubo_load_28 = ((scalar_offset_39 & 2) ? ubo_load_29.zw : ubo_load_29.xy); uint2 ubo_load_28 = ((scalar_offset_39 & 2) ? ubo_load_29.zw : ubo_load_29.xy);
vector<float16_t, 2> ubo_load_28_xz = vector<float16_t, 2>(f16tof32(ubo_load_28 & 0xFFFF)); vector<float16_t, 2> ubo_load_28_xz = vector<float16_t, 2>(f16tof32(ubo_load_28 & 0xFFFF));
vector<float16_t, 2> ubo_load_28_yw = vector<float16_t, 2>(f16tof32(ubo_load_28 >> 16)); vector<float16_t, 2> ubo_load_28_yw = vector<float16_t, 2>(f16tof32(ubo_load_28 >> 16));
const uint scalar_offset_40 = ((offset + 8u)) / 4; const uint scalar_offset_40 = ((offset + 8u)) / 4;
uint4 ubo_load_31 = buffer[scalar_offset_40 / 4]; uint4 ubo_load_31 = ub[scalar_offset_40 / 4];
uint2 ubo_load_30 = ((scalar_offset_40 & 2) ? ubo_load_31.zw : ubo_load_31.xy); uint2 ubo_load_30 = ((scalar_offset_40 & 2) ? ubo_load_31.zw : ubo_load_31.xy);
vector<float16_t, 2> ubo_load_30_xz = vector<float16_t, 2>(f16tof32(ubo_load_30 & 0xFFFF)); vector<float16_t, 2> ubo_load_30_xz = vector<float16_t, 2>(f16tof32(ubo_load_30 & 0xFFFF));
vector<float16_t, 2> ubo_load_30_yw = vector<float16_t, 2>(f16tof32(ubo_load_30 >> 16)); vector<float16_t, 2> ubo_load_30_yw = vector<float16_t, 2>(f16tof32(ubo_load_30 >> 16));
const uint scalar_offset_41 = ((offset + 16u)) / 4; const uint scalar_offset_41 = ((offset + 16u)) / 4;
uint4 ubo_load_33 = buffer[scalar_offset_41 / 4]; uint4 ubo_load_33 = ub[scalar_offset_41 / 4];
uint2 ubo_load_32 = ((scalar_offset_41 & 2) ? ubo_load_33.zw : ubo_load_33.xy); uint2 ubo_load_32 = ((scalar_offset_41 & 2) ? ubo_load_33.zw : ubo_load_33.xy);
vector<float16_t, 2> ubo_load_32_xz = vector<float16_t, 2>(f16tof32(ubo_load_32 & 0xFFFF)); vector<float16_t, 2> ubo_load_32_xz = vector<float16_t, 2>(f16tof32(ubo_load_32 & 0xFFFF));
vector<float16_t, 2> ubo_load_32_yw = vector<float16_t, 2>(f16tof32(ubo_load_32 >> 16)); vector<float16_t, 2> ubo_load_32_yw = vector<float16_t, 2>(f16tof32(ubo_load_32 >> 16));
return matrix<float16_t, 3, 4>(vector<float16_t, 4>(ubo_load_28_xz[0], ubo_load_28_yw[0], ubo_load_28_xz[1], ubo_load_28_yw[1]), vector<float16_t, 4>(ubo_load_30_xz[0], ubo_load_30_yw[0], ubo_load_30_xz[1], ubo_load_30_yw[1]), vector<float16_t, 4>(ubo_load_32_xz[0], ubo_load_32_yw[0], ubo_load_32_xz[1], ubo_load_32_yw[1])); return matrix<float16_t, 3, 4>(vector<float16_t, 4>(ubo_load_28_xz[0], ubo_load_28_yw[0], ubo_load_28_xz[1], ubo_load_28_yw[1]), vector<float16_t, 4>(ubo_load_30_xz[0], ubo_load_30_yw[0], ubo_load_30_xz[1], ubo_load_30_yw[1]), vector<float16_t, 4>(ubo_load_32_xz[0], ubo_load_32_yw[0], ubo_load_32_xz[1], ubo_load_32_yw[1]));
} }
matrix<float16_t, 4, 2> tint_symbol_33(uint4 buffer[400], uint offset) { matrix<float16_t, 4, 2> ub_load_31(uint offset) {
const uint scalar_offset_42 = ((offset + 0u)) / 4; const uint scalar_offset_42 = ((offset + 0u)) / 4;
uint ubo_load_34 = buffer[scalar_offset_42 / 4][scalar_offset_42 % 4]; uint ubo_load_34 = ub[scalar_offset_42 / 4][scalar_offset_42 % 4];
const uint scalar_offset_43 = ((offset + 4u)) / 4; const uint scalar_offset_43 = ((offset + 4u)) / 4;
uint ubo_load_35 = buffer[scalar_offset_43 / 4][scalar_offset_43 % 4]; uint ubo_load_35 = ub[scalar_offset_43 / 4][scalar_offset_43 % 4];
const uint scalar_offset_44 = ((offset + 8u)) / 4; const uint scalar_offset_44 = ((offset + 8u)) / 4;
uint ubo_load_36 = buffer[scalar_offset_44 / 4][scalar_offset_44 % 4]; uint ubo_load_36 = ub[scalar_offset_44 / 4][scalar_offset_44 % 4];
const uint scalar_offset_45 = ((offset + 12u)) / 4; const uint scalar_offset_45 = ((offset + 12u)) / 4;
uint ubo_load_37 = buffer[scalar_offset_45 / 4][scalar_offset_45 % 4]; uint ubo_load_37 = ub[scalar_offset_45 / 4][scalar_offset_45 % 4];
return matrix<float16_t, 4, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_34 & 0xFFFF)), float16_t(f16tof32(ubo_load_34 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_35 & 0xFFFF)), float16_t(f16tof32(ubo_load_35 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_36 & 0xFFFF)), float16_t(f16tof32(ubo_load_36 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_37 & 0xFFFF)), float16_t(f16tof32(ubo_load_37 >> 16)))); return matrix<float16_t, 4, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_34 & 0xFFFF)), float16_t(f16tof32(ubo_load_34 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_35 & 0xFFFF)), float16_t(f16tof32(ubo_load_35 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_36 & 0xFFFF)), float16_t(f16tof32(ubo_load_36 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_37 & 0xFFFF)), float16_t(f16tof32(ubo_load_37 >> 16))));
} }
matrix<float16_t, 4, 3> tint_symbol_34(uint4 buffer[400], uint offset) { matrix<float16_t, 4, 3> ub_load_32(uint offset) {
const uint scalar_offset_46 = ((offset + 0u)) / 4; const uint scalar_offset_46 = ((offset + 0u)) / 4;
uint4 ubo_load_39 = buffer[scalar_offset_46 / 4]; uint4 ubo_load_39 = ub[scalar_offset_46 / 4];
uint2 ubo_load_38 = ((scalar_offset_46 & 2) ? ubo_load_39.zw : ubo_load_39.xy); uint2 ubo_load_38 = ((scalar_offset_46 & 2) ? ubo_load_39.zw : ubo_load_39.xy);
vector<float16_t, 2> ubo_load_38_xz = vector<float16_t, 2>(f16tof32(ubo_load_38 & 0xFFFF)); vector<float16_t, 2> ubo_load_38_xz = vector<float16_t, 2>(f16tof32(ubo_load_38 & 0xFFFF));
float16_t ubo_load_38_y = f16tof32(ubo_load_38[0] >> 16); float16_t ubo_load_38_y = f16tof32(ubo_load_38[0] >> 16);
const uint scalar_offset_47 = ((offset + 8u)) / 4; const uint scalar_offset_47 = ((offset + 8u)) / 4;
uint4 ubo_load_41 = buffer[scalar_offset_47 / 4]; uint4 ubo_load_41 = ub[scalar_offset_47 / 4];
uint2 ubo_load_40 = ((scalar_offset_47 & 2) ? ubo_load_41.zw : ubo_load_41.xy); uint2 ubo_load_40 = ((scalar_offset_47 & 2) ? ubo_load_41.zw : ubo_load_41.xy);
vector<float16_t, 2> ubo_load_40_xz = vector<float16_t, 2>(f16tof32(ubo_load_40 & 0xFFFF)); vector<float16_t, 2> ubo_load_40_xz = vector<float16_t, 2>(f16tof32(ubo_load_40 & 0xFFFF));
float16_t ubo_load_40_y = f16tof32(ubo_load_40[0] >> 16); float16_t ubo_load_40_y = f16tof32(ubo_load_40[0] >> 16);
const uint scalar_offset_48 = ((offset + 16u)) / 4; const uint scalar_offset_48 = ((offset + 16u)) / 4;
uint4 ubo_load_43 = buffer[scalar_offset_48 / 4]; uint4 ubo_load_43 = ub[scalar_offset_48 / 4];
uint2 ubo_load_42 = ((scalar_offset_48 & 2) ? ubo_load_43.zw : ubo_load_43.xy); uint2 ubo_load_42 = ((scalar_offset_48 & 2) ? ubo_load_43.zw : ubo_load_43.xy);
vector<float16_t, 2> ubo_load_42_xz = vector<float16_t, 2>(f16tof32(ubo_load_42 & 0xFFFF)); vector<float16_t, 2> ubo_load_42_xz = vector<float16_t, 2>(f16tof32(ubo_load_42 & 0xFFFF));
float16_t ubo_load_42_y = f16tof32(ubo_load_42[0] >> 16); float16_t ubo_load_42_y = f16tof32(ubo_load_42[0] >> 16);
const uint scalar_offset_49 = ((offset + 24u)) / 4; const uint scalar_offset_49 = ((offset + 24u)) / 4;
uint4 ubo_load_45 = buffer[scalar_offset_49 / 4]; uint4 ubo_load_45 = ub[scalar_offset_49 / 4];
uint2 ubo_load_44 = ((scalar_offset_49 & 2) ? ubo_load_45.zw : ubo_load_45.xy); uint2 ubo_load_44 = ((scalar_offset_49 & 2) ? ubo_load_45.zw : ubo_load_45.xy);
vector<float16_t, 2> ubo_load_44_xz = vector<float16_t, 2>(f16tof32(ubo_load_44 & 0xFFFF)); vector<float16_t, 2> ubo_load_44_xz = vector<float16_t, 2>(f16tof32(ubo_load_44 & 0xFFFF));
float16_t ubo_load_44_y = f16tof32(ubo_load_44[0] >> 16); float16_t ubo_load_44_y = f16tof32(ubo_load_44[0] >> 16);
return matrix<float16_t, 4, 3>(vector<float16_t, 3>(ubo_load_38_xz[0], ubo_load_38_y, ubo_load_38_xz[1]), vector<float16_t, 3>(ubo_load_40_xz[0], ubo_load_40_y, ubo_load_40_xz[1]), vector<float16_t, 3>(ubo_load_42_xz[0], ubo_load_42_y, ubo_load_42_xz[1]), vector<float16_t, 3>(ubo_load_44_xz[0], ubo_load_44_y, ubo_load_44_xz[1])); return matrix<float16_t, 4, 3>(vector<float16_t, 3>(ubo_load_38_xz[0], ubo_load_38_y, ubo_load_38_xz[1]), vector<float16_t, 3>(ubo_load_40_xz[0], ubo_load_40_y, ubo_load_40_xz[1]), vector<float16_t, 3>(ubo_load_42_xz[0], ubo_load_42_y, ubo_load_42_xz[1]), vector<float16_t, 3>(ubo_load_44_xz[0], ubo_load_44_y, ubo_load_44_xz[1]));
} }
matrix<float16_t, 4, 4> tint_symbol_35(uint4 buffer[400], uint offset) { matrix<float16_t, 4, 4> ub_load_33(uint offset) {
const uint scalar_offset_50 = ((offset + 0u)) / 4; const uint scalar_offset_50 = ((offset + 0u)) / 4;
uint4 ubo_load_47 = buffer[scalar_offset_50 / 4]; uint4 ubo_load_47 = ub[scalar_offset_50 / 4];
uint2 ubo_load_46 = ((scalar_offset_50 & 2) ? ubo_load_47.zw : ubo_load_47.xy); uint2 ubo_load_46 = ((scalar_offset_50 & 2) ? ubo_load_47.zw : ubo_load_47.xy);
vector<float16_t, 2> ubo_load_46_xz = vector<float16_t, 2>(f16tof32(ubo_load_46 & 0xFFFF)); vector<float16_t, 2> ubo_load_46_xz = vector<float16_t, 2>(f16tof32(ubo_load_46 & 0xFFFF));
vector<float16_t, 2> ubo_load_46_yw = vector<float16_t, 2>(f16tof32(ubo_load_46 >> 16)); vector<float16_t, 2> ubo_load_46_yw = vector<float16_t, 2>(f16tof32(ubo_load_46 >> 16));
const uint scalar_offset_51 = ((offset + 8u)) / 4; const uint scalar_offset_51 = ((offset + 8u)) / 4;
uint4 ubo_load_49 = buffer[scalar_offset_51 / 4]; uint4 ubo_load_49 = ub[scalar_offset_51 / 4];
uint2 ubo_load_48 = ((scalar_offset_51 & 2) ? ubo_load_49.zw : ubo_load_49.xy); uint2 ubo_load_48 = ((scalar_offset_51 & 2) ? ubo_load_49.zw : ubo_load_49.xy);
vector<float16_t, 2> ubo_load_48_xz = vector<float16_t, 2>(f16tof32(ubo_load_48 & 0xFFFF)); vector<float16_t, 2> ubo_load_48_xz = vector<float16_t, 2>(f16tof32(ubo_load_48 & 0xFFFF));
vector<float16_t, 2> ubo_load_48_yw = vector<float16_t, 2>(f16tof32(ubo_load_48 >> 16)); vector<float16_t, 2> ubo_load_48_yw = vector<float16_t, 2>(f16tof32(ubo_load_48 >> 16));
const uint scalar_offset_52 = ((offset + 16u)) / 4; const uint scalar_offset_52 = ((offset + 16u)) / 4;
uint4 ubo_load_51 = buffer[scalar_offset_52 / 4]; uint4 ubo_load_51 = ub[scalar_offset_52 / 4];
uint2 ubo_load_50 = ((scalar_offset_52 & 2) ? ubo_load_51.zw : ubo_load_51.xy); uint2 ubo_load_50 = ((scalar_offset_52 & 2) ? ubo_load_51.zw : ubo_load_51.xy);
vector<float16_t, 2> ubo_load_50_xz = vector<float16_t, 2>(f16tof32(ubo_load_50 & 0xFFFF)); vector<float16_t, 2> ubo_load_50_xz = vector<float16_t, 2>(f16tof32(ubo_load_50 & 0xFFFF));
vector<float16_t, 2> ubo_load_50_yw = vector<float16_t, 2>(f16tof32(ubo_load_50 >> 16)); vector<float16_t, 2> ubo_load_50_yw = vector<float16_t, 2>(f16tof32(ubo_load_50 >> 16));
const uint scalar_offset_53 = ((offset + 24u)) / 4; const uint scalar_offset_53 = ((offset + 24u)) / 4;
uint4 ubo_load_53 = buffer[scalar_offset_53 / 4]; uint4 ubo_load_53 = ub[scalar_offset_53 / 4];
uint2 ubo_load_52 = ((scalar_offset_53 & 2) ? ubo_load_53.zw : ubo_load_53.xy); uint2 ubo_load_52 = ((scalar_offset_53 & 2) ? ubo_load_53.zw : ubo_load_53.xy);
vector<float16_t, 2> ubo_load_52_xz = vector<float16_t, 2>(f16tof32(ubo_load_52 & 0xFFFF)); vector<float16_t, 2> ubo_load_52_xz = vector<float16_t, 2>(f16tof32(ubo_load_52 & 0xFFFF));
vector<float16_t, 2> ubo_load_52_yw = vector<float16_t, 2>(f16tof32(ubo_load_52 >> 16)); vector<float16_t, 2> ubo_load_52_yw = vector<float16_t, 2>(f16tof32(ubo_load_52 >> 16));
return matrix<float16_t, 4, 4>(vector<float16_t, 4>(ubo_load_46_xz[0], ubo_load_46_yw[0], ubo_load_46_xz[1], ubo_load_46_yw[1]), vector<float16_t, 4>(ubo_load_48_xz[0], ubo_load_48_yw[0], ubo_load_48_xz[1], ubo_load_48_yw[1]), vector<float16_t, 4>(ubo_load_50_xz[0], ubo_load_50_yw[0], ubo_load_50_xz[1], ubo_load_50_yw[1]), vector<float16_t, 4>(ubo_load_52_xz[0], ubo_load_52_yw[0], ubo_load_52_xz[1], ubo_load_52_yw[1])); return matrix<float16_t, 4, 4>(vector<float16_t, 4>(ubo_load_46_xz[0], ubo_load_46_yw[0], ubo_load_46_xz[1], ubo_load_46_yw[1]), vector<float16_t, 4>(ubo_load_48_xz[0], ubo_load_48_yw[0], ubo_load_48_xz[1], ubo_load_48_yw[1]), vector<float16_t, 4>(ubo_load_50_xz[0], ubo_load_50_yw[0], ubo_load_50_xz[1], ubo_load_50_yw[1]), vector<float16_t, 4>(ubo_load_52_xz[0], ubo_load_52_yw[0], ubo_load_52_xz[1], ubo_load_52_yw[1]));
} }
typedef float3 tint_symbol_36_ret[2]; typedef float3 ub_load_34_ret[2];
tint_symbol_36_ret tint_symbol_36(uint4 buffer[400], uint offset) { ub_load_34_ret ub_load_34(uint offset) {
float3 arr_1[2] = (float3[2])0; float3 arr_1[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_54 = ((offset + (i * 16u))) / 4; const uint scalar_offset_54 = ((offset + (i * 16u))) / 4;
arr_1[i] = asfloat(buffer[scalar_offset_54 / 4].xyz); arr_1[i] = asfloat(ub[scalar_offset_54 / 4].xyz);
} }
} }
return arr_1; return arr_1;
} }
typedef matrix<float16_t, 4, 2> tint_symbol_37_ret[2]; typedef matrix<float16_t, 4, 2> ub_load_35_ret[2];
tint_symbol_37_ret tint_symbol_37(uint4 buffer[400], uint offset) { ub_load_35_ret ub_load_35(uint offset) {
matrix<float16_t, 4, 2> arr_2[2] = (matrix<float16_t, 4, 2>[2])0; matrix<float16_t, 4, 2> arr_2[2] = (matrix<float16_t, 4, 2>[2])0;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
arr_2[i_1] = tint_symbol_33(buffer, (offset + (i_1 * 16u))); arr_2[i_1] = ub_load_31((offset + (i_1 * 16u)));
} }
} }
return arr_2; return arr_2;
@ -291,26 +291,26 @@ void main_inner(uint idx) {
vector<float16_t, 2> ubo_load_60_xz = vector<float16_t, 2>(f16tof32(ubo_load_60 & 0xFFFF)); vector<float16_t, 2> ubo_load_60_xz = vector<float16_t, 2>(f16tof32(ubo_load_60 & 0xFFFF));
vector<float16_t, 2> ubo_load_60_yw = vector<float16_t, 2>(f16tof32(ubo_load_60 >> 16)); vector<float16_t, 2> ubo_load_60_yw = vector<float16_t, 2>(f16tof32(ubo_load_60 >> 16));
const vector<float16_t, 4> vec4_f16 = vector<float16_t, 4>(ubo_load_60_xz[0], ubo_load_60_yw[0], ubo_load_60_xz[1], ubo_load_60_yw[1]); const vector<float16_t, 4> vec4_f16 = vector<float16_t, 4>(ubo_load_60_xz[0], ubo_load_60_yw[0], ubo_load_60_xz[1], ubo_load_60_yw[1]);
const float2x2 mat2x2_f32 = tint_symbol_18(ub, ((800u * idx) + 168u)); const float2x2 mat2x2_f32 = ub_load_16(((800u * idx) + 168u));
const float2x3 mat2x3_f32 = tint_symbol_19(ub, ((800u * idx) + 192u)); const float2x3 mat2x3_f32 = ub_load_17(((800u * idx) + 192u));
const float2x4 mat2x4_f32 = tint_symbol_20(ub, ((800u * idx) + 224u)); const float2x4 mat2x4_f32 = ub_load_18(((800u * idx) + 224u));
const float3x2 mat3x2_f32 = tint_symbol_21(ub, ((800u * idx) + 256u)); const float3x2 mat3x2_f32 = ub_load_19(((800u * idx) + 256u));
const float3x3 mat3x3_f32 = tint_symbol_22(ub, ((800u * idx) + 288u)); const float3x3 mat3x3_f32 = ub_load_20(((800u * idx) + 288u));
const float3x4 mat3x4_f32 = tint_symbol_23(ub, ((800u * idx) + 336u)); const float3x4 mat3x4_f32 = ub_load_21(((800u * idx) + 336u));
const float4x2 mat4x2_f32 = tint_symbol_24(ub, ((800u * idx) + 384u)); const float4x2 mat4x2_f32 = ub_load_22(((800u * idx) + 384u));
const float4x3 mat4x3_f32 = tint_symbol_25(ub, ((800u * idx) + 416u)); const float4x3 mat4x3_f32 = ub_load_23(((800u * idx) + 416u));
const float4x4 mat4x4_f32 = tint_symbol_26(ub, ((800u * idx) + 480u)); const float4x4 mat4x4_f32 = ub_load_24(((800u * idx) + 480u));
const matrix<float16_t, 2, 2> mat2x2_f16 = tint_symbol_27(ub, ((800u * idx) + 544u)); const matrix<float16_t, 2, 2> mat2x2_f16 = ub_load_25(((800u * idx) + 544u));
const matrix<float16_t, 2, 3> mat2x3_f16 = tint_symbol_28(ub, ((800u * idx) + 552u)); const matrix<float16_t, 2, 3> mat2x3_f16 = ub_load_26(((800u * idx) + 552u));
const matrix<float16_t, 2, 4> mat2x4_f16 = tint_symbol_29(ub, ((800u * idx) + 568u)); const matrix<float16_t, 2, 4> mat2x4_f16 = ub_load_27(((800u * idx) + 568u));
const matrix<float16_t, 3, 2> mat3x2_f16 = tint_symbol_30(ub, ((800u * idx) + 584u)); const matrix<float16_t, 3, 2> mat3x2_f16 = ub_load_28(((800u * idx) + 584u));
const matrix<float16_t, 3, 3> mat3x3_f16 = tint_symbol_31(ub, ((800u * idx) + 600u)); const matrix<float16_t, 3, 3> mat3x3_f16 = ub_load_29(((800u * idx) + 600u));
const matrix<float16_t, 3, 4> mat3x4_f16 = tint_symbol_32(ub, ((800u * idx) + 624u)); const matrix<float16_t, 3, 4> mat3x4_f16 = ub_load_30(((800u * idx) + 624u));
const matrix<float16_t, 4, 2> mat4x2_f16 = tint_symbol_33(ub, ((800u * idx) + 648u)); const matrix<float16_t, 4, 2> mat4x2_f16 = ub_load_31(((800u * idx) + 648u));
const matrix<float16_t, 4, 3> mat4x3_f16 = tint_symbol_34(ub, ((800u * idx) + 664u)); const matrix<float16_t, 4, 3> mat4x3_f16 = ub_load_32(((800u * idx) + 664u));
const matrix<float16_t, 4, 4> mat4x4_f16 = tint_symbol_35(ub, ((800u * idx) + 696u)); const matrix<float16_t, 4, 4> mat4x4_f16 = ub_load_33(((800u * idx) + 696u));
const float3 arr2_vec3_f32[2] = tint_symbol_36(ub, ((800u * idx) + 736u)); const float3 arr2_vec3_f32[2] = ub_load_34(((800u * idx) + 736u));
const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = tint_symbol_37(ub, ((800u * idx) + 768u)); const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = ub_load_35(((800u * idx) + 768u));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]

90
test/tint/buffer/uniform/static_index/read.wgsl.expected.dxc.hlsl
View File

@ -7,103 +7,103 @@ cbuffer cbuffer_ub : register(b0, space0) {
uint4 ub[44]; uint4 ub[44];
}; };
float2x2 tint_symbol_12(uint4 buffer[44], uint offset) { float2x2 ub_load_12(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_13(uint4 buffer[44], uint offset) { float2x3 ub_load_13(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_14(uint4 buffer[44], uint offset) { float2x4 ub_load_14(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_15(uint4 buffer[44], uint offset) { float3x2 ub_load_15(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_16(uint4 buffer[44], uint offset) { float3x3 ub_load_16(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_17(uint4 buffer[44], uint offset) { float3x4 ub_load_17(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_18(uint4 buffer[44], uint offset) { float4x2 ub_load_18(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_19(uint4 buffer[44], uint offset) { float4x3 ub_load_19(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_20(uint4 buffer[44], uint offset) { float4x4 ub_load_20(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
typedef float3 tint_symbol_21_ret[2]; typedef float3 ub_load_21_ret[2];
tint_symbol_21_ret tint_symbol_21(uint4 buffer[44], uint offset) { ub_load_21_ret ub_load_21(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_27 = ((offset + (i * 16u))) / 4; const uint scalar_offset_27 = ((offset + (i * 16u))) / 4;
arr[i] = asfloat(buffer[scalar_offset_27 / 4].xyz); arr[i] = asfloat(ub[scalar_offset_27 / 4].xyz);
} }
} }
return arr; return arr;
} }
Inner tint_symbol_22(uint4 buffer[44], uint offset) { Inner ub_load_22(uint offset) {
const uint scalar_offset_28 = ((offset + 0u)) / 4; const uint scalar_offset_28 = ((offset + 0u)) / 4;
const uint scalar_offset_29 = ((offset + 16u)) / 4; const uint scalar_offset_29 = ((offset + 16u)) / 4;
const Inner tint_symbol_24 = {asint(buffer[scalar_offset_28 / 4][scalar_offset_28 % 4]), asfloat(buffer[scalar_offset_29 / 4][scalar_offset_29 % 4])}; const Inner tint_symbol = {asint(ub[scalar_offset_28 / 4][scalar_offset_28 % 4]), asfloat(ub[scalar_offset_29 / 4][scalar_offset_29 % 4])};
return tint_symbol_24; return tint_symbol;
} }
typedef Inner tint_symbol_23_ret[4]; typedef Inner ub_load_23_ret[4];
tint_symbol_23_ret tint_symbol_23(uint4 buffer[44], uint offset) { ub_load_23_ret ub_load_23(uint offset) {
Inner arr_1[4] = (Inner[4])0; Inner arr_1[4] = (Inner[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_22(buffer, (offset + (i_1 * 32u))); arr_1[i_1] = ub_load_22((offset + (i_1 * 32u)));
} }
} }
return arr_1; return arr_1;
@ -123,17 +123,17 @@ void main() {
const float4 vec4_f32 = asfloat(ub[6]); const float4 vec4_f32 = asfloat(ub[6]);
const int4 vec4_i32 = asint(ub[7]); const int4 vec4_i32 = asint(ub[7]);
const uint4 vec4_u32 = ub[8]; const uint4 vec4_u32 = ub[8];
const float2x2 mat2x2_f32 = tint_symbol_12(ub, 144u); const float2x2 mat2x2_f32 = ub_load_12(144u);
const float2x3 mat2x3_f32 = tint_symbol_13(ub, 160u); const float2x3 mat2x3_f32 = ub_load_13(160u);
const float2x4 mat2x4_f32 = tint_symbol_14(ub, 192u); const float2x4 mat2x4_f32 = ub_load_14(192u);
const float3x2 mat3x2_f32 = tint_symbol_15(ub, 224u); const float3x2 mat3x2_f32 = ub_load_15(224u);
const float3x3 mat3x3_f32 = tint_symbol_16(ub, 256u); const float3x3 mat3x3_f32 = ub_load_16(256u);
const float3x4 mat3x4_f32 = tint_symbol_17(ub, 304u); const float3x4 mat3x4_f32 = ub_load_17(304u);
const float4x2 mat4x2_f32 = tint_symbol_18(ub, 352u); const float4x2 mat4x2_f32 = ub_load_18(352u);
const float4x3 mat4x3_f32 = tint_symbol_19(ub, 384u); const float4x3 mat4x3_f32 = ub_load_19(384u);
const float4x4 mat4x4_f32 = tint_symbol_20(ub, 448u); const float4x4 mat4x4_f32 = ub_load_20(448u);
const float3 arr2_vec3_f32[2] = tint_symbol_21(ub, 512u); const float3 arr2_vec3_f32[2] = ub_load_21(512u);
const Inner struct_inner = tint_symbol_22(ub, 544u); const Inner struct_inner = ub_load_22(544u);
const Inner array_struct_inner[4] = tint_symbol_23(ub, 576u); const Inner array_struct_inner[4] = ub_load_23(576u);
return; return;
} }

90
test/tint/buffer/uniform/static_index/read.wgsl.expected.fxc.hlsl
View File

@ -7,103 +7,103 @@ cbuffer cbuffer_ub : register(b0, space0) {
uint4 ub[44]; uint4 ub[44];
}; };
float2x2 tint_symbol_12(uint4 buffer[44], uint offset) { float2x2 ub_load_12(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_13(uint4 buffer[44], uint offset) { float2x3 ub_load_13(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_14(uint4 buffer[44], uint offset) { float2x4 ub_load_14(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_15(uint4 buffer[44], uint offset) { float3x2 ub_load_15(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_16(uint4 buffer[44], uint offset) { float3x3 ub_load_16(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_17(uint4 buffer[44], uint offset) { float3x4 ub_load_17(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_18(uint4 buffer[44], uint offset) { float4x2 ub_load_18(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_19(uint4 buffer[44], uint offset) { float4x3 ub_load_19(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_20(uint4 buffer[44], uint offset) { float4x4 ub_load_20(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
typedef float3 tint_symbol_21_ret[2]; typedef float3 ub_load_21_ret[2];
tint_symbol_21_ret tint_symbol_21(uint4 buffer[44], uint offset) { ub_load_21_ret ub_load_21(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_27 = ((offset + (i * 16u))) / 4; const uint scalar_offset_27 = ((offset + (i * 16u))) / 4;
arr[i] = asfloat(buffer[scalar_offset_27 / 4].xyz); arr[i] = asfloat(ub[scalar_offset_27 / 4].xyz);
} }
} }
return arr; return arr;
} }
Inner tint_symbol_22(uint4 buffer[44], uint offset) { Inner ub_load_22(uint offset) {
const uint scalar_offset_28 = ((offset + 0u)) / 4; const uint scalar_offset_28 = ((offset + 0u)) / 4;
const uint scalar_offset_29 = ((offset + 16u)) / 4; const uint scalar_offset_29 = ((offset + 16u)) / 4;
const Inner tint_symbol_24 = {asint(buffer[scalar_offset_28 / 4][scalar_offset_28 % 4]), asfloat(buffer[scalar_offset_29 / 4][scalar_offset_29 % 4])}; const Inner tint_symbol = {asint(ub[scalar_offset_28 / 4][scalar_offset_28 % 4]), asfloat(ub[scalar_offset_29 / 4][scalar_offset_29 % 4])};
return tint_symbol_24; return tint_symbol;
} }
typedef Inner tint_symbol_23_ret[4]; typedef Inner ub_load_23_ret[4];
tint_symbol_23_ret tint_symbol_23(uint4 buffer[44], uint offset) { ub_load_23_ret ub_load_23(uint offset) {
Inner arr_1[4] = (Inner[4])0; Inner arr_1[4] = (Inner[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_22(buffer, (offset + (i_1 * 32u))); arr_1[i_1] = ub_load_22((offset + (i_1 * 32u)));
} }
} }
return arr_1; return arr_1;
@ -123,17 +123,17 @@ void main() {
const float4 vec4_f32 = asfloat(ub[6]); const float4 vec4_f32 = asfloat(ub[6]);
const int4 vec4_i32 = asint(ub[7]); const int4 vec4_i32 = asint(ub[7]);
const uint4 vec4_u32 = ub[8]; const uint4 vec4_u32 = ub[8];
const float2x2 mat2x2_f32 = tint_symbol_12(ub, 144u); const float2x2 mat2x2_f32 = ub_load_12(144u);
const float2x3 mat2x3_f32 = tint_symbol_13(ub, 160u); const float2x3 mat2x3_f32 = ub_load_13(160u);
const float2x4 mat2x4_f32 = tint_symbol_14(ub, 192u); const float2x4 mat2x4_f32 = ub_load_14(192u);
const float3x2 mat3x2_f32 = tint_symbol_15(ub, 224u); const float3x2 mat3x2_f32 = ub_load_15(224u);
const float3x3 mat3x3_f32 = tint_symbol_16(ub, 256u); const float3x3 mat3x3_f32 = ub_load_16(256u);
const float3x4 mat3x4_f32 = tint_symbol_17(ub, 304u); const float3x4 mat3x4_f32 = ub_load_17(304u);
const float4x2 mat4x2_f32 = tint_symbol_18(ub, 352u); const float4x2 mat4x2_f32 = ub_load_18(352u);
const float4x3 mat4x3_f32 = tint_symbol_19(ub, 384u); const float4x3 mat4x3_f32 = ub_load_19(384u);
const float4x4 mat4x4_f32 = tint_symbol_20(ub, 448u); const float4x4 mat4x4_f32 = ub_load_20(448u);
const float3 arr2_vec3_f32[2] = tint_symbol_21(ub, 512u); const float3 arr2_vec3_f32[2] = ub_load_21(512u);
const Inner struct_inner = tint_symbol_22(ub, 544u); const Inner struct_inner = ub_load_22(544u);
const Inner array_struct_inner[4] = tint_symbol_23(ub, 576u); const Inner array_struct_inner[4] = ub_load_23(576u);
return; return;
} }

188
test/tint/buffer/uniform/static_index/read_f16.wgsl.expected.dxc.hlsl
View File

@ -8,260 +8,260 @@ cbuffer cbuffer_ub : register(b0, space0) {
uint4 ub[55]; uint4 ub[55];
}; };
float2x2 tint_symbol_16(uint4 buffer[55], uint offset) { float2x2 ub_load_16(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = ub[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = ub[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
float2x3 tint_symbol_17(uint4 buffer[55], uint offset) { float2x3 ub_load_17(uint offset) {
const uint scalar_offset_2 = ((offset + 0u)) / 4; const uint scalar_offset_2 = ((offset + 0u)) / 4;
const uint scalar_offset_3 = ((offset + 16u)) / 4; const uint scalar_offset_3 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz)); return float2x3(asfloat(ub[scalar_offset_2 / 4].xyz), asfloat(ub[scalar_offset_3 / 4].xyz));
} }
float2x4 tint_symbol_18(uint4 buffer[55], uint offset) { float2x4 ub_load_18(uint offset) {
const uint scalar_offset_4 = ((offset + 0u)) / 4; const uint scalar_offset_4 = ((offset + 0u)) / 4;
const uint scalar_offset_5 = ((offset + 16u)) / 4; const uint scalar_offset_5 = ((offset + 16u)) / 4;
return float2x4(asfloat(buffer[scalar_offset_4 / 4]), asfloat(buffer[scalar_offset_5 / 4])); return float2x4(asfloat(ub[scalar_offset_4 / 4]), asfloat(ub[scalar_offset_5 / 4]));
} }
float3x2 tint_symbol_19(uint4 buffer[55], uint offset) { float3x2 ub_load_19(uint offset) {
const uint scalar_offset_6 = ((offset + 0u)) / 4; const uint scalar_offset_6 = ((offset + 0u)) / 4;
uint4 ubo_load_2 = buffer[scalar_offset_6 / 4]; uint4 ubo_load_2 = ub[scalar_offset_6 / 4];
const uint scalar_offset_7 = ((offset + 8u)) / 4; const uint scalar_offset_7 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_7 / 4]; uint4 ubo_load_3 = ub[scalar_offset_7 / 4];
const uint scalar_offset_8 = ((offset + 16u)) / 4; const uint scalar_offset_8 = ((offset + 16u)) / 4;
uint4 ubo_load_4 = buffer[scalar_offset_8 / 4]; uint4 ubo_load_4 = ub[scalar_offset_8 / 4];
return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy))); return float3x2(asfloat(((scalar_offset_6 & 2) ? ubo_load_2.zw : ubo_load_2.xy)), asfloat(((scalar_offset_7 & 2) ? ubo_load_3.zw : ubo_load_3.xy)), asfloat(((scalar_offset_8 & 2) ? ubo_load_4.zw : ubo_load_4.xy)));
} }
float3x3 tint_symbol_20(uint4 buffer[55], uint offset) { float3x3 ub_load_20(uint offset) {
const uint scalar_offset_9 = ((offset + 0u)) / 4; const uint scalar_offset_9 = ((offset + 0u)) / 4;
const uint scalar_offset_10 = ((offset + 16u)) / 4; const uint scalar_offset_10 = ((offset + 16u)) / 4;
const uint scalar_offset_11 = ((offset + 32u)) / 4; const uint scalar_offset_11 = ((offset + 32u)) / 4;
return float3x3(asfloat(buffer[scalar_offset_9 / 4].xyz), asfloat(buffer[scalar_offset_10 / 4].xyz), asfloat(buffer[scalar_offset_11 / 4].xyz)); return float3x3(asfloat(ub[scalar_offset_9 / 4].xyz), asfloat(ub[scalar_offset_10 / 4].xyz), asfloat(ub[scalar_offset_11 / 4].xyz));
} }
float3x4 tint_symbol_21(uint4 buffer[55], uint offset) { float3x4 ub_load_21(uint offset) {
const uint scalar_offset_12 = ((offset + 0u)) / 4; const uint scalar_offset_12 = ((offset + 0u)) / 4;
const uint scalar_offset_13 = ((offset + 16u)) / 4; const uint scalar_offset_13 = ((offset + 16u)) / 4;
const uint scalar_offset_14 = ((offset + 32u)) / 4; const uint scalar_offset_14 = ((offset + 32u)) / 4;
return float3x4(asfloat(buffer[scalar_offset_12 / 4]), asfloat(buffer[scalar_offset_13 / 4]), asfloat(buffer[scalar_offset_14 / 4])); return float3x4(asfloat(ub[scalar_offset_12 / 4]), asfloat(ub[scalar_offset_13 / 4]), asfloat(ub[scalar_offset_14 / 4]));
} }
float4x2 tint_symbol_22(uint4 buffer[55], uint offset) { float4x2 ub_load_22(uint offset) {
const uint scalar_offset_15 = ((offset + 0u)) / 4; const uint scalar_offset_15 = ((offset + 0u)) / 4;
uint4 ubo_load_5 = buffer[scalar_offset_15 / 4]; uint4 ubo_load_5 = ub[scalar_offset_15 / 4];
const uint scalar_offset_16 = ((offset + 8u)) / 4; const uint scalar_offset_16 = ((offset + 8u)) / 4;
uint4 ubo_load_6 = buffer[scalar_offset_16 / 4]; uint4 ubo_load_6 = ub[scalar_offset_16 / 4];
const uint scalar_offset_17 = ((offset + 16u)) / 4; const uint scalar_offset_17 = ((offset + 16u)) / 4;
uint4 ubo_load_7 = buffer[scalar_offset_17 / 4]; uint4 ubo_load_7 = ub[scalar_offset_17 / 4];
const uint scalar_offset_18 = ((offset + 24u)) / 4; const uint scalar_offset_18 = ((offset + 24u)) / 4;
uint4 ubo_load_8 = buffer[scalar_offset_18 / 4]; uint4 ubo_load_8 = ub[scalar_offset_18 / 4];
return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy))); return float4x2(asfloat(((scalar_offset_15 & 2) ? ubo_load_5.zw : ubo_load_5.xy)), asfloat(((scalar_offset_16 & 2) ? ubo_load_6.zw : ubo_load_6.xy)), asfloat(((scalar_offset_17 & 2) ? ubo_load_7.zw : ubo_load_7.xy)), asfloat(((scalar_offset_18 & 2) ? ubo_load_8.zw : ubo_load_8.xy)));
} }
float4x3 tint_symbol_23(uint4 buffer[55], uint offset) { float4x3 ub_load_23(uint offset) {
const uint scalar_offset_19 = ((offset + 0u)) / 4; const uint scalar_offset_19 = ((offset + 0u)) / 4;
const uint scalar_offset_20 = ((offset + 16u)) / 4; const uint scalar_offset_20 = ((offset + 16u)) / 4;
const uint scalar_offset_21 = ((offset + 32u)) / 4; const uint scalar_offset_21 = ((offset + 32u)) / 4;
const uint scalar_offset_22 = ((offset + 48u)) / 4; const uint scalar_offset_22 = ((offset + 48u)) / 4;
return float4x3(asfloat(buffer[scalar_offset_19 / 4].xyz), asfloat(buffer[scalar_offset_20 / 4].xyz), asfloat(buffer[scalar_offset_21 / 4].xyz), asfloat(buffer[scalar_offset_22 / 4].xyz)); return float4x3(asfloat(ub[scalar_offset_19 / 4].xyz), asfloat(ub[scalar_offset_20 / 4].xyz), asfloat(ub[scalar_offset_21 / 4].xyz), asfloat(ub[scalar_offset_22 / 4].xyz));
} }
float4x4 tint_symbol_24(uint4 buffer[55], uint offset) { float4x4 ub_load_24(uint offset) {
const uint scalar_offset_23 = ((offset + 0u)) / 4; const uint scalar_offset_23 = ((offset + 0u)) / 4;
const uint scalar_offset_24 = ((offset + 16u)) / 4; const uint scalar_offset_24 = ((offset + 16u)) / 4;
const uint scalar_offset_25 = ((offset + 32u)) / 4; const uint scalar_offset_25 = ((offset + 32u)) / 4;
const uint scalar_offset_26 = ((offset + 48u)) / 4; const uint scalar_offset_26 = ((offset + 48u)) / 4;
return float4x4(asfloat(buffer[scalar_offset_23 / 4]), asfloat(buffer[scalar_offset_24 / 4]), asfloat(buffer[scalar_offset_25 / 4]), asfloat(buffer[scalar_offset_26 / 4])); return float4x4(asfloat(ub[scalar_offset_23 / 4]), asfloat(ub[scalar_offset_24 / 4]), asfloat(ub[scalar_offset_25 / 4]), asfloat(ub[scalar_offset_26 / 4]));
} }
matrix<float16_t, 2, 2> tint_symbol_25(uint4 buffer[55], uint offset) { matrix<float16_t, 2, 2> ub_load_25(uint offset) {
const uint scalar_offset_27 = ((offset + 0u)) / 4; const uint scalar_offset_27 = ((offset + 0u)) / 4;
uint ubo_load_9 = buffer[scalar_offset_27 / 4][scalar_offset_27 % 4]; uint ubo_load_9 = ub[scalar_offset_27 / 4][scalar_offset_27 % 4];
const uint scalar_offset_28 = ((offset + 4u)) / 4; const uint scalar_offset_28 = ((offset + 4u)) / 4;
uint ubo_load_10 = buffer[scalar_offset_28 / 4][scalar_offset_28 % 4]; uint ubo_load_10 = ub[scalar_offset_28 / 4][scalar_offset_28 % 4];
return matrix<float16_t, 2, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_9 & 0xFFFF)), float16_t(f16tof32(ubo_load_9 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_10 & 0xFFFF)), float16_t(f16tof32(ubo_load_10 >> 16)))); return matrix<float16_t, 2, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_9 & 0xFFFF)), float16_t(f16tof32(ubo_load_9 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_10 & 0xFFFF)), float16_t(f16tof32(ubo_load_10 >> 16))));
} }
matrix<float16_t, 2, 3> tint_symbol_26(uint4 buffer[55], uint offset) { matrix<float16_t, 2, 3> ub_load_26(uint offset) {
const uint scalar_offset_29 = ((offset + 0u)) / 4; const uint scalar_offset_29 = ((offset + 0u)) / 4;
uint4 ubo_load_12 = buffer[scalar_offset_29 / 4]; uint4 ubo_load_12 = ub[scalar_offset_29 / 4];
uint2 ubo_load_11 = ((scalar_offset_29 & 2) ? ubo_load_12.zw : ubo_load_12.xy); uint2 ubo_load_11 = ((scalar_offset_29 & 2) ? ubo_load_12.zw : ubo_load_12.xy);
vector<float16_t, 2> ubo_load_11_xz = vector<float16_t, 2>(f16tof32(ubo_load_11 & 0xFFFF)); vector<float16_t, 2> ubo_load_11_xz = vector<float16_t, 2>(f16tof32(ubo_load_11 & 0xFFFF));
float16_t ubo_load_11_y = f16tof32(ubo_load_11[0] >> 16); float16_t ubo_load_11_y = f16tof32(ubo_load_11[0] >> 16);
const uint scalar_offset_30 = ((offset + 8u)) / 4; const uint scalar_offset_30 = ((offset + 8u)) / 4;
uint4 ubo_load_14 = buffer[scalar_offset_30 / 4]; uint4 ubo_load_14 = ub[scalar_offset_30 / 4];
uint2 ubo_load_13 = ((scalar_offset_30 & 2) ? ubo_load_14.zw : ubo_load_14.xy); uint2 ubo_load_13 = ((scalar_offset_30 & 2) ? ubo_load_14.zw : ubo_load_14.xy);
vector<float16_t, 2> ubo_load_13_xz = vector<float16_t, 2>(f16tof32(ubo_load_13 & 0xFFFF)); vector<float16_t, 2> ubo_load_13_xz = vector<float16_t, 2>(f16tof32(ubo_load_13 & 0xFFFF));
float16_t ubo_load_13_y = f16tof32(ubo_load_13[0] >> 16); float16_t ubo_load_13_y = f16tof32(ubo_load_13[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_11_xz[0], ubo_load_11_y, ubo_load_11_xz[1]), vector<float16_t, 3>(ubo_load_13_xz[0], ubo_load_13_y, ubo_load_13_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_11_xz[0], ubo_load_11_y, ubo_load_11_xz[1]), vector<float16_t, 3>(ubo_load_13_xz[0], ubo_load_13_y, ubo_load_13_xz[1]));
} }
matrix<float16_t, 2, 4> tint_symbol_27(uint4 buffer[55], uint offset) { matrix<float16_t, 2, 4> ub_load_27(uint offset) {
const uint scalar_offset_31 = ((offset + 0u)) / 4; const uint scalar_offset_31 = ((offset + 0u)) / 4;
uint4 ubo_load_16 = buffer[scalar_offset_31 / 4]; uint4 ubo_load_16 = ub[scalar_offset_31 / 4];
uint2 ubo_load_15 = ((scalar_offset_31 & 2) ? ubo_load_16.zw : ubo_load_16.xy); uint2 ubo_load_15 = ((scalar_offset_31 & 2) ? ubo_load_16.zw : ubo_load_16.xy);
vector<float16_t, 2> ubo_load_15_xz = vector<float16_t, 2>(f16tof32(ubo_load_15 & 0xFFFF)); vector<float16_t, 2> ubo_load_15_xz = vector<float16_t, 2>(f16tof32(ubo_load_15 & 0xFFFF));
vector<float16_t, 2> ubo_load_15_yw = vector<float16_t, 2>(f16tof32(ubo_load_15 >> 16)); vector<float16_t, 2> ubo_load_15_yw = vector<float16_t, 2>(f16tof32(ubo_load_15 >> 16));
const uint scalar_offset_32 = ((offset + 8u)) / 4; const uint scalar_offset_32 = ((offset + 8u)) / 4;
uint4 ubo_load_18 = buffer[scalar_offset_32 / 4]; uint4 ubo_load_18 = ub[scalar_offset_32 / 4];
uint2 ubo_load_17 = ((scalar_offset_32 & 2) ? ubo_load_18.zw : ubo_load_18.xy); uint2 ubo_load_17 = ((scalar_offset_32 & 2) ? ubo_load_18.zw : ubo_load_18.xy);
vector<float16_t, 2> ubo_load_17_xz = vector<float16_t, 2>(f16tof32(ubo_load_17 & 0xFFFF)); vector<float16_t, 2> ubo_load_17_xz = vector<float16_t, 2>(f16tof32(ubo_load_17 & 0xFFFF));
vector<float16_t, 2> ubo_load_17_yw = vector<float16_t, 2>(f16tof32(ubo_load_17 >> 16)); vector<float16_t, 2> ubo_load_17_yw = vector<float16_t, 2>(f16tof32(ubo_load_17 >> 16));
return matrix<float16_t, 2, 4>(vector<float16_t, 4>(ubo_load_15_xz[0], ubo_load_15_yw[0], ubo_load_15_xz[1], ubo_load_15_yw[1]), vector<float16_t, 4>(ubo_load_17_xz[0], ubo_load_17_yw[0], ubo_load_17_xz[1], ubo_load_17_yw[1])); return matrix<float16_t, 2, 4>(vector<float16_t, 4>(ubo_load_15_xz[0], ubo_load_15_yw[0], ubo_load_15_xz[1], ubo_load_15_yw[1]), vector<float16_t, 4>(ubo_load_17_xz[0], ubo_load_17_yw[0], ubo_load_17_xz[1], ubo_load_17_yw[1]));
} }
matrix<float16_t, 3, 2> tint_symbol_28(uint4 buffer[55], uint offset) { matrix<float16_t, 3, 2> ub_load_28(uint offset) {
const uint scalar_offset_33 = ((offset + 0u)) / 4; const uint scalar_offset_33 = ((offset + 0u)) / 4;
uint ubo_load_19 = buffer[scalar_offset_33 / 4][scalar_offset_33 % 4]; uint ubo_load_19 = ub[scalar_offset_33 / 4][scalar_offset_33 % 4];
const uint scalar_offset_34 = ((offset + 4u)) / 4; const uint scalar_offset_34 = ((offset + 4u)) / 4;
uint ubo_load_20 = buffer[scalar_offset_34 / 4][scalar_offset_34 % 4]; uint ubo_load_20 = ub[scalar_offset_34 / 4][scalar_offset_34 % 4];
const uint scalar_offset_35 = ((offset + 8u)) / 4; const uint scalar_offset_35 = ((offset + 8u)) / 4;
uint ubo_load_21 = buffer[scalar_offset_35 / 4][scalar_offset_35 % 4]; uint ubo_load_21 = ub[scalar_offset_35 / 4][scalar_offset_35 % 4];
return matrix<float16_t, 3, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_19 & 0xFFFF)), float16_t(f16tof32(ubo_load_19 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_20 & 0xFFFF)), float16_t(f16tof32(ubo_load_20 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_21 & 0xFFFF)), float16_t(f16tof32(ubo_load_21 >> 16)))); return matrix<float16_t, 3, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_19 & 0xFFFF)), float16_t(f16tof32(ubo_load_19 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_20 & 0xFFFF)), float16_t(f16tof32(ubo_load_20 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_21 & 0xFFFF)), float16_t(f16tof32(ubo_load_21 >> 16))));
} }
matrix<float16_t, 3, 3> tint_symbol_29(uint4 buffer[55], uint offset) { matrix<float16_t, 3, 3> ub_load_29(uint offset) {
const uint scalar_offset_36 = ((offset + 0u)) / 4; const uint scalar_offset_36 = ((offset + 0u)) / 4;
uint4 ubo_load_23 = buffer[scalar_offset_36 / 4]; uint4 ubo_load_23 = ub[scalar_offset_36 / 4];
uint2 ubo_load_22 = ((scalar_offset_36 & 2) ? ubo_load_23.zw : ubo_load_23.xy); uint2 ubo_load_22 = ((scalar_offset_36 & 2) ? ubo_load_23.zw : ubo_load_23.xy);
vector<float16_t, 2> ubo_load_22_xz = vector<float16_t, 2>(f16tof32(ubo_load_22 & 0xFFFF)); vector<float16_t, 2> ubo_load_22_xz = vector<float16_t, 2>(f16tof32(ubo_load_22 & 0xFFFF));
float16_t ubo_load_22_y = f16tof32(ubo_load_22[0] >> 16); float16_t ubo_load_22_y = f16tof32(ubo_load_22[0] >> 16);
const uint scalar_offset_37 = ((offset + 8u)) / 4; const uint scalar_offset_37 = ((offset + 8u)) / 4;
uint4 ubo_load_25 = buffer[scalar_offset_37 / 4]; uint4 ubo_load_25 = ub[scalar_offset_37 / 4];
uint2 ubo_load_24 = ((scalar_offset_37 & 2) ? ubo_load_25.zw : ubo_load_25.xy); uint2 ubo_load_24 = ((scalar_offset_37 & 2) ? ubo_load_25.zw : ubo_load_25.xy);
vector<float16_t, 2> ubo_load_24_xz = vector<float16_t, 2>(f16tof32(ubo_load_24 & 0xFFFF)); vector<float16_t, 2> ubo_load_24_xz = vector<float16_t, 2>(f16tof32(ubo_load_24 & 0xFFFF));
float16_t ubo_load_24_y = f16tof32(ubo_load_24[0] >> 16); float16_t ubo_load_24_y = f16tof32(ubo_load_24[0] >> 16);
const uint scalar_offset_38 = ((offset + 16u)) / 4; const uint scalar_offset_38 = ((offset + 16u)) / 4;
uint4 ubo_load_27 = buffer[scalar_offset_38 / 4]; uint4 ubo_load_27 = ub[scalar_offset_38 / 4];
uint2 ubo_load_26 = ((scalar_offset_38 & 2) ? ubo_load_27.zw : ubo_load_27.xy); uint2 ubo_load_26 = ((scalar_offset_38 & 2) ? ubo_load_27.zw : ubo_load_27.xy);
vector<float16_t, 2> ubo_load_26_xz = vector<float16_t, 2>(f16tof32(ubo_load_26 & 0xFFFF)); vector<float16_t, 2> ubo_load_26_xz = vector<float16_t, 2>(f16tof32(ubo_load_26 & 0xFFFF));
float16_t ubo_load_26_y = f16tof32(ubo_load_26[0] >> 16); float16_t ubo_load_26_y = f16tof32(ubo_load_26[0] >> 16);
return matrix<float16_t, 3, 3>(vector<float16_t, 3>(ubo_load_22_xz[0], ubo_load_22_y, ubo_load_22_xz[1]), vector<float16_t, 3>(ubo_load_24_xz[0], ubo_load_24_y, ubo_load_24_xz[1]), vector<float16_t, 3>(ubo_load_26_xz[0], ubo_load_26_y, ubo_load_26_xz[1])); return matrix<float16_t, 3, 3>(vector<float16_t, 3>(ubo_load_22_xz[0], ubo_load_22_y, ubo_load_22_xz[1]), vector<float16_t, 3>(ubo_load_24_xz[0], ubo_load_24_y, ubo_load_24_xz[1]), vector<float16_t, 3>(ubo_load_26_xz[0], ubo_load_26_y, ubo_load_26_xz[1]));
} }
matrix<float16_t, 3, 4> tint_symbol_30(uint4 buffer[55], uint offset) { matrix<float16_t, 3, 4> ub_load_30(uint offset) {
const uint scalar_offset_39 = ((offset + 0u)) / 4; const uint scalar_offset_39 = ((offset + 0u)) / 4;
uint4 ubo_load_29 = buffer[scalar_offset_39 / 4]; uint4 ubo_load_29 = ub[scalar_offset_39 / 4];
uint2 ubo_load_28 = ((scalar_offset_39 & 2) ? ubo_load_29.zw : ubo_load_29.xy); uint2 ubo_load_28 = ((scalar_offset_39 & 2) ? ubo_load_29.zw : ubo_load_29.xy);
vector<float16_t, 2> ubo_load_28_xz = vector<float16_t, 2>(f16tof32(ubo_load_28 & 0xFFFF)); vector<float16_t, 2> ubo_load_28_xz = vector<float16_t, 2>(f16tof32(ubo_load_28 & 0xFFFF));
vector<float16_t, 2> ubo_load_28_yw = vector<float16_t, 2>(f16tof32(ubo_load_28 >> 16)); vector<float16_t, 2> ubo_load_28_yw = vector<float16_t, 2>(f16tof32(ubo_load_28 >> 16));
const uint scalar_offset_40 = ((offset + 8u)) / 4; const uint scalar_offset_40 = ((offset + 8u)) / 4;
uint4 ubo_load_31 = buffer[scalar_offset_40 / 4]; uint4 ubo_load_31 = ub[scalar_offset_40 / 4];
uint2 ubo_load_30 = ((scalar_offset_40 & 2) ? ubo_load_31.zw : ubo_load_31.xy); uint2 ubo_load_30 = ((scalar_offset_40 & 2) ? ubo_load_31.zw : ubo_load_31.xy);
vector<float16_t, 2> ubo_load_30_xz = vector<float16_t, 2>(f16tof32(ubo_load_30 & 0xFFFF)); vector<float16_t, 2> ubo_load_30_xz = vector<float16_t, 2>(f16tof32(ubo_load_30 & 0xFFFF));
vector<float16_t, 2> ubo_load_30_yw = vector<float16_t, 2>(f16tof32(ubo_load_30 >> 16)); vector<float16_t, 2> ubo_load_30_yw = vector<float16_t, 2>(f16tof32(ubo_load_30 >> 16));
const uint scalar_offset_41 = ((offset + 16u)) / 4; const uint scalar_offset_41 = ((offset + 16u)) / 4;
uint4 ubo_load_33 = buffer[scalar_offset_41 / 4]; uint4 ubo_load_33 = ub[scalar_offset_41 / 4];
uint2 ubo_load_32 = ((scalar_offset_41 & 2) ? ubo_load_33.zw : ubo_load_33.xy); uint2 ubo_load_32 = ((scalar_offset_41 & 2) ? ubo_load_33.zw : ubo_load_33.xy);
vector<float16_t, 2> ubo_load_32_xz = vector<float16_t, 2>(f16tof32(ubo_load_32 & 0xFFFF)); vector<float16_t, 2> ubo_load_32_xz = vector<float16_t, 2>(f16tof32(ubo_load_32 & 0xFFFF));
vector<float16_t, 2> ubo_load_32_yw = vector<float16_t, 2>(f16tof32(ubo_load_32 >> 16)); vector<float16_t, 2> ubo_load_32_yw = vector<float16_t, 2>(f16tof32(ubo_load_32 >> 16));
return matrix<float16_t, 3, 4>(vector<float16_t, 4>(ubo_load_28_xz[0], ubo_load_28_yw[0], ubo_load_28_xz[1], ubo_load_28_yw[1]), vector<float16_t, 4>(ubo_load_30_xz[0], ubo_load_30_yw[0], ubo_load_30_xz[1], ubo_load_30_yw[1]), vector<float16_t, 4>(ubo_load_32_xz[0], ubo_load_32_yw[0], ubo_load_32_xz[1], ubo_load_32_yw[1])); return matrix<float16_t, 3, 4>(vector<float16_t, 4>(ubo_load_28_xz[0], ubo_load_28_yw[0], ubo_load_28_xz[1], ubo_load_28_yw[1]), vector<float16_t, 4>(ubo_load_30_xz[0], ubo_load_30_yw[0], ubo_load_30_xz[1], ubo_load_30_yw[1]), vector<float16_t, 4>(ubo_load_32_xz[0], ubo_load_32_yw[0], ubo_load_32_xz[1], ubo_load_32_yw[1]));
} }
matrix<float16_t, 4, 2> tint_symbol_31(uint4 buffer[55], uint offset) { matrix<float16_t, 4, 2> ub_load_31(uint offset) {
const uint scalar_offset_42 = ((offset + 0u)) / 4; const uint scalar_offset_42 = ((offset + 0u)) / 4;
uint ubo_load_34 = buffer[scalar_offset_42 / 4][scalar_offset_42 % 4]; uint ubo_load_34 = ub[scalar_offset_42 / 4][scalar_offset_42 % 4];
const uint scalar_offset_43 = ((offset + 4u)) / 4; const uint scalar_offset_43 = ((offset + 4u)) / 4;
uint ubo_load_35 = buffer[scalar_offset_43 / 4][scalar_offset_43 % 4]; uint ubo_load_35 = ub[scalar_offset_43 / 4][scalar_offset_43 % 4];
const uint scalar_offset_44 = ((offset + 8u)) / 4; const uint scalar_offset_44 = ((offset + 8u)) / 4;
uint ubo_load_36 = buffer[scalar_offset_44 / 4][scalar_offset_44 % 4]; uint ubo_load_36 = ub[scalar_offset_44 / 4][scalar_offset_44 % 4];
const uint scalar_offset_45 = ((offset + 12u)) / 4; const uint scalar_offset_45 = ((offset + 12u)) / 4;
uint ubo_load_37 = buffer[scalar_offset_45 / 4][scalar_offset_45 % 4]; uint ubo_load_37 = ub[scalar_offset_45 / 4][scalar_offset_45 % 4];
return matrix<float16_t, 4, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_34 & 0xFFFF)), float16_t(f16tof32(ubo_load_34 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_35 & 0xFFFF)), float16_t(f16tof32(ubo_load_35 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_36 & 0xFFFF)), float16_t(f16tof32(ubo_load_36 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_37 & 0xFFFF)), float16_t(f16tof32(ubo_load_37 >> 16)))); return matrix<float16_t, 4, 2>(vector<float16_t, 2>(float16_t(f16tof32(ubo_load_34 & 0xFFFF)), float16_t(f16tof32(ubo_load_34 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_35 & 0xFFFF)), float16_t(f16tof32(ubo_load_35 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_36 & 0xFFFF)), float16_t(f16tof32(ubo_load_36 >> 16))), vector<float16_t, 2>(float16_t(f16tof32(ubo_load_37 & 0xFFFF)), float16_t(f16tof32(ubo_load_37 >> 16))));
} }
matrix<float16_t, 4, 3> tint_symbol_32(uint4 buffer[55], uint offset) { matrix<float16_t, 4, 3> ub_load_32(uint offset) {
const uint scalar_offset_46 = ((offset + 0u)) / 4; const uint scalar_offset_46 = ((offset + 0u)) / 4;
uint4 ubo_load_39 = buffer[scalar_offset_46 / 4]; uint4 ubo_load_39 = ub[scalar_offset_46 / 4];
uint2 ubo_load_38 = ((scalar_offset_46 & 2) ? ubo_load_39.zw : ubo_load_39.xy); uint2 ubo_load_38 = ((scalar_offset_46 & 2) ? ubo_load_39.zw : ubo_load_39.xy);
vector<float16_t, 2> ubo_load_38_xz = vector<float16_t, 2>(f16tof32(ubo_load_38 & 0xFFFF)); vector<float16_t, 2> ubo_load_38_xz = vector<float16_t, 2>(f16tof32(ubo_load_38 & 0xFFFF));
float16_t ubo_load_38_y = f16tof32(ubo_load_38[0] >> 16); float16_t ubo_load_38_y = f16tof32(ubo_load_38[0] >> 16);
const uint scalar_offset_47 = ((offset + 8u)) / 4; const uint scalar_offset_47 = ((offset + 8u)) / 4;
uint4 ubo_load_41 = buffer[scalar_offset_47 / 4]; uint4 ubo_load_41 = ub[scalar_offset_47 / 4];
uint2 ubo_load_40 = ((scalar_offset_47 & 2) ? ubo_load_41.zw : ubo_load_41.xy); uint2 ubo_load_40 = ((scalar_offset_47 & 2) ? ubo_load_41.zw : ubo_load_41.xy);
vector<float16_t, 2> ubo_load_40_xz = vector<float16_t, 2>(f16tof32(ubo_load_40 & 0xFFFF)); vector<float16_t, 2> ubo_load_40_xz = vector<float16_t, 2>(f16tof32(ubo_load_40 & 0xFFFF));
float16_t ubo_load_40_y = f16tof32(ubo_load_40[0] >> 16); float16_t ubo_load_40_y = f16tof32(ubo_load_40[0] >> 16);
const uint scalar_offset_48 = ((offset + 16u)) / 4; const uint scalar_offset_48 = ((offset + 16u)) / 4;
uint4 ubo_load_43 = buffer[scalar_offset_48 / 4]; uint4 ubo_load_43 = ub[scalar_offset_48 / 4];
uint2 ubo_load_42 = ((scalar_offset_48 & 2) ? ubo_load_43.zw : ubo_load_43.xy); uint2 ubo_load_42 = ((scalar_offset_48 & 2) ? ubo_load_43.zw : ubo_load_43.xy);
vector<float16_t, 2> ubo_load_42_xz = vector<float16_t, 2>(f16tof32(ubo_load_42 & 0xFFFF)); vector<float16_t, 2> ubo_load_42_xz = vector<float16_t, 2>(f16tof32(ubo_load_42 & 0xFFFF));
float16_t ubo_load_42_y = f16tof32(ubo_load_42[0] >> 16); float16_t ubo_load_42_y = f16tof32(ubo_load_42[0] >> 16);
const uint scalar_offset_49 = ((offset + 24u)) / 4; const uint scalar_offset_49 = ((offset + 24u)) / 4;
uint4 ubo_load_45 = buffer[scalar_offset_49 / 4]; uint4 ubo_load_45 = ub[scalar_offset_49 / 4];
uint2 ubo_load_44 = ((scalar_offset_49 & 2) ? ubo_load_45.zw : ubo_load_45.xy); uint2 ubo_load_44 = ((scalar_offset_49 & 2) ? ubo_load_45.zw : ubo_load_45.xy);
vector<float16_t, 2> ubo_load_44_xz = vector<float16_t, 2>(f16tof32(ubo_load_44 & 0xFFFF)); vector<float16_t, 2> ubo_load_44_xz = vector<float16_t, 2>(f16tof32(ubo_load_44 & 0xFFFF));
float16_t ubo_load_44_y = f16tof32(ubo_load_44[0] >> 16); float16_t ubo_load_44_y = f16tof32(ubo_load_44[0] >> 16);
return matrix<float16_t, 4, 3>(vector<float16_t, 3>(ubo_load_38_xz[0], ubo_load_38_y, ubo_load_38_xz[1]), vector<float16_t, 3>(ubo_load_40_xz[0], ubo_load_40_y, ubo_load_40_xz[1]), vector<float16_t, 3>(ubo_load_42_xz[0], ubo_load_42_y, ubo_load_42_xz[1]), vector<float16_t, 3>(ubo_load_44_xz[0], ubo_load_44_y, ubo_load_44_xz[1])); return matrix<float16_t, 4, 3>(vector<float16_t, 3>(ubo_load_38_xz[0], ubo_load_38_y, ubo_load_38_xz[1]), vector<float16_t, 3>(ubo_load_40_xz[0], ubo_load_40_y, ubo_load_40_xz[1]), vector<float16_t, 3>(ubo_load_42_xz[0], ubo_load_42_y, ubo_load_42_xz[1]), vector<float16_t, 3>(ubo_load_44_xz[0], ubo_load_44_y, ubo_load_44_xz[1]));
} }
matrix<float16_t, 4, 4> tint_symbol_33(uint4 buffer[55], uint offset) { matrix<float16_t, 4, 4> ub_load_33(uint offset) {
const uint scalar_offset_50 = ((offset + 0u)) / 4; const uint scalar_offset_50 = ((offset + 0u)) / 4;
uint4 ubo_load_47 = buffer[scalar_offset_50 / 4]; uint4 ubo_load_47 = ub[scalar_offset_50 / 4];
uint2 ubo_load_46 = ((scalar_offset_50 & 2) ? ubo_load_47.zw : ubo_load_47.xy); uint2 ubo_load_46 = ((scalar_offset_50 & 2) ? ubo_load_47.zw : ubo_load_47.xy);
vector<float16_t, 2> ubo_load_46_xz = vector<float16_t, 2>(f16tof32(ubo_load_46 & 0xFFFF)); vector<float16_t, 2> ubo_load_46_xz = vector<float16_t, 2>(f16tof32(ubo_load_46 & 0xFFFF));
vector<float16_t, 2> ubo_load_46_yw = vector<float16_t, 2>(f16tof32(ubo_load_46 >> 16)); vector<float16_t, 2> ubo_load_46_yw = vector<float16_t, 2>(f16tof32(ubo_load_46 >> 16));
const uint scalar_offset_51 = ((offset + 8u)) / 4; const uint scalar_offset_51 = ((offset + 8u)) / 4;
uint4 ubo_load_49 = buffer[scalar_offset_51 / 4]; uint4 ubo_load_49 = ub[scalar_offset_51 / 4];
uint2 ubo_load_48 = ((scalar_offset_51 & 2) ? ubo_load_49.zw : ubo_load_49.xy); uint2 ubo_load_48 = ((scalar_offset_51 & 2) ? ubo_load_49.zw : ubo_load_49.xy);
vector<float16_t, 2> ubo_load_48_xz = vector<float16_t, 2>(f16tof32(ubo_load_48 & 0xFFFF)); vector<float16_t, 2> ubo_load_48_xz = vector<float16_t, 2>(f16tof32(ubo_load_48 & 0xFFFF));
vector<float16_t, 2> ubo_load_48_yw = vector<float16_t, 2>(f16tof32(ubo_load_48 >> 16)); vector<float16_t, 2> ubo_load_48_yw = vector<float16_t, 2>(f16tof32(ubo_load_48 >> 16));
const uint scalar_offset_52 = ((offset + 16u)) / 4; const uint scalar_offset_52 = ((offset + 16u)) / 4;
uint4 ubo_load_51 = buffer[scalar_offset_52 / 4]; uint4 ubo_load_51 = ub[scalar_offset_52 / 4];
uint2 ubo_load_50 = ((scalar_offset_52 & 2) ? ubo_load_51.zw : ubo_load_51.xy); uint2 ubo_load_50 = ((scalar_offset_52 & 2) ? ubo_load_51.zw : ubo_load_51.xy);
vector<float16_t, 2> ubo_load_50_xz = vector<float16_t, 2>(f16tof32(ubo_load_50 & 0xFFFF)); vector<float16_t, 2> ubo_load_50_xz = vector<float16_t, 2>(f16tof32(ubo_load_50 & 0xFFFF));
vector<float16_t, 2> ubo_load_50_yw = vector<float16_t, 2>(f16tof32(ubo_load_50 >> 16)); vector<float16_t, 2> ubo_load_50_yw = vector<float16_t, 2>(f16tof32(ubo_load_50 >> 16));
const uint scalar_offset_53 = ((offset + 24u)) / 4; const uint scalar_offset_53 = ((offset + 24u)) / 4;
uint4 ubo_load_53 = buffer[scalar_offset_53 / 4]; uint4 ubo_load_53 = ub[scalar_offset_53 / 4];
uint2 ubo_load_52 = ((scalar_offset_53 & 2) ? ubo_load_53.zw : ubo_load_53.xy); uint2 ubo_load_52 = ((scalar_offset_53 & 2) ? ubo_load_53.zw : ubo_load_53.xy);
vector<float16_t, 2> ubo_load_52_xz = vector<float16_t, 2>(f16tof32(ubo_load_52 & 0xFFFF)); vector<float16_t, 2> ubo_load_52_xz = vector<float16_t, 2>(f16tof32(ubo_load_52 & 0xFFFF));
vector<float16_t, 2> ubo_load_52_yw = vector<float16_t, 2>(f16tof32(ubo_load_52 >> 16)); vector<float16_t, 2> ubo_load_52_yw = vector<float16_t, 2>(f16tof32(ubo_load_52 >> 16));
return matrix<float16_t, 4, 4>(vector<float16_t, 4>(ubo_load_46_xz[0], ubo_load_46_yw[0], ubo_load_46_xz[1], ubo_load_46_yw[1]), vector<float16_t, 4>(ubo_load_48_xz[0], ubo_load_48_yw[0], ubo_load_48_xz[1], ubo_load_48_yw[1]), vector<float16_t, 4>(ubo_load_50_xz[0], ubo_load_50_yw[0], ubo_load_50_xz[1], ubo_load_50_yw[1]), vector<float16_t, 4>(ubo_load_52_xz[0], ubo_load_52_yw[0], ubo_load_52_xz[1], ubo_load_52_yw[1])); return matrix<float16_t, 4, 4>(vector<float16_t, 4>(ubo_load_46_xz[0], ubo_load_46_yw[0], ubo_load_46_xz[1], ubo_load_46_yw[1]), vector<float16_t, 4>(ubo_load_48_xz[0], ubo_load_48_yw[0], ubo_load_48_xz[1], ubo_load_48_yw[1]), vector<float16_t, 4>(ubo_load_50_xz[0], ubo_load_50_yw[0], ubo_load_50_xz[1], ubo_load_50_yw[1]), vector<float16_t, 4>(ubo_load_52_xz[0], ubo_load_52_yw[0], ubo_load_52_xz[1], ubo_load_52_yw[1]));
} }
typedef float3 tint_symbol_34_ret[2]; typedef float3 ub_load_34_ret[2];
tint_symbol_34_ret tint_symbol_34(uint4 buffer[55], uint offset) { ub_load_34_ret ub_load_34(uint offset) {
float3 arr[2] = (float3[2])0; float3 arr[2] = (float3[2])0;
{ {
for(uint i = 0u; (i < 2u); i = (i + 1u)) { for(uint i = 0u; (i < 2u); i = (i + 1u)) {
const uint scalar_offset_54 = ((offset + (i * 16u))) / 4; const uint scalar_offset_54 = ((offset + (i * 16u))) / 4;
arr[i] = asfloat(buffer[scalar_offset_54 / 4].xyz); arr[i] = asfloat(ub[scalar_offset_54 / 4].xyz);
} }
} }
return arr; return arr;
} }
typedef matrix<float16_t, 4, 2> tint_symbol_35_ret[2]; typedef matrix<float16_t, 4, 2> ub_load_35_ret[2];
tint_symbol_35_ret tint_symbol_35(uint4 buffer[55], uint offset) { ub_load_35_ret ub_load_35(uint offset) {
matrix<float16_t, 4, 2> arr_1[2] = (matrix<float16_t, 4, 2>[2])0; matrix<float16_t, 4, 2> arr_1[2] = (matrix<float16_t, 4, 2>[2])0;
{ {
for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 2u); i_1 = (i_1 + 1u)) {
arr_1[i_1] = tint_symbol_31(buffer, (offset + (i_1 * 16u))); arr_1[i_1] = ub_load_31((offset + (i_1 * 16u)));
} }
} }
return arr_1; return arr_1;
} }
Inner tint_symbol_36(uint4 buffer[55], uint offset) { Inner ub_load_36(uint offset) {
const uint scalar_offset_55 = ((offset + 0u)) / 4; const uint scalar_offset_55 = ((offset + 0u)) / 4;
const uint scalar_offset_56 = ((offset + 4u)) / 4; const uint scalar_offset_56 = ((offset + 4u)) / 4;
const uint scalar_offset_bytes = ((offset + 8u)); const uint scalar_offset_bytes = ((offset + 8u));
const uint scalar_offset_index = scalar_offset_bytes / 4; const uint scalar_offset_index = scalar_offset_bytes / 4;
const Inner tint_symbol_38 = {asint(buffer[scalar_offset_55 / 4][scalar_offset_55 % 4]), asfloat(buffer[scalar_offset_56 / 4][scalar_offset_56 % 4]), float16_t(f16tof32(((buffer[scalar_offset_index / 4][scalar_offset_index % 4] >> (scalar_offset_bytes % 4 == 0 ? 0 : 16)) & 0xFFFF)))}; const Inner tint_symbol = {asint(ub[scalar_offset_55 / 4][scalar_offset_55 % 4]), asfloat(ub[scalar_offset_56 / 4][scalar_offset_56 % 4]), float16_t(f16tof32(((ub[scalar_offset_index / 4][scalar_offset_index % 4] >> (scalar_offset_bytes % 4 == 0 ? 0 : 16)) & 0xFFFF)))};
return tint_symbol_38; return tint_symbol;
} }
typedef Inner tint_symbol_37_ret[4]; typedef Inner ub_load_37_ret[4];
tint_symbol_37_ret tint_symbol_37(uint4 buffer[55], uint offset) { ub_load_37_ret ub_load_37(uint offset) {
Inner arr_2[4] = (Inner[4])0; Inner arr_2[4] = (Inner[4])0;
{ {
for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) { for(uint i_2 = 0u; (i_2 < 4u); i_2 = (i_2 + 1u)) {
arr_2[i_2] = tint_symbol_36(buffer, (offset + (i_2 * 16u))); arr_2[i_2] = ub_load_36((offset + (i_2 * 16u)));
} }
} }
return arr_2; return arr_2;
@ -292,27 +292,27 @@ void main() {
vector<float16_t, 2> ubo_load_56_xz = vector<float16_t, 2>(f16tof32(ubo_load_56 & 0xFFFF)); vector<float16_t, 2> ubo_load_56_xz = vector<float16_t, 2>(f16tof32(ubo_load_56 & 0xFFFF));
vector<float16_t, 2> ubo_load_56_yw = vector<float16_t, 2>(f16tof32(ubo_load_56 >> 16)); vector<float16_t, 2> ubo_load_56_yw = vector<float16_t, 2>(f16tof32(ubo_load_56 >> 16));
const vector<float16_t, 4> vec4_f16 = vector<float16_t, 4>(ubo_load_56_xz[0], ubo_load_56_yw[0], ubo_load_56_xz[1], ubo_load_56_yw[1]); const vector<float16_t, 4> vec4_f16 = vector<float16_t, 4>(ubo_load_56_xz[0], ubo_load_56_yw[0], ubo_load_56_xz[1], ubo_load_56_yw[1]);
const float2x2 mat2x2_f32 = tint_symbol_16(ub, 168u); const float2x2 mat2x2_f32 = ub_load_16(168u);
const float2x3 mat2x3_f32 = tint_symbol_17(ub, 192u); const float2x3 mat2x3_f32 = ub_load_17(192u);
const float2x4 mat2x4_f32 = tint_symbol_18(ub, 224u); const float2x4 mat2x4_f32 = ub_load_18(224u);
const float3x2 mat3x2_f32 = tint_symbol_19(ub, 256u); const float3x2 mat3x2_f32 = ub_load_19(256u);
const float3x3 mat3x3_f32 = tint_symbol_20(ub, 288u); const float3x3 mat3x3_f32 = ub_load_20(288u);
const float3x4 mat3x4_f32 = tint_symbol_21(ub, 336u); const float3x4 mat3x4_f32 = ub_load_21(336u);
const float4x2 mat4x2_f32 = tint_symbol_22(ub, 384u); const float4x2 mat4x2_f32 = ub_load_22(384u);
const float4x3 mat4x3_f32 = tint_symbol_23(ub, 416u); const float4x3 mat4x3_f32 = ub_load_23(416u);
const float4x4 mat4x4_f32 = tint_symbol_24(ub, 480u); const float4x4 mat4x4_f32 = ub_load_24(480u);
const matrix<float16_t, 2, 2> mat2x2_f16 = tint_symbol_25(ub, 544u); const matrix<float16_t, 2, 2> mat2x2_f16 = ub_load_25(544u);
const matrix<float16_t, 2, 3> mat2x3_f16 = tint_symbol_26(ub, 552u); const matrix<float16_t, 2, 3> mat2x3_f16 = ub_load_26(552u);
const matrix<float16_t, 2, 4> mat2x4_f16 = tint_symbol_27(ub, 568u); const matrix<float16_t, 2, 4> mat2x4_f16 = ub_load_27(568u);
const matrix<float16_t, 3, 2> mat3x2_f16 = tint_symbol_28(ub, 584u); const matrix<float16_t, 3, 2> mat3x2_f16 = ub_load_28(584u);
const matrix<float16_t, 3, 3> mat3x3_f16 = tint_symbol_29(ub, 600u); const matrix<float16_t, 3, 3> mat3x3_f16 = ub_load_29(600u);
const matrix<float16_t, 3, 4> mat3x4_f16 = tint_symbol_30(ub, 624u); const matrix<float16_t, 3, 4> mat3x4_f16 = ub_load_30(624u);
const matrix<float16_t, 4, 2> mat4x2_f16 = tint_symbol_31(ub, 648u); const matrix<float16_t, 4, 2> mat4x2_f16 = ub_load_31(648u);
const matrix<float16_t, 4, 3> mat4x3_f16 = tint_symbol_32(ub, 664u); const matrix<float16_t, 4, 3> mat4x3_f16 = ub_load_32(664u);
const matrix<float16_t, 4, 4> mat4x4_f16 = tint_symbol_33(ub, 696u); const matrix<float16_t, 4, 4> mat4x4_f16 = ub_load_33(696u);
const float3 arr2_vec3_f32[2] = tint_symbol_34(ub, 736u); const float3 arr2_vec3_f32[2] = ub_load_34(736u);
const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = tint_symbol_35(ub, 768u); const matrix<float16_t, 4, 2> arr2_mat4x2_f16[2] = ub_load_35(768u);
const Inner struct_inner = tint_symbol_36(ub, 800u); const Inner struct_inner = ub_load_36(800u);
const Inner array_struct_inner[4] = tint_symbol_37(ub, 816u); const Inner array_struct_inner[4] = ub_load_37(816u);
return; return;
} }

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -8,20 +8,20 @@ int i() {
return counter; return counter;
} }
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = a[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = a[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_1(buffer, (offset + (i_1 * 16u))); arr[i_1] = a_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -31,8 +31,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
void f() { void f() {
const int p_a_i_save = i(); const int p_a_i_save = i();
const int p_a_i_i_save = i(); const int p_a_i_i_save = i();
const float2x2 l_a[4] = tint_symbol(a, 0u); const float2x2 l_a[4] = a_load(0u);
const float2x2 l_a_i = tint_symbol_1(a, (16u * uint(p_a_i_save))); const float2x2 l_a_i = a_load_1((16u * uint(p_a_i_save)));
const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4; const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4;
uint4 ubo_load_2 = a[scalar_offset_2 / 4]; uint4 ubo_load_2 = a[scalar_offset_2 / 4];
const float2 l_a_i_i = asfloat(((scalar_offset_2 & 2) ? ubo_load_2.zw : ubo_load_2.xy)); const float2 l_a_i_i = asfloat(((scalar_offset_2 & 2) ? ubo_load_2.zw : ubo_load_2.xy));

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.fxc.hlsl
View File

@ -8,20 +8,20 @@ int i() {
return counter; return counter;
} }
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = a[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = a[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_1(buffer, (offset + (i_1 * 16u))); arr[i_1] = a_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -31,8 +31,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
void f() { void f() {
const int p_a_i_save = i(); const int p_a_i_save = i();
const int p_a_i_i_save = i(); const int p_a_i_i_save = i();
const float2x2 l_a[4] = tint_symbol(a, 0u); const float2x2 l_a[4] = a_load(0u);
const float2x2 l_a_i = tint_symbol_1(a, (16u * uint(p_a_i_save))); const float2x2 l_a_i = a_load_1((16u * uint(p_a_i_save)));
const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4; const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4;
uint4 ubo_load_2 = a[scalar_offset_2 / 4]; uint4 ubo_load_2 = a[scalar_offset_2 / 4];
const float2 l_a_i_i = asfloat(((scalar_offset_2 & 2) ? ubo_load_2.zw : ubo_load_2.xy)); const float2 l_a_i_i = asfloat(((scalar_offset_2 & 2) ? ubo_load_2.zw : ubo_load_2.xy));

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/static_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -2,20 +2,20 @@ cbuffer cbuffer_a : register(b0, space0) {
uint4 a[4]; uint4 a[4];
}; };
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = a[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = a[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = a_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -23,8 +23,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x2 l_a[4] = tint_symbol(a, 0u); const float2x2 l_a[4] = a_load(0u);
const float2x2 l_a_i = tint_symbol_1(a, 32u); const float2x2 l_a_i = a_load_1(32u);
const float2 l_a_i_i = asfloat(a[2].zw); const float2 l_a_i_i = asfloat(a[2].zw);
return; return;
} }

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/static_index_via_ptr.wgsl.expected.fxc.hlsl
View File

@ -2,20 +2,20 @@ cbuffer cbuffer_a : register(b0, space0) {
uint4 a[4]; uint4 a[4];
}; };
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = a[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = a[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = a_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -23,8 +23,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x2 l_a[4] = tint_symbol(a, 0u); const float2x2 l_a[4] = a_load(0u);
const float2x2 l_a_i = tint_symbol_1(a, 32u); const float2x2 l_a_i = a_load_1(32u);
const float2 l_a_i_i = asfloat(a[2].zw); const float2 l_a_i_i = asfloat(a[2].zw);
return; return;
} }

8
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_builtin.wgsl.expected.dxc.hlsl
View File

@ -2,17 +2,17 @@ cbuffer cbuffer_u : register(b0, space0) {
uint4 u[4]; uint4 u[4];
}; };
float2x2 tint_symbol(uint4 buffer[4], uint offset) { float2x2 u_load(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x2 t = transpose(tint_symbol(u, 32u)); const float2x2 t = transpose(u_load(32u));
const float l = length(asfloat(u[0].zw).yx); const float l = length(asfloat(u[0].zw).yx);
const float a = abs(asfloat(u[0].zw).yx.x); const float a = abs(asfloat(u[0].zw).yx.x);
return; return;

8
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_builtin.wgsl.expected.fxc.hlsl
View File

@ -2,17 +2,17 @@ cbuffer cbuffer_u : register(b0, space0) {
uint4 u[4]; uint4 u[4];
}; };
float2x2 tint_symbol(uint4 buffer[4], uint offset) { float2x2 u_load(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x2 t = transpose(tint_symbol(u, 32u)); const float2x2 t = transpose(u_load(32u));
const float l = length(asfloat(u[0].zw).yx); const float l = length(asfloat(u[0].zw).yx);
const float a = abs(asfloat(u[0].zw).yx.x); const float a = abs(asfloat(u[0].zw).yx.x);
return; return;

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_fn.wgsl.expected.dxc.hlsl
View File

@ -14,20 +14,20 @@ void c(float2 v) {
void d(float f_1) { void d(float f_1) {
} }
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -35,8 +35,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
a(tint_symbol(u, 0u)); a(u_load(0u));
b(tint_symbol_1(u, 16u)); b(u_load_1(16u));
c(asfloat(u[1].xy).yx); c(asfloat(u[1].xy).yx);
d(asfloat(u[1].xy).yx.x); d(asfloat(u[1].xy).yx.x);
return; return;

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_fn.wgsl.expected.fxc.hlsl
View File

@ -14,20 +14,20 @@ void c(float2 v) {
void d(float f_1) { void d(float f_1) {
} }
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -35,8 +35,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
a(tint_symbol(u, 0u)); a(u_load(0u));
b(tint_symbol_1(u, 16u)); b(u_load_1(16u));
c(asfloat(u[1].xy).yx); c(asfloat(u[1].xy).yx);
d(asfloat(u[1].xy).yx.x); d(asfloat(u[1].xy).yx.x);
return; return;

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_private.wgsl.expected.dxc.hlsl
View File

@ -3,20 +3,20 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
static float2x2 p[4] = (float2x2[4])0; static float2x2 p[4] = (float2x2[4])0;
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -24,8 +24,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
p = tint_symbol(u, 0u); p = u_load(0u);
p[1] = tint_symbol_1(u, 32u); p[1] = u_load_1(32u);
p[1][0] = asfloat(u[0].zw).yx; p[1][0] = asfloat(u[0].zw).yx;
p[1][0].x = asfloat(u[0].z); p[1][0].x = asfloat(u[0].z);
return; return;

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_private.wgsl.expected.fxc.hlsl
View File

@ -3,20 +3,20 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
static float2x2 p[4] = (float2x2[4])0; static float2x2 p[4] = (float2x2[4])0;
float2x2 tint_symbol_1(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -24,8 +24,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
p = tint_symbol(u, 0u); p = u_load(0u);
p[1] = tint_symbol_1(u, 32u); p[1] = u_load_1(32u);
p[1][0] = asfloat(u[0].zw).yx; p[1][0] = asfloat(u[0].zw).yx;
p[1][0].x = asfloat(u[0].z); p[1][0].x = asfloat(u[0].z);
return; return;

26
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_storage.wgsl.expected.dxc.hlsl
View File

@ -3,34 +3,34 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
RWByteAddressBuffer s : register(u1, space0); RWByteAddressBuffer s : register(u1, space0);
void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void s_store_1(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); s.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); s.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol(RWByteAddressBuffer buffer, uint offset, float2x2 value[4]) { void s_store(uint offset, float2x2 value[4]) {
float2x2 array_1[4] = value; float2x2 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
tint_symbol_1(buffer, (offset + (i * 16u)), array_1[i]); s_store_1((offset + (i * 16u)), array_1[i]);
} }
} }
} }
float2x2 tint_symbol_4(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_3_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_4(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -38,8 +38,8 @@ tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
tint_symbol(s, 0u, tint_symbol_3(u, 0u)); s_store(0u, u_load(0u));
tint_symbol_1(s, 16u, tint_symbol_4(u, 32u)); s_store_1(16u, u_load_1(32u));
s.Store2(16u, asuint(asfloat(u[0].zw).yx)); s.Store2(16u, asuint(asfloat(u[0].zw).yx));
s.Store(16u, asuint(asfloat(u[0].z))); s.Store(16u, asuint(asfloat(u[0].z)));
return; return;

26
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_storage.wgsl.expected.fxc.hlsl
View File

@ -3,34 +3,34 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
RWByteAddressBuffer s : register(u1, space0); RWByteAddressBuffer s : register(u1, space0);
void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, float2x2 value) { void s_store_1(uint offset, float2x2 value) {
buffer.Store2((offset + 0u), asuint(value[0u])); s.Store2((offset + 0u), asuint(value[0u]));
buffer.Store2((offset + 8u), asuint(value[1u])); s.Store2((offset + 8u), asuint(value[1u]));
} }
void tint_symbol(RWByteAddressBuffer buffer, uint offset, float2x2 value[4]) { void s_store(uint offset, float2x2 value[4]) {
float2x2 array_1[4] = value; float2x2 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
tint_symbol_1(buffer, (offset + (i * 16u)), array_1[i]); s_store_1((offset + (i * 16u)), array_1[i]);
} }
} }
} }
float2x2 tint_symbol_4(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_3_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_4(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -38,8 +38,8 @@ tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
tint_symbol(s, 0u, tint_symbol_3(u, 0u)); s_store(0u, u_load(0u));
tint_symbol_1(s, 16u, tint_symbol_4(u, 32u)); s_store_1(16u, u_load_1(32u));
s.Store2(16u, asuint(asfloat(u[0].zw).yx)); s.Store2(16u, asuint(asfloat(u[0].zw).yx));
s.Store(16u, asuint(asfloat(u[0].z))); s.Store(16u, asuint(asfloat(u[0].z)));
return; return;

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_workgroup.wgsl.expected.dxc.hlsl
View File

@ -7,20 +7,20 @@ struct tint_symbol_1 {
uint local_invocation_index : SV_GroupIndex; uint local_invocation_index : SV_GroupIndex;
}; };
float2x2 tint_symbol_3(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_2_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_3(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -34,8 +34,8 @@ void f_inner(uint local_invocation_index) {
} }
} }
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
w = tint_symbol_2(u, 0u); w = u_load(0u);
w[1] = tint_symbol_3(u, 32u); w[1] = u_load_1(32u);
w[1][0] = asfloat(u[0].zw).yx; w[1][0] = asfloat(u[0].zw).yx;
w[1][0].x = asfloat(u[0].z); w[1][0].x = asfloat(u[0].z);
} }

16
test/tint/buffer/uniform/std140/array/mat2x2_f32/to_workgroup.wgsl.expected.fxc.hlsl
View File

@ -7,20 +7,20 @@ struct tint_symbol_1 {
uint local_invocation_index : SV_GroupIndex; uint local_invocation_index : SV_GroupIndex;
}; };
float2x2 tint_symbol_3(uint4 buffer[4], uint offset) { float2x2 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load = buffer[scalar_offset / 4]; uint4 ubo_load = u[scalar_offset / 4];
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_1 = u[scalar_offset_1 / 4];
return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy))); return float2x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)));
} }
typedef float2x2 tint_symbol_2_ret[4]; typedef float2x2 u_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
float2x2 arr[4] = (float2x2[4])0; float2x2 arr[4] = (float2x2[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_3(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -34,8 +34,8 @@ void f_inner(uint local_invocation_index) {
} }
} }
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
w = tint_symbol_2(u, 0u); w = u_load(0u);
w[1] = tint_symbol_3(u, 32u); w[1] = u_load_1(32u);
w[1][0] = asfloat(u[0].zw).yx; w[1][0] = asfloat(u[0].zw).yx;
w[1][0].x = asfloat(u[0].z); w[1][0].x = asfloat(u[0].z);
} }

16
test/tint/buffer/uniform/std140/array/mat2x3_f16/dynamic_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -8,26 +8,26 @@ int i() {
return counter; return counter;
} }
matrix<float16_t, 2, 3> tint_symbol_1(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = a[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = a[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_ret[4]; typedef matrix<float16_t, 2, 3> a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_1(buffer, (offset + (i_1 * 16u))); arr[i_1] = a_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -37,8 +37,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
void f() { void f() {
const int p_a_i_save = i(); const int p_a_i_save = i();
const int p_a_i_i_save = i(); const int p_a_i_i_save = i();
const matrix<float16_t, 2, 3> l_a[4] = tint_symbol(a, 0u); const matrix<float16_t, 2, 3> l_a[4] = a_load(0u);
const matrix<float16_t, 2, 3> l_a_i = tint_symbol_1(a, (16u * uint(p_a_i_save))); const matrix<float16_t, 2, 3> l_a_i = a_load_1((16u * uint(p_a_i_save)));
const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4; const uint scalar_offset_2 = (((16u * uint(p_a_i_save)) + (8u * uint(p_a_i_i_save)))) / 4;
uint4 ubo_load_5 = a[scalar_offset_2 / 4]; uint4 ubo_load_5 = a[scalar_offset_2 / 4];
uint2 ubo_load_4 = ((scalar_offset_2 & 2) ? ubo_load_5.zw : ubo_load_5.xy); uint2 ubo_load_4 = ((scalar_offset_2 & 2) ? ubo_load_5.zw : ubo_load_5.xy);

16
test/tint/buffer/uniform/std140/array/mat2x3_f16/static_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -2,26 +2,26 @@ cbuffer cbuffer_a : register(b0, space0) {
uint4 a[4]; uint4 a[4];
}; };
matrix<float16_t, 2, 3> tint_symbol_1(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = a[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = a[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_ret[4]; typedef matrix<float16_t, 2, 3> a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { a_load_ret a_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = a_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -29,8 +29,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const matrix<float16_t, 2, 3> l_a[4] = tint_symbol(a, 0u); const matrix<float16_t, 2, 3> l_a[4] = a_load(0u);
const matrix<float16_t, 2, 3> l_a_i = tint_symbol_1(a, 32u); const matrix<float16_t, 2, 3> l_a_i = a_load_1(32u);
uint2 ubo_load_4 = a[2].zw; uint2 ubo_load_4 = a[2].zw;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

8
test/tint/buffer/uniform/std140/array/mat2x3_f16/to_builtin.wgsl.expected.dxc.hlsl
View File

@ -2,14 +2,14 @@ cbuffer cbuffer_u : register(b0, space0) {
uint4 u[4]; uint4 u[4];
}; };
matrix<float16_t, 2, 3> tint_symbol(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> u_load(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = u[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = u[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
@ -18,7 +18,7 @@ matrix<float16_t, 2, 3> tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const matrix<float16_t, 3, 2> t = transpose(tint_symbol(u, 32u)); const matrix<float16_t, 3, 2> t = transpose(u_load(32u));
uint2 ubo_load_4 = u[0].zw; uint2 ubo_load_4 = u[0].zw;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

16
test/tint/buffer/uniform/std140/array/mat2x3_f16/to_fn.wgsl.expected.dxc.hlsl
View File

@ -14,26 +14,26 @@ void c(vector<float16_t, 3> v) {
void d(float16_t f_1) { void d(float16_t f_1) {
} }
matrix<float16_t, 2, 3> tint_symbol_1(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = u[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = u[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_ret[4]; typedef matrix<float16_t, 2, 3> u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -41,8 +41,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
a(tint_symbol(u, 0u)); a(u_load(0u));
b(tint_symbol_1(u, 16u)); b(u_load_1(16u));
uint2 ubo_load_4 = u[1].xy; uint2 ubo_load_4 = u[1].xy;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

16
test/tint/buffer/uniform/std140/array/mat2x3_f16/to_private.wgsl.expected.dxc.hlsl
View File

@ -3,26 +3,26 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
static matrix<float16_t, 2, 3> p[4] = (matrix<float16_t, 2, 3>[4])0; static matrix<float16_t, 2, 3> p[4] = (matrix<float16_t, 2, 3>[4])0;
matrix<float16_t, 2, 3> tint_symbol_1(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = u[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = u[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_ret[4]; typedef matrix<float16_t, 2, 3> u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 16u))); arr[i] = u_load_1((offset + (i * 16u)));
} }
} }
return arr; return arr;
@ -30,8 +30,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
p = tint_symbol(u, 0u); p = u_load(0u);
p[1] = tint_symbol_1(u, 32u); p[1] = u_load_1(32u);
uint2 ubo_load_4 = u[0].zw; uint2 ubo_load_4 = u[0].zw;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

26
test/tint/buffer/uniform/std140/array/mat2x3_f16/to_storage.wgsl.expected.dxc.hlsl
View File

@ -3,40 +3,40 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
RWByteAddressBuffer s : register(u1, space0); RWByteAddressBuffer s : register(u1, space0);
void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 3> value) { void s_store_1(uint offset, matrix<float16_t, 2, 3> value) {
buffer.Store<vector<float16_t, 3> >((offset + 0u), value[0u]); s.Store<vector<float16_t, 3> >((offset + 0u), value[0u]);
buffer.Store<vector<float16_t, 3> >((offset + 8u), value[1u]); s.Store<vector<float16_t, 3> >((offset + 8u), value[1u]);
} }
void tint_symbol(RWByteAddressBuffer buffer, uint offset, matrix<float16_t, 2, 3> value[4]) { void s_store(uint offset, matrix<float16_t, 2, 3> value[4]) {
matrix<float16_t, 2, 3> array_1[4] = value; matrix<float16_t, 2, 3> array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
tint_symbol_1(buffer, (offset + (i * 16u)), array_1[i]); s_store_1((offset + (i * 16u)), array_1[i]);
} }
} }
} }
matrix<float16_t, 2, 3> tint_symbol_4(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = u[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = u[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_3_ret[4]; typedef matrix<float16_t, 2, 3> u_load_ret[4];
tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_4(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -44,8 +44,8 @@ tint_symbol_3_ret tint_symbol_3(uint4 buffer[4], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
tint_symbol(s, 0u, tint_symbol_3(u, 0u)); s_store(0u, u_load(0u));
tint_symbol_1(s, 16u, tint_symbol_4(u, 32u)); s_store_1(16u, u_load_1(32u));
uint2 ubo_load_4 = u[0].zw; uint2 ubo_load_4 = u[0].zw;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

16
test/tint/buffer/uniform/std140/array/mat2x3_f16/to_workgroup.wgsl.expected.dxc.hlsl
View File

@ -7,26 +7,26 @@ struct tint_symbol_1 {
uint local_invocation_index : SV_GroupIndex; uint local_invocation_index : SV_GroupIndex;
}; };
matrix<float16_t, 2, 3> tint_symbol_3(uint4 buffer[4], uint offset) { matrix<float16_t, 2, 3> u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
uint4 ubo_load_1 = buffer[scalar_offset / 4]; uint4 ubo_load_1 = u[scalar_offset / 4];
uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy); uint2 ubo_load = ((scalar_offset & 2) ? ubo_load_1.zw : ubo_load_1.xy);
vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF)); vector<float16_t, 2> ubo_load_xz = vector<float16_t, 2>(f16tof32(ubo_load & 0xFFFF));
float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16); float16_t ubo_load_y = f16tof32(ubo_load[0] >> 16);
const uint scalar_offset_1 = ((offset + 8u)) / 4; const uint scalar_offset_1 = ((offset + 8u)) / 4;
uint4 ubo_load_3 = buffer[scalar_offset_1 / 4]; uint4 ubo_load_3 = u[scalar_offset_1 / 4];
uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy); uint2 ubo_load_2 = ((scalar_offset_1 & 2) ? ubo_load_3.zw : ubo_load_3.xy);
vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF)); vector<float16_t, 2> ubo_load_2_xz = vector<float16_t, 2>(f16tof32(ubo_load_2 & 0xFFFF));
float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16); float16_t ubo_load_2_y = f16tof32(ubo_load_2[0] >> 16);
return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1])); return matrix<float16_t, 2, 3>(vector<float16_t, 3>(ubo_load_xz[0], ubo_load_y, ubo_load_xz[1]), vector<float16_t, 3>(ubo_load_2_xz[0], ubo_load_2_y, ubo_load_2_xz[1]));
} }
typedef matrix<float16_t, 2, 3> tint_symbol_2_ret[4]; typedef matrix<float16_t, 2, 3> u_load_ret[4];
tint_symbol_2_ret tint_symbol_2(uint4 buffer[4], uint offset) { u_load_ret u_load(uint offset) {
matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0; matrix<float16_t, 2, 3> arr[4] = (matrix<float16_t, 2, 3>[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_3(buffer, (offset + (i_1 * 16u))); arr[i_1] = u_load_1((offset + (i_1 * 16u)));
} }
} }
return arr; return arr;
@ -40,8 +40,8 @@ void f_inner(uint local_invocation_index) {
} }
} }
GroupMemoryBarrierWithGroupSync(); GroupMemoryBarrierWithGroupSync();
w = tint_symbol_2(u, 0u); w = u_load(0u);
w[1] = tint_symbol_3(u, 32u); w[1] = u_load_1(32u);
uint2 ubo_load_4 = u[0].zw; uint2 ubo_load_4 = u[0].zw;
vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF)); vector<float16_t, 2> ubo_load_4_xz = vector<float16_t, 2>(f16tof32(ubo_load_4 & 0xFFFF));
float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16); float16_t ubo_load_4_y = f16tof32(ubo_load_4[0] >> 16);

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -8,18 +8,18 @@ int i() {
return counter; return counter;
} }
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(a[scalar_offset / 4].xyz), asfloat(a[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { a_load_ret a_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_1(buffer, (offset + (i_1 * 32u))); arr[i_1] = a_load_1((offset + (i_1 * 32u)));
} }
} }
return arr; return arr;
@ -29,8 +29,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
void f() { void f() {
const int p_a_i_save = i(); const int p_a_i_save = i();
const int p_a_i_i_save = i(); const int p_a_i_i_save = i();
const float2x3 l_a[4] = tint_symbol(a, 0u); const float2x3 l_a[4] = a_load(0u);
const float2x3 l_a_i = tint_symbol_1(a, (32u * uint(p_a_i_save))); const float2x3 l_a_i = a_load_1((32u * uint(p_a_i_save)));
const uint scalar_offset_2 = (((32u * uint(p_a_i_save)) + (16u * uint(p_a_i_i_save)))) / 4; const uint scalar_offset_2 = (((32u * uint(p_a_i_save)) + (16u * uint(p_a_i_i_save)))) / 4;
const float3 l_a_i_i = asfloat(a[scalar_offset_2 / 4].xyz); const float3 l_a_i_i = asfloat(a[scalar_offset_2 / 4].xyz);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.fxc.hlsl
View File

@ -8,18 +8,18 @@ int i() {
return counter; return counter;
} }
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(a[scalar_offset / 4].xyz), asfloat(a[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { a_load_ret a_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_1(buffer, (offset + (i_1 * 32u))); arr[i_1] = a_load_1((offset + (i_1 * 32u)));
} }
} }
return arr; return arr;
@ -29,8 +29,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
void f() { void f() {
const int p_a_i_save = i(); const int p_a_i_save = i();
const int p_a_i_i_save = i(); const int p_a_i_i_save = i();
const float2x3 l_a[4] = tint_symbol(a, 0u); const float2x3 l_a[4] = a_load(0u);
const float2x3 l_a_i = tint_symbol_1(a, (32u * uint(p_a_i_save))); const float2x3 l_a_i = a_load_1((32u * uint(p_a_i_save)));
const uint scalar_offset_2 = (((32u * uint(p_a_i_save)) + (16u * uint(p_a_i_i_save)))) / 4; const uint scalar_offset_2 = (((32u * uint(p_a_i_save)) + (16u * uint(p_a_i_i_save)))) / 4;
const float3 l_a_i_i = asfloat(a[scalar_offset_2 / 4].xyz); const float3 l_a_i_i = asfloat(a[scalar_offset_2 / 4].xyz);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/static_index_via_ptr.wgsl.expected.dxc.hlsl
View File

@ -2,18 +2,18 @@ cbuffer cbuffer_a : register(b0, space0) {
uint4 a[8]; uint4 a[8];
}; };
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(a[scalar_offset / 4].xyz), asfloat(a[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { a_load_ret a_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = a_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -21,8 +21,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x3 l_a[4] = tint_symbol(a, 0u); const float2x3 l_a[4] = a_load(0u);
const float2x3 l_a_i = tint_symbol_1(a, 64u); const float2x3 l_a_i = a_load_1(64u);
const float3 l_a_i_i = asfloat(a[5].xyz); const float3 l_a_i_i = asfloat(a[5].xyz);
return; return;
} }

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/static_index_via_ptr.wgsl.expected.fxc.hlsl
View File

@ -2,18 +2,18 @@ cbuffer cbuffer_a : register(b0, space0) {
uint4 a[8]; uint4 a[8];
}; };
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 a_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(a[scalar_offset / 4].xyz), asfloat(a[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 a_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { a_load_ret a_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = a_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -21,8 +21,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float2x3 l_a[4] = tint_symbol(a, 0u); const float2x3 l_a[4] = a_load(0u);
const float2x3 l_a_i = tint_symbol_1(a, 64u); const float2x3 l_a_i = a_load_1(64u);
const float3 l_a_i_i = asfloat(a[5].xyz); const float3 l_a_i_i = asfloat(a[5].xyz);
return; return;
} }

6
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_builtin.wgsl.expected.dxc.hlsl
View File

@ -2,15 +2,15 @@ cbuffer cbuffer_u : register(b0, space0) {
uint4 u[8]; uint4 u[8];
}; };
float2x3 tint_symbol(uint4 buffer[8], uint offset) { float2x3 u_load(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float3x2 t = transpose(tint_symbol(u, 64u)); const float3x2 t = transpose(u_load(64u));
const float l = length(asfloat(u[1].xyz).zxy); const float l = length(asfloat(u[1].xyz).zxy);
const float a = abs(asfloat(u[1].xyz).zxy.x); const float a = abs(asfloat(u[1].xyz).zxy.x);
return; return;

6
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_builtin.wgsl.expected.fxc.hlsl
View File

@ -2,15 +2,15 @@ cbuffer cbuffer_u : register(b0, space0) {
uint4 u[8]; uint4 u[8];
}; };
float2x3 tint_symbol(uint4 buffer[8], uint offset) { float2x3 u_load(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float3x2 t = transpose(tint_symbol(u, 64u)); const float3x2 t = transpose(u_load(64u));
const float l = length(asfloat(u[1].xyz).zxy); const float l = length(asfloat(u[1].xyz).zxy);
const float a = abs(asfloat(u[1].xyz).zxy.x); const float a = abs(asfloat(u[1].xyz).zxy.x);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_fn.wgsl.expected.dxc.hlsl
View File

@ -14,18 +14,18 @@ void c(float3 v) {
void d(float f_1) { void d(float f_1) {
} }
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = u_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -33,8 +33,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
a(tint_symbol(u, 0u)); a(u_load(0u));
b(tint_symbol_1(u, 32u)); b(u_load_1(32u));
c(asfloat(u[2].xyz).zxy); c(asfloat(u[2].xyz).zxy);
d(asfloat(u[2].xyz).zxy.x); d(asfloat(u[2].xyz).zxy.x);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_fn.wgsl.expected.fxc.hlsl
View File

@ -14,18 +14,18 @@ void c(float3 v) {
void d(float f_1) { void d(float f_1) {
} }
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = u_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -33,8 +33,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
a(tint_symbol(u, 0u)); a(u_load(0u));
b(tint_symbol_1(u, 32u)); b(u_load_1(32u));
c(asfloat(u[2].xyz).zxy); c(asfloat(u[2].xyz).zxy);
d(asfloat(u[2].xyz).zxy.x); d(asfloat(u[2].xyz).zxy.x);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_private.wgsl.expected.dxc.hlsl
View File

@ -3,18 +3,18 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
static float2x3 p[4] = (float2x3[4])0; static float2x3 p[4] = (float2x3[4])0;
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = u_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -22,8 +22,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
p = tint_symbol(u, 0u); p = u_load(0u);
p[1] = tint_symbol_1(u, 64u); p[1] = u_load_1(64u);
p[1][0] = asfloat(u[1].xyz).zxy; p[1][0] = asfloat(u[1].xyz).zxy;
p[1][0].x = asfloat(u[1].x); p[1][0].x = asfloat(u[1].x);
return; return;

14
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_private.wgsl.expected.fxc.hlsl
View File

@ -3,18 +3,18 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
static float2x3 p[4] = (float2x3[4])0; static float2x3 p[4] = (float2x3[4])0;
float2x3 tint_symbol_1(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
arr[i] = tint_symbol_1(buffer, (offset + (i * 32u))); arr[i] = u_load_1((offset + (i * 32u)));
} }
} }
return arr; return arr;
@ -22,8 +22,8 @@ tint_symbol_ret tint_symbol(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
p = tint_symbol(u, 0u); p = u_load(0u);
p[1] = tint_symbol_1(u, 64u); p[1] = u_load_1(64u);
p[1][0] = asfloat(u[1].xyz).zxy; p[1][0] = asfloat(u[1].xyz).zxy;
p[1][0].x = asfloat(u[1].x); p[1][0].x = asfloat(u[1].x);
return; return;

24
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_storage.wgsl.expected.dxc.hlsl
View File

@ -3,32 +3,32 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
RWByteAddressBuffer s : register(u1, space0); RWByteAddressBuffer s : register(u1, space0);
void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void s_store_1(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); s.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); s.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol(RWByteAddressBuffer buffer, uint offset, float2x3 value[4]) { void s_store(uint offset, float2x3 value[4]) {
float2x3 array_1[4] = value; float2x3 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
tint_symbol_1(buffer, (offset + (i * 32u)), array_1[i]); s_store_1((offset + (i * 32u)), array_1[i]);
} }
} }
} }
float2x3 tint_symbol_4(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_3_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_3_ret tint_symbol_3(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_4(buffer, (offset + (i_1 * 32u))); arr[i_1] = u_load_1((offset + (i_1 * 32u)));
} }
} }
return arr; return arr;
@ -36,8 +36,8 @@ tint_symbol_3_ret tint_symbol_3(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
tint_symbol(s, 0u, tint_symbol_3(u, 0u)); s_store(0u, u_load(0u));
tint_symbol_1(s, 32u, tint_symbol_4(u, 64u)); s_store_1(32u, u_load_1(64u));
s.Store3(32u, asuint(asfloat(u[1].xyz).zxy)); s.Store3(32u, asuint(asfloat(u[1].xyz).zxy));
s.Store(32u, asuint(asfloat(u[1].x))); s.Store(32u, asuint(asfloat(u[1].x)));
return; return;

24
test/tint/buffer/uniform/std140/array/mat2x3_f32/to_storage.wgsl.expected.fxc.hlsl
View File

@ -3,32 +3,32 @@ cbuffer cbuffer_u : register(b0, space0) {
}; };
RWByteAddressBuffer s : register(u1, space0); RWByteAddressBuffer s : register(u1, space0);
void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, float2x3 value) { void s_store_1(uint offset, float2x3 value) {
buffer.Store3((offset + 0u), asuint(value[0u])); s.Store3((offset + 0u), asuint(value[0u]));
buffer.Store3((offset + 16u), asuint(value[1u])); s.Store3((offset + 16u), asuint(value[1u]));
} }
void tint_symbol(RWByteAddressBuffer buffer, uint offset, float2x3 value[4]) { void s_store(uint offset, float2x3 value[4]) {
float2x3 array_1[4] = value; float2x3 array_1[4] = value;
{ {
for(uint i = 0u; (i < 4u); i = (i + 1u)) { for(uint i = 0u; (i < 4u); i = (i + 1u)) {
tint_symbol_1(buffer, (offset + (i * 32u)), array_1[i]); s_store_1((offset + (i * 32u)), array_1[i]);
} }
} }
} }
float2x3 tint_symbol_4(uint4 buffer[8], uint offset) { float2x3 u_load_1(uint offset) {
const uint scalar_offset = ((offset + 0u)) / 4; const uint scalar_offset = ((offset + 0u)) / 4;
const uint scalar_offset_1 = ((offset + 16u)) / 4; const uint scalar_offset_1 = ((offset + 16u)) / 4;
return float2x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz)); return float2x3(asfloat(u[scalar_offset / 4].xyz), asfloat(u[scalar_offset_1 / 4].xyz));
} }
typedef float2x3 tint_symbol_3_ret[4]; typedef float2x3 u_load_ret[4];
tint_symbol_3_ret tint_symbol_3(uint4 buffer[8], uint offset) { u_load_ret u_load(uint offset) {
float2x3 arr[4] = (float2x3[4])0; float2x3 arr[4] = (float2x3[4])0;
{ {
for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) { for(uint i_1 = 0u; (i_1 < 4u); i_1 = (i_1 + 1u)) {
arr[i_1] = tint_symbol_4(buffer, (offset + (i_1 * 32u))); arr[i_1] = u_load_1((offset + (i_1 * 32u)));
} }
} }
return arr; return arr;
@ -36,8 +36,8 @@ tint_symbol_3_ret tint_symbol_3(uint4 buffer[8], uint offset) {
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
tint_symbol(s, 0u, tint_symbol_3(u, 0u)); s_store(0u, u_load(0u));
tint_symbol_1(s, 32u, tint_symbol_4(u, 64u)); s_store_1(32u, u_load_1(64u));
s.Store3(32u, asuint(asfloat(u[1].xyz).zxy)); s.Store3(32u, asuint(asfloat(u[1].xyz).zxy));
s.Store(32u, asuint(asfloat(u[1].x))); s.Store(32u, asuint(asfloat(u[1].x)));
return; return;

Some files were not shown because too many files have changed in this diff Show More