HLSL-IR: ReplaceNonIndexableMatVecStores transform
FXC workaround for cases of stores to dynamically-indexed shader-local
matrices and vectors.
Bug: 368355095
Change-Id: Ie4c61ff69e7cf7db1880ea8813ec04ab01352638
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/209755
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
Reviewed-by: James Price <jrprice@google.com>
diff --git a/src/tint/lang/hlsl/writer/raise/BUILD.bazel b/src/tint/lang/hlsl/writer/raise/BUILD.bazel
index ba70b5f..46be924 100644
--- a/src/tint/lang/hlsl/writer/raise/BUILD.bazel
+++ b/src/tint/lang/hlsl/writer/raise/BUILD.bazel
@@ -47,6 +47,7 @@
"localize_struct_array_assignment.cc",
"promote_initializers.cc",
"raise.cc",
+ "replace_non_indexable_mat_vec_stores.cc",
"shader_io.cc",
],
hdrs = [
@@ -58,6 +59,7 @@
"localize_struct_array_assignment.h",
"promote_initializers.h",
"raise.h",
+ "replace_non_indexable_mat_vec_stores.h",
"shader_io.h",
],
deps = [
@@ -103,6 +105,7 @@
"fxc_polyfill_test.cc",
"localize_struct_array_assignment_test.cc",
"promote_initializers_test.cc",
+ "replace_non_indexable_mat_vec_stores_test.cc",
"shader_io_test.cc",
],
deps = [
diff --git a/src/tint/lang/hlsl/writer/raise/BUILD.cmake b/src/tint/lang/hlsl/writer/raise/BUILD.cmake
index 814c9fe..9f2515b 100644
--- a/src/tint/lang/hlsl/writer/raise/BUILD.cmake
+++ b/src/tint/lang/hlsl/writer/raise/BUILD.cmake
@@ -55,6 +55,8 @@
lang/hlsl/writer/raise/promote_initializers.h
lang/hlsl/writer/raise/raise.cc
lang/hlsl/writer/raise/raise.h
+ lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.cc
+ lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h
lang/hlsl/writer/raise/shader_io.cc
lang/hlsl/writer/raise/shader_io.h
)
@@ -104,6 +106,7 @@
lang/hlsl/writer/raise/fxc_polyfill_test.cc
lang/hlsl/writer/raise/localize_struct_array_assignment_test.cc
lang/hlsl/writer/raise/promote_initializers_test.cc
+ lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores_test.cc
lang/hlsl/writer/raise/shader_io_test.cc
)
diff --git a/src/tint/lang/hlsl/writer/raise/BUILD.gn b/src/tint/lang/hlsl/writer/raise/BUILD.gn
index 882d21f..48efb8d 100644
--- a/src/tint/lang/hlsl/writer/raise/BUILD.gn
+++ b/src/tint/lang/hlsl/writer/raise/BUILD.gn
@@ -61,6 +61,8 @@
"promote_initializers.h",
"raise.cc",
"raise.h",
+ "replace_non_indexable_mat_vec_stores.cc",
+ "replace_non_indexable_mat_vec_stores.h",
"shader_io.cc",
"shader_io.h",
]
@@ -104,6 +106,7 @@
"fxc_polyfill_test.cc",
"localize_struct_array_assignment_test.cc",
"promote_initializers_test.cc",
+ "replace_non_indexable_mat_vec_stores_test.cc",
"shader_io_test.cc",
]
deps = [
diff --git a/src/tint/lang/hlsl/writer/raise/raise.cc b/src/tint/lang/hlsl/writer/raise/raise.cc
index feecca8..228d1e4 100644
--- a/src/tint/lang/hlsl/writer/raise/raise.cc
+++ b/src/tint/lang/hlsl/writer/raise/raise.cc
@@ -54,6 +54,7 @@
#include "src/tint/lang/hlsl/writer/raise/fxc_polyfill.h"
#include "src/tint/lang/hlsl/writer/raise/localize_struct_array_assignment.h"
#include "src/tint/lang/hlsl/writer/raise/promote_initializers.h"
+#include "src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h"
#include "src/tint/lang/hlsl/writer/raise/shader_io.h"
#include "src/tint/utils/result/result.h"
@@ -138,6 +139,7 @@
if (options.compiler == Options::Compiler::kFXC) {
RUN_TRANSFORM(raise::FxcPolyfill, module);
RUN_TRANSFORM(raise::LocalizeStructArrayAssignment, module);
+ RUN_TRANSFORM(raise::ReplaceNonIndexableMatVecStores, module);
}
if (!options.disable_robustness) {
diff --git a/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.cc b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.cc
new file mode 100644
index 0000000..1cf3f3f
--- /dev/null
+++ b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.cc
@@ -0,0 +1,300 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h"
+
+#include "src/tint/lang/core/ir/builder.h"
+#include "src/tint/lang/core/ir/validator.h"
+#include "src/tint/utils/result/result.h"
+
+namespace tint::hlsl::writer::raise {
+namespace {
+
+using namespace tint::core::fluent_types; // NOLINT
+using namespace tint::core::number_suffixes; // NOLINT
+
+/// PIMPL state for the transform.
+struct State {
+ /// The IR module.
+ core::ir::Module& ir;
+
+ /// The IR builder.
+ core::ir::Builder b{ir};
+
+ /// The type manager.
+ core::type::Manager& ty{ir.Types()};
+
+ const core::type::Type* GetElementType(const core::type::Type* type,
+ const core::ir::Value* idx) {
+ if (auto* constant = idx->As<core::ir::Constant>()) {
+ auto i = constant->Value()->ValueAs<u32>();
+ return type->Element(i);
+ }
+ return type->Elements().type;
+ }
+
+ bool IsConstant(core::ir::Value* value) {
+ if (value->Is<core::ir::Constant>()) {
+ return true;
+ }
+ // Also check for lets to constant, which is a common use-case
+ if (auto* result = value->As<core::ir::InstructionResult>()) {
+ if (auto* let = result->Instruction()->As<core::ir::Let>()) {
+ if (let->Value()->Is<core::ir::Constant>()) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ // If the input access chain is a dynamic index to a matrix, this function will replace the
+ // input store (either a Store or a StoreVectorElement) with a switch statement over the
+ // dynamic index, with a case for each column index used to index the matrix directly.
+ // Returns a vector of the new Store/StoreVectorElements that were created in each case block.
+ // NOTE: `store` may be destroyed
+ Vector<core::ir::Instruction*, 4> ProcessMatrixColumnAccess(core::ir::Instruction* store,
+ core::ir::Access* const to_access) {
+ // Look for a dynamically indexed matrix through the access chain.
+ // This will always be the last index in the chain.
+
+ // The last index must be dynamic
+ if (IsConstant(to_access->Indices().Back())) {
+ return {};
+ }
+ // Get the root object type
+ const auto* object_ty = to_access->Object()->Type()->As<core::type::Pointer>()->StoreType();
+ const auto indicesButLast =
+ to_access->Indices().Truncate(to_access->Indices().Length() - 1);
+ for (auto* idx : indicesButLast) {
+ object_ty = GetElementType(object_ty, idx);
+ }
+ // It must be a matrix
+ const auto* mat_ty = object_ty->As<core::type::Matrix>();
+ if (!mat_ty) {
+ return {};
+ }
+
+ core::ir::Value* const to = Switch(
+ store, //
+ [&](core::ir::Store* s) { return s->To(); }, //
+ [&](core::ir::StoreVectorElement* s) { return s->To(); }, //
+ TINT_ICE_ON_NO_MATCH);
+
+ auto* const to_ptr = to->Type()->As<core::type::Pointer>();
+
+ // Instead of indexing the matrix dynamically, we want to replace it with a switch statement
+ // over the dynamic index, with each case in [0-3] emitting the store with a constant index.
+ Vector<core::ir::Instruction*, 4> new_stores;
+
+ b.InsertBefore(store, [&] {
+ // Create access to the matrix we're dynamically indexing
+ core::ir::Value* matrix = to_access->Object();
+ if (!indicesButLast.IsEmpty()) {
+ // Matrix is in a struct or array, for example
+ matrix = b.Access(ty.ptr(to_ptr->AddressSpace(), mat_ty), to_access->Object(),
+ ToVector<4>(indicesButLast))
+ ->Result(0);
+ }
+ // Switch over dynamic index, emitting a case for all possible column indices
+ auto* switch_ = b.Switch(to_access->Indices().Back());
+ for (uint32_t i = 0; i < mat_ty->Columns(); ++i) {
+ b.Append(b.Case(switch_, {b.Constant(u32(i))}), [&] {
+ auto* const vec_ty = to_ptr->StoreType();
+ auto* access = b.Access(ty.ptr(to_ptr->AddressSpace(), vec_ty), matrix, u32(i));
+ auto* new_store = Switch(
+ store,
+ [&](core::ir::Store* s) { //
+ return b.Store(access, s->From());
+ },
+ [&](core::ir::StoreVectorElement* s) {
+ return b.StoreVectorElement(access, s->Index(), s->Value());
+ },
+ TINT_ICE_ON_NO_MATCH);
+ new_stores.Push(new_store);
+ b.ExitSwitch(switch_);
+ });
+ }
+ b.Append(b.DefaultCase(switch_), [&] { b.ExitSwitch(switch_); });
+
+ store->Destroy();
+ });
+ TINT_ASSERT(!new_stores.IsEmpty());
+ return new_stores;
+ }
+
+ // Process store to matrix column
+ void ProcessStore(core::ir::Store* store) {
+ // Must be storing to a shader-local variable
+ auto* to_ptr = store->To()->Type()->As<core::type::Pointer>();
+ if (to_ptr->AddressSpace() != core::AddressSpace::kFunction &&
+ to_ptr->AddressSpace() != core::AddressSpace::kPrivate) {
+ return;
+ }
+ // Must be storing a vector
+ if (!to_ptr->StoreType()->Is<core::type::Vector>()) {
+ return;
+ }
+ // Must be storing via an access
+ auto* to = store->To()->As<core::ir::InstructionResult>();
+ if (!to) {
+ return;
+ }
+ auto* to_access = to->Instruction()->As<core::ir::Access>();
+ if (!to_access) {
+ return;
+ }
+ ProcessMatrixColumnAccess(store, to_access);
+ }
+
+ // Replaces the vector element store with a full vector store that masks in the indexed
+ // value. Example HLSL: vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
+ void ReplaceStoreVectorElement(core::ir::StoreVectorElement* store) {
+ TINT_ASSERT(!IsConstant(store->Index()));
+ auto* to_ptr = store->To()->Type()->As<core::type::Pointer>();
+ TINT_ASSERT(to_ptr);
+
+ b.InsertBefore(store, [&] {
+ auto* vec_param = store->Operands()[0];
+ auto* index_param = store->Operands()[1];
+ auto* value_param = store->Operands()[2];
+
+ auto* vec_ty = to_ptr->StoreType()->As<core::type::Vector>();
+
+ // e.g. "xxx" for vec3
+ Vector<uint32_t, 4> swizzle_indices;
+ swizzle_indices.Resize(vec_ty->Width(), 0);
+
+ // e.g. "0,1,2" for vec3
+ Vector<core::ir::Value*, 4> select_indices;
+ switch (vec_ty->Width()) {
+ case 2:
+ select_indices = b.Values(0_i, 1_i);
+ break;
+ case 3:
+ select_indices = b.Values(0_i, 1_i, 2_i);
+ break;
+ case 4:
+ select_indices = b.Values(0_i, 1_i, 2_i, 3_i);
+ break;
+ }
+
+ auto* false_val = b.Load(vec_param);
+ auto* true_val = b.Swizzle(vec_ty, value_param, swizzle_indices);
+
+ auto* lhs = b.Swizzle(vec_ty, index_param, swizzle_indices);
+ auto* rhs = b.Construct(vec_ty, select_indices);
+ auto* cond = b.Equal(ty.MatchWidth(ty.bool_(), vec_ty), lhs, rhs);
+
+ // NOTE: Using Select means we depend on BuiltinPolyfill to run after this transform. We
+ // could also just emit a Ternary instruction.
+ auto* result = b.Call(vec_ty, core::BuiltinFn::kSelect, false_val, true_val, cond);
+ b.Store(vec_param, result);
+
+ store->Destroy();
+ });
+ }
+
+ // Process store to vector element for both vector and matrix element stores
+ void ProcessStoreVectorElement(core::ir::StoreVectorElement* store) {
+ auto* to_ptr = store->To()->Type()->As<core::type::Pointer>();
+ if (to_ptr->AddressSpace() != core::AddressSpace::kFunction &&
+ to_ptr->AddressSpace() != core::AddressSpace::kPrivate) {
+ return;
+ }
+ auto* to = store->To()->As<core::ir::InstructionResult>();
+ if (!to) {
+ return;
+ }
+
+ const bool is_dynamic_index = !IsConstant(store->Index());
+
+ // This may be a vector store to a dynamically indexed matrix
+ if (auto* to_access = to->Instruction()->As<core::ir::Access>()) {
+ auto new_stores = ProcessMatrixColumnAccess(store, to_access);
+ if (!new_stores.IsEmpty() && is_dynamic_index) {
+ // The dynamic matrix index has been replaced by a switch with cases containing
+ // multiple StoreVectorElement copies of the input one to this function. If
+ // dynamically indexed, replace each of the new stores and return.
+ for (auto* s : new_stores) {
+ ReplaceStoreVectorElement(s->As<core::ir::StoreVectorElement>());
+ }
+ return;
+ }
+ }
+
+ // If the index is dynamic, replace
+ if (is_dynamic_index) {
+ ReplaceStoreVectorElement(store);
+ }
+ }
+
+ /// Process the module.
+ void Process() {
+ // Collect stores before processing them
+ Vector<core::ir::Store*, 16> stores;
+ Vector<core::ir::StoreVectorElement*, 16> store_vec_elems;
+ for (auto* inst : ir.Instructions()) {
+ // Inline pointers
+ if (auto* l = inst->As<core::ir::Let>()) {
+ if (l->Result(0)->Type()->Is<core::type::Pointer>()) {
+ l->Result(0)->ReplaceAllUsesWith(l->Value());
+ l->Destroy();
+ }
+ }
+
+ if (auto* store = inst->As<core::ir::Store>()) {
+ stores.Push(store);
+ } else if (auto* vector_store = inst->As<core::ir::StoreVectorElement>()) {
+ store_vec_elems.Push(vector_store);
+ }
+ }
+
+ // Process the stores
+ for (auto* store : stores) {
+ ProcessStore(store);
+ }
+ for (auto* store : store_vec_elems) {
+ ProcessStoreVectorElement(store);
+ }
+ }
+};
+
+} // namespace
+
+Result<SuccessType> ReplaceNonIndexableMatVecStores(core::ir::Module& ir) {
+ auto result = ValidateAndDumpIfNeeded(ir, "ReplaceNonIndexableMatVecStores transform");
+ if (result != Success) {
+ return result.Failure();
+ }
+
+ State{ir}.Process();
+
+ return Success;
+}
+
+} // namespace tint::hlsl::writer::raise
diff --git a/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h
new file mode 100644
index 0000000..d109116
--- /dev/null
+++ b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h
@@ -0,0 +1,57 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef SRC_TINT_LANG_HLSL_WRITER_RAISE_REPLACE_NON_INDEXABLE_MAT_VEC_STORES_H_
+#define SRC_TINT_LANG_HLSL_WRITER_RAISE_REPLACE_NON_INDEXABLE_MAT_VEC_STORES_H_
+
+#include "src/tint/utils/result/result.h"
+
+// Forward declarations.
+namespace tint::core::ir {
+class Module;
+} // namespace tint::core::ir
+
+namespace tint::hlsl::writer::raise {
+
+/// This transform replaces element stores to dynamically-indexed shader-local matrices or vectors
+/// with full vector stores. This is done to work around FXC's inability to compile in these cases
+/// (see crbug.com/42250349 and crbug.com/42251617).
+///
+/// This transform is similar to LocalizeStructArrayAssignment, but for matrices and vectors. As
+/// with structs of arrays, FXC does not allocate indexable registers to shader-local matrix and
+/// vector variables. For dynamically indexed vectors, we replace the indexed element store with
+/// a full vector store using a selection mask. For dynamically indexed matrices, we replace the
+/// indexed matrix store with a switch over the index, and emit a case for each column that sets the
+/// matrix column by constant index.
+
+/// @param module the module to transform
+/// @returns success or failure
+Result<SuccessType> ReplaceNonIndexableMatVecStores(core::ir::Module& module);
+
+} // namespace tint::hlsl::writer::raise
+
+#endif // SRC_TINT_LANG_HLSL_WRITER_RAISE_REPLACE_NON_INDEXABLE_MAT_VEC_STORES_H_
diff --git a/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores_test.cc b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores_test.cc
new file mode 100644
index 0000000..f77e48c
--- /dev/null
+++ b/src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores_test.cc
@@ -0,0 +1,2041 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+// list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/hlsl/writer/raise/replace_non_indexable_mat_vec_stores.h"
+
+#include <gtest/gtest.h>
+
+#include "src/tint/lang/core/fluent_types.h"
+#include "src/tint/lang/core/ir/function.h"
+#include "src/tint/lang/core/ir/transform/helper_test.h"
+#include "src/tint/lang/core/number.h"
+
+using namespace tint::core::fluent_types; // NOLINT
+using namespace tint::core::number_suffixes; // NOLINT
+
+namespace tint::hlsl::writer::raise {
+namespace {
+
+using HlslWriterReplaceNonIndexableMatVecStoresTest = core::ir::transform::TransformTest;
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, Vector) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.vec3<f32>()));
+ b.StoreVectorElement(v, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(v, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %5:u32 = load %dyn_index
+ store_vector_element %v, %5, 1.0f
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %5:u32 = load %dyn_index
+ %6:vec3<f32> = load %v
+ %7:vec3<f32> = swizzle 1.0f, xxx
+ %8:vec3<f32> = swizzle %5, xxx
+ %9:vec3<f32> = construct 0i, 1i, 2i
+ %10:vec3<bool> = eq %8, %9
+ %11:vec3<f32> = select %6, %7, %10
+ store %v, %11
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, VectorInStruct) {
+ auto* vec_ty = ty.vec3<f32>();
+ auto* struct_ty = ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), vec_ty}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* access = b.Access(ty.ptr<function>(vec_ty), v, 0_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:vec3<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:vec3<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u
+ %6:u32 = load %dyn_index
+ %7:vec3<f32> = load %5
+ %8:vec3<f32> = swizzle 1.0f, xxx
+ %9:vec3<f32> = swizzle %6, xxx
+ %10:vec3<f32> = construct 0i, 1i, 2i
+ %11:vec3<bool> = eq %9, %10
+ %12:vec3<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, VectorInArray) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* vec_ty = ty.vec3<f32>();
+ auto* v = b.Var("v", ty.ptr<function>(ty.array(vec_ty, 8)));
+ auto* access = b.Access(ty.ptr<function>(vec_ty), v, 0_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<vec3<f32>, 8>, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<vec3<f32>, 8>, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u
+ %6:u32 = load %dyn_index
+ %7:vec3<f32> = load %5
+ %8:vec3<f32> = swizzle 1.0f, xxx
+ %9:vec3<f32> = swizzle %6, xxx
+ %10:vec3<f32> = construct 0i, 1i, 2i
+ %11:vec3<bool> = eq %9, %10
+ %12:vec3<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, VectorInArrayInStruct) {
+ auto* vec_ty = ty.vec3<f32>();
+ auto* struct_ty =
+ ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), ty.array(vec_ty, 8)}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* access = b.Access(ty.ptr<function>(vec_ty), v, 0_u, 0_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:array<vec3<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u, 0u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:array<vec3<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec3<f32>, read_write> = access %v, 0u, 0u
+ %6:u32 = load %dyn_index
+ %7:vec3<f32> = load %5
+ %8:vec3<f32> = swizzle 1.0f, xxx
+ %9:vec3<f32> = swizzle %6, xxx
+ %10:vec3<f32> = construct 0i, 1i, 2i
+ %11:vec3<bool> = eq %9, %10
+ %12:vec3<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, VectorByFunc) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* get_dynamic = b.Function("get_dynamic", ty.u32());
+ b.Append(get_dynamic->Block(), [&] { b.Return(get_dynamic, b.Load(dyn_index)); });
+ auto* get_static = b.Function("get_static", ty.u32());
+ b.Append(get_static->Block(), [&] { b.Return(get_static, 0_u); });
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* v = b.Var("v", ty.ptr<function>(ty.vec3<f32>()));
+ b.StoreVectorElement(v, b.Call(get_dynamic), 1_f);
+ // Will be transformed because we assume functions return a dynamic value
+ b.StoreVectorElement(v, b.Call(get_static), 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %7:u32 = call %get_dynamic
+ store_vector_element %v, %7, 1.0f
+ %8:u32 = call %get_static
+ store_vector_element %v, %8, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %7:u32 = call %get_dynamic
+ %8:vec3<f32> = load %v
+ %9:vec3<f32> = swizzle 1.0f, xxx
+ %10:vec3<f32> = swizzle %7, xxx
+ %11:vec3<f32> = construct 0i, 1i, 2i
+ %12:vec3<bool> = eq %10, %11
+ %13:vec3<f32> = select %8, %9, %12
+ store %v, %13
+ %14:u32 = call %get_static
+ %15:vec3<f32> = load %v
+ %16:vec3<f32> = swizzle 1.0f, xxx
+ %17:vec3<f32> = swizzle %14, xxx
+ %18:vec3<f32> = construct 0i, 1i, 2i
+ %19:vec3<bool> = eq %17, %18
+ %20:vec3<f32> = select %15, %16, %19
+ store %v, %20
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, Vector_ViaPointer) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.vec3<f32>()));
+ auto* p = b.Let("p", v);
+ b.StoreVectorElement(p, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(p, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %p:ptr<function, vec3<f32>, read_write> = let %v
+ %6:u32 = load %dyn_index
+ store_vector_element %p, %6, 1.0f
+ store_vector_element %p, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, vec3<f32>, read_write> = var
+ %5:u32 = load %dyn_index
+ %6:vec3<f32> = load %v
+ %7:vec3<f32> = swizzle 1.0f, xxx
+ %8:vec3<f32> = swizzle %5, xxx
+ %9:vec3<f32> = construct 0i, 1i, 2i
+ %10:vec3<bool> = eq %8, %9
+ %11:vec3<f32> = select %6, %7, %10
+ store %v, %11
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, Vector_PrivateVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<private_>(ty.vec3<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ b.StoreVectorElement(v, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(v, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, vec3<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:u32 = load %dyn_index
+ store_vector_element %v, %5, 1.0f
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, vec3<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:u32 = load %dyn_index
+ %6:vec3<f32> = load %v
+ %7:vec3<f32> = swizzle 1.0f, xxx
+ %8:vec3<f32> = swizzle %5, xxx
+ %9:vec3<f32> = construct 0i, 1i, 2i
+ %10:vec3<bool> = eq %8, %9
+ %11:vec3<f32> = select %6, %7, %10
+ store %v, %11
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, Vector_StorageVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<storage>(ty.vec3<f32>()));
+ v->SetBindingPoint(0, 1);
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ b.StoreVectorElement(v, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(v, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<storage, vec3<f32>, read_write> = var @binding_point(0, 1)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:u32 = load %dyn_index
+ store_vector_element %v, %5, 1.0f
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, Vector_WorkgroupVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<workgroup>(ty.vec3<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ b.StoreVectorElement(v, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(v, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<workgroup, vec3<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:u32 = load %dyn_index
+ store_vector_element %v, %5, 1.0f
+ store_vector_element %v, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElement) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElementInStruct) {
+ auto* mat_ty = ty.mat2x4<f32>();
+ auto* struct_ty = ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), mat_ty}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:mat2x4<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 0u, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:mat2x4<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 0u, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElementInArray) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.array(ty.mat2x4<f32>(), 8)));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 7_u, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<mat2x4<f32>, 8>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 7u, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<mat2x4<f32>, 8>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 7u, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElementInArrayInStruct) {
+ auto* mat_ty = ty.mat2x4<f32>();
+ auto* struct_ty =
+ ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), ty.array(mat_ty, 8)}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, 7_u, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:array<mat2x4<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:array<mat2x4<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+// MatrixElementByFunc
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElementByFunc) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* get_dynamic = b.Function("get_dynamic", ty.u32());
+ b.Append(get_dynamic->Block(), [&] { b.Return(get_dynamic, b.Load(dyn_index)); });
+ auto* get_static = b.Function("get_static", ty.u32());
+ b.Append(get_static->Block(), [&] { b.Return(get_static, 0_u); });
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 1_u);
+ b.StoreVectorElement(access, b.Call(get_dynamic), 1_f);
+ // Will be transformed because we assume functions return a dynamic value
+ b.StoreVectorElement(access, b.Call(get_static), 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %8:u32 = call %get_dynamic
+ store_vector_element %7, %8, 1.0f
+ %9:u32 = call %get_static
+ store_vector_element %7, %9, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %8:u32 = call %get_dynamic
+ %9:vec4<f32> = load %7
+ %10:vec4<f32> = swizzle 1.0f, xxxx
+ %11:vec4<f32> = swizzle %8, xxxx
+ %12:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %13:vec4<bool> = eq %11, %12
+ %14:vec4<f32> = select %9, %10, %13
+ store %7, %14
+ %15:u32 = call %get_static
+ %16:vec4<f32> = load %7
+ %17:vec4<f32> = swizzle 1.0f, xxxx
+ %18:vec4<f32> = swizzle %15, xxxx
+ %19:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %20:vec4<bool> = eq %18, %19
+ %21:vec4<f32> = select %16, %17, %20
+ store %7, %21
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElement_ViaPointer) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* access = b.Access(ty.ptr<function, vec4<f32>>(), v, 1_u);
+ auto* p = b.Let("p", access);
+ b.StoreVectorElement(p, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(p, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %p:ptr<function, vec4<f32>, read_write> = let %5
+ %7:u32 = load %dyn_index
+ store_vector_element %p, %7, 1.0f
+ store_vector_element %p, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElement_PrivateVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<private_>(ty.mat2x4<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* access = b.Access(ty.ptr<private_, vec4<f32>>(), v, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:ptr<private, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:ptr<private, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ %7:vec4<f32> = load %5
+ %8:vec4<f32> = swizzle 1.0f, xxxx
+ %9:vec4<f32> = swizzle %6, xxxx
+ %10:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %11:vec4<bool> = eq %9, %10
+ %12:vec4<f32> = select %7, %8, %11
+ store %5, %12
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElement_StorageVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<storage>(ty.mat2x4<f32>()));
+ v->SetBindingPoint(0, 1);
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* access = b.Access(ty.ptr<storage, vec4<f32>>(), v, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<storage, mat2x4<f32>, read_write> = var @binding_point(0, 1)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:ptr<storage, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixElement_WorkgroupVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<workgroup>(ty.mat2x4<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* access = b.Access(ty.ptr<workgroup, vec4<f32>>(), v, 1_u);
+ b.StoreVectorElement(access, b.Load(dyn_index), 1_f);
+ b.StoreVectorElement(access, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<workgroup, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:ptr<workgroup, vec4<f32>, read_write> = access %v, 1u
+ %6:u32 = load %dyn_index
+ store_vector_element %5, %6, 1.0f
+ store_vector_element %5, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumn) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, %6
+ store %7, %5
+ %8:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, %6
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 0u
+ store %8, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %9:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %10:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ store %10, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumnInStruct) {
+ auto* mat_ty = ty.mat2x4<f32>();
+ auto* struct_ty = ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), mat_ty}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:mat2x4<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 0u, %6
+ store %7, %5
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 0u, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:mat2x4<f32> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 0u, %6
+ %8:ptr<function, mat2x4<f32>, read_write> = access %v, 0u
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %9:ptr<function, vec4<f32>, read_write> = access %8, 0u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %10:ptr<function, vec4<f32>, read_write> = access %8, 1u
+ store %10, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %11:ptr<function, vec4<f32>, read_write> = access %v, 0u, %static_index
+ store %11, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumnInArray) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.array(ty.mat2x4<f32>(), 8)));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, 7_u, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, 7_u, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<mat2x4<f32>, 8>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 7u, %6
+ store %7, %5
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 7u, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, array<mat2x4<f32>, 8>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 7u, %6
+ %8:ptr<function, mat2x4<f32>, read_write> = access %v, 7u
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %9:ptr<function, vec4<f32>, read_write> = access %8, 0u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %10:ptr<function, vec4<f32>, read_write> = access %8, 1u
+ store %10, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %11:ptr<function, vec4<f32>, read_write> = access %v, 7u, %static_index
+ store %11, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumnInArrayInStruct) {
+ auto* mat_ty = ty.mat2x4<f32>();
+ auto* struct_ty =
+ ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("v"), ty.array(mat_ty, 8)}});
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(struct_ty));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, 7_u, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, 0_u, 7_u, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+S = struct @align(16) {
+ v:array<mat2x4<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, %6
+ store %7, %5
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+S = struct @align(16) {
+ v:array<mat2x4<f32>, 8> @offset(0)
+}
+
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, S, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, %6
+ %8:ptr<function, mat2x4<f32>, read_write> = access %v, 0u, 7u
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %9:ptr<function, vec4<f32>, read_write> = access %8, 0u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %10:ptr<function, vec4<f32>, read_write> = access %8, 1u
+ store %10, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %11:ptr<function, vec4<f32>, read_write> = access %v, 0u, 7u, %static_index
+ store %11, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumnByFunc) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* get_dynamic = b.Function("get_dynamic", ty.u32());
+ b.Append(get_dynamic->Block(), [&] { b.Return(get_dynamic, b.Load(dyn_index)); });
+ auto* get_static = b.Function("get_static", ty.u32());
+ b.Append(get_static->Block(), [&] { b.Return(get_static, 0_u); });
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, b.Call(get_dynamic));
+ b.Store(access0, vec);
+ // Will be transformed because we assume functions return a dynamic value
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, b.Call(get_static));
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %7:vec4<f32> = construct 0.0f
+ %8:u32 = call %get_dynamic
+ %9:ptr<function, vec4<f32>, read_write> = access %v, %8
+ store %9, %7
+ %10:u32 = call %get_static
+ %11:ptr<function, vec4<f32>, read_write> = access %v, %10
+ store %11, %7
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%get_dynamic = func():u32 {
+ $B2: {
+ %3:u32 = load %dyn_index
+ ret %3
+ }
+}
+%get_static = func():u32 {
+ $B3: {
+ ret 0u
+ }
+}
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B4: {
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %7:vec4<f32> = construct 0.0f
+ %8:u32 = call %get_dynamic
+ %9:ptr<function, vec4<f32>, read_write> = access %v, %8
+ switch %8 [c: (0u, $B5), c: (1u, $B6), c: (default, $B7)] { # switch_1
+ $B5: { # case
+ %10:ptr<function, vec4<f32>, read_write> = access %v, 0u
+ store %10, %7
+ exit_switch # switch_1
+ }
+ $B6: { # case
+ %11:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ store %11, %7
+ exit_switch # switch_1
+ }
+ $B7: { # case
+ exit_switch # switch_1
+ }
+ }
+ %12:u32 = call %get_static
+ %13:ptr<function, vec4<f32>, read_write> = access %v, %12
+ switch %12 [c: (0u, $B8), c: (1u, $B9), c: (default, $B10)] { # switch_2
+ $B8: { # case
+ %14:ptr<function, vec4<f32>, read_write> = access %v, 0u
+ store %14, %7
+ exit_switch # switch_2
+ }
+ $B9: { # case
+ %15:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ store %15, %7
+ exit_switch # switch_2
+ }
+ $B10: { # case
+ exit_switch # switch_2
+ }
+ }
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumn_ViaPointer) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, b.Load(dyn_index));
+ auto* p0 = b.Let("p0", access0);
+ b.Store(p0, vec);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, static_index);
+ auto* p1 = b.Let("p1", access1);
+ b.Store(p1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, %6
+ %p0:ptr<function, vec4<f32>, read_write> = let %7
+ store %p0, %5
+ %9:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ %p1:ptr<function, vec4<f32>, read_write> = let %9
+ store %p1, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<function, vec4<f32>, read_write> = access %v, %6
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 0u
+ store %8, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %9:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %10:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ store %10, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumn_PrivateVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<private_>(ty.mat2x4<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<private_, vec4<f32>>(), v, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<private_, vec4<f32>>(), v, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<private, vec4<f32>, read_write> = access %v, %6
+ store %7, %5
+ %8:ptr<private, vec4<f32>, read_write> = access %v, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<private, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<private, vec4<f32>, read_write> = access %v, %6
+ switch %6 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %8:ptr<private, vec4<f32>, read_write> = access %v, 0u
+ store %8, %5
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %9:ptr<private, vec4<f32>, read_write> = access %v, 1u
+ store %9, %5
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %10:ptr<private, vec4<f32>, read_write> = access %v, %static_index
+ store %10, %5
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumn_StorageVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<storage>(ty.mat2x4<f32>()));
+ v->SetBindingPoint(0, 1);
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<storage, vec4<f32>>(), v, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<storage, vec4<f32>>(), v, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<storage, mat2x4<f32>, read_write> = var @binding_point(0, 1)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<storage, vec4<f32>, read_write> = access %v, %6
+ store %7, %5
+ %8:ptr<storage, vec4<f32>, read_write> = access %v, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumn_WorkgroupVar) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+ auto* v = b.Var("v", ty.ptr<workgroup>(ty.mat2x4<f32>()));
+ mod.root_block->Append(v);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* vec = b.Construct(ty.vec4<f32>(), 0_f);
+ auto* access0 = b.Access(ty.ptr<workgroup, vec4<f32>>(), v, b.Load(dyn_index));
+ b.Store(access0, vec);
+ auto* access1 = b.Access(ty.ptr<workgroup, vec4<f32>>(), v, static_index);
+ b.Store(access1, vec);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+ %v:ptr<workgroup, mat2x4<f32>, read_write> = var
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %5:vec4<f32> = construct 0.0f
+ %6:u32 = load %dyn_index
+ %7:ptr<workgroup, vec4<f32>, read_write> = access %v, %6
+ store %7, %5
+ %8:ptr<workgroup, vec4<f32>, read_write> = access %v, %static_index
+ store %8, %5
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = src;
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+TEST_F(HlslWriterReplaceNonIndexableMatVecStoresTest, MatrixColumnAndElement) {
+ auto* dyn_index = b.Var("dyn_index", ty.ptr<uniform, u32>());
+ dyn_index->SetBindingPoint(0, 0);
+ mod.root_block->Append(dyn_index);
+
+ auto* func = b.Function("main", ty.void_(), core::ir::Function::PipelineStage::kCompute);
+ func->SetWorkgroupSize(1, 1, 1);
+ b.Append(func->Block(), [&] {
+ auto* static_index = b.Let("static_index", 0_u);
+ auto* v = b.Var("v", ty.ptr<function>(ty.mat2x4<f32>()));
+ auto* access0 = b.Access(ty.ptr<function, vec4<f32>>(), v, b.Load(dyn_index));
+ b.StoreVectorElement(access0, b.Load(dyn_index), 1_f);
+ auto* access1 = b.Access(ty.ptr<function, vec4<f32>>(), v, static_index);
+ b.StoreVectorElement(access1, static_index, 1_f);
+ b.Return(func);
+ });
+
+ auto* src = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:u32 = load %dyn_index
+ %6:ptr<function, vec4<f32>, read_write> = access %v, %5
+ %7:u32 = load %dyn_index
+ store_vector_element %6, %7, 1.0f
+ %8:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ store_vector_element %8, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ EXPECT_EQ(src, str());
+
+ auto* expect = R"(
+$B1: { # root
+ %dyn_index:ptr<uniform, u32, read> = var @binding_point(0, 0)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+ $B2: {
+ %static_index:u32 = let 0u
+ %v:ptr<function, mat2x4<f32>, read_write> = var
+ %5:u32 = load %dyn_index
+ %6:ptr<function, vec4<f32>, read_write> = access %v, %5
+ %7:u32 = load %dyn_index
+ switch %5 [c: (0u, $B3), c: (1u, $B4), c: (default, $B5)] { # switch_1
+ $B3: { # case
+ %8:ptr<function, vec4<f32>, read_write> = access %v, 0u
+ %9:vec4<f32> = load %8
+ %10:vec4<f32> = swizzle 1.0f, xxxx
+ %11:vec4<f32> = swizzle %7, xxxx
+ %12:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %13:vec4<bool> = eq %11, %12
+ %14:vec4<f32> = select %9, %10, %13
+ store %8, %14
+ exit_switch # switch_1
+ }
+ $B4: { # case
+ %15:ptr<function, vec4<f32>, read_write> = access %v, 1u
+ %16:vec4<f32> = load %15
+ %17:vec4<f32> = swizzle 1.0f, xxxx
+ %18:vec4<f32> = swizzle %7, xxxx
+ %19:vec4<f32> = construct 0i, 1i, 2i, 3i
+ %20:vec4<bool> = eq %18, %19
+ %21:vec4<f32> = select %16, %17, %20
+ store %15, %21
+ exit_switch # switch_1
+ }
+ $B5: { # case
+ exit_switch # switch_1
+ }
+ }
+ %22:ptr<function, vec4<f32>, read_write> = access %v, %static_index
+ store_vector_element %22, %static_index, 1.0f
+ ret
+ }
+}
+)";
+
+ Run(ReplaceNonIndexableMatVecStores);
+
+ EXPECT_EQ(expect, str());
+}
+
+} // namespace
+} // namespace tint::hlsl::writer::raise
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
index 90cc569..f87c5c2 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,22 @@
[numthreads(1, 1, 1)]
void main() {
float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
- m1[uniforms[0u].x][0] = 1.0f;
+ uint v = uniforms[0u].x;
+ switch(v) {
+ case 0u:
+ {
+ m1[0u][int(0)] = 1.0f;
+ break;
+ }
+ case 1u:
+ {
+ m1[1u][int(0)] = 1.0f;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
index b2d4f59..0751a3d 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,25 @@
[numthreads(1, 1, 1)]
void main() {
float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
- m1[uniforms[0u].x][uniforms[0u].y] = 1.0f;
+ uint v = uniforms[0u].x;
+ uint v_1 = uniforms[0u].y;
+ switch(v) {
+ case 0u:
+ {
+ float4 v_2 = m1[0u];
+ m1[0u] = (((v_1.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_2));
+ break;
+ }
+ case 1u:
+ {
+ float4 v_3 = m1[1u];
+ m1[1u] = (((v_1.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_3));
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
index f12523a..6fa43fc 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,8 @@
static float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
[numthreads(1, 1, 1)]
void main() {
- m1[0][uniforms[0u].y] = 1.0f;
+ float4 v = m1[int(0)];
+ float4 v_1 = uniforms[0u].y.xxxx;
+ m1[int(0)] = (((v_1 == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v));
}
-FXC validation failure:
-<scrubbed_path>(8,3-23): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_vector.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_vector.wgsl.expected.ir.fxc.hlsl
index e10bf36..99effaf 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_vector.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/local_assign_vector.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,22 @@
[numthreads(1, 1, 1)]
void main() {
float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
- m1[uniforms[0u].x] = (1.0f).xxxx;
+ uint v = uniforms[0u].x;
+ switch(v) {
+ case 0u:
+ {
+ m1[0u] = (1.0f).xxxx;
+ break;
+ }
+ case 1u:
+ {
+ m1[1u] = (1.0f).xxxx;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
index 5f16a9d..3f4f699 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_x.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,22 @@
static float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
[numthreads(1, 1, 1)]
void main() {
- m1[uniforms[0u].x][0] = 1.0f;
+ uint v = uniforms[0u].x;
+ switch(v) {
+ case 0u:
+ {
+ m1[0u][int(0)] = 1.0f;
+ break;
+ }
+ case 1u:
+ {
+ m1[1u][int(0)] = 1.0f;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
index c91def8..fc07399 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_xy.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,25 @@
static float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
[numthreads(1, 1, 1)]
void main() {
- m1[uniforms[0u].x][uniforms[0u].y] = 1.0f;
+ uint v = uniforms[0u].x;
+ uint v_1 = uniforms[0u].y;
+ switch(v) {
+ case 0u:
+ {
+ float4 v_2 = m1[0u];
+ m1[0u] = (((v_1.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_2));
+ break;
+ }
+ case 1u:
+ {
+ float4 v_3 = m1[1u];
+ m1[1u] = (((v_1.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_3));
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
index f12523a..6fa43fc 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_scalar_y.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,8 @@
static float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
[numthreads(1, 1, 1)]
void main() {
- m1[0][uniforms[0u].y] = 1.0f;
+ float4 v = m1[int(0)];
+ float4 v_1 = uniforms[0u].y.xxxx;
+ m1[int(0)] = (((v_1 == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v));
}
-FXC validation failure:
-<scrubbed_path>(8,3-23): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_vector.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_vector.wgsl.expected.ir.fxc.hlsl
index b8f8b30..25208fe 100644
--- a/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_vector.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/matrix_assignment_dynamic_index/module_assign_vector.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_uniforms : register(b4, space1) {
uint4 uniforms[1];
@@ -7,11 +5,22 @@
static float2x4 m1 = float2x4((0.0f).xxxx, (0.0f).xxxx);
[numthreads(1, 1, 1)]
void main() {
- m1[uniforms[0u].x] = (1.0f).xxxx;
+ uint v = uniforms[0u].x;
+ switch(v) {
+ case 0u:
+ {
+ m1[0u] = (1.0f).xxxx;
+ break;
+ }
+ case 1u:
+ {
+ m1[1u] = (1.0f).xxxx;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(8,3-20): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/vector_assignment_dynamic_index/function_var.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_dynamic_index/function_var.wgsl.expected.ir.fxc.hlsl
index a0e620d..78a74a4 100644
--- a/test/tint/bug/fxc/vector_assignment_dynamic_index/function_var.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_dynamic_index/function_var.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_i : register(b0) {
uint4 i[1];
@@ -7,11 +5,8 @@
[numthreads(1, 1, 1)]
void main() {
float3 v1 = (0.0f).xxx;
- v1[i[0u].x] = 1.0f;
+ float3 v = v1;
+ float3 v_1 = i[0u].x.xxx;
+ v1 = (((v_1 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v));
}
-FXC validation failure:
-<scrubbed_path>(8,3-13): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/vector_assignment_dynamic_index/private_var.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_dynamic_index/private_var.wgsl.expected.ir.fxc.hlsl
index 4545f7c..b3df419 100644
--- a/test/tint/bug/fxc/vector_assignment_dynamic_index/private_var.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_dynamic_index/private_var.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
cbuffer cbuffer_i : register(b0) {
uint4 i[1];
@@ -7,11 +5,8 @@
static float3 v1 = (0.0f).xxx;
[numthreads(1, 1, 1)]
void main() {
- v1[i[0u].x] = 1.0f;
+ float3 v = v1;
+ float3 v_1 = i[0u].x.xxx;
+ v1 = (((v_1 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v));
}
-FXC validation failure:
-<scrubbed_path>(8,3-13): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.ir.fxc.hlsl
index cc983da..75dba2e 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_loop.wgsl.expected.ir.fxc.hlsl
@@ -11,10 +11,18 @@
} else {
break;
}
- v2f[i] = 1.0f;
- v3i[i] = int(1);
- v4u[i] = 1u;
- v2b[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ int3 v_2 = v3i;
+ int3 v_3 = i.xxx;
+ v3i = (((v_3 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_2));
+ uint4 v_4 = v4u;
+ uint4 v_5 = i.xxxx;
+ v4u = (((v_5 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_4));
+ bool2 v_6 = v2b;
+ bool2 v_7 = i.xx;
+ v2b = (((v_7 == bool2(int(0), int(1)))) ? (true.xx) : (v_6));
{
i = (i + int(1));
}
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.ir.fxc.hlsl
index efcfa31..de7c05e 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_call_with_no_loop.wgsl.expected.ir.fxc.hlsl
@@ -5,10 +5,18 @@
static bool2 v2b = (false).xx;
void foo() {
int i = int(0);
- v2f[i] = 1.0f;
- v3i[i] = int(1);
- v4u[i] = 1u;
- v2b[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ int3 v_2 = v3i;
+ int3 v_3 = i.xxx;
+ v3i = (((v_3 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_2));
+ uint4 v_4 = v4u;
+ uint4 v_5 = i.xxxx;
+ v4u = (((v_5 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_4));
+ bool2 v_6 = v2b;
+ bool2 v_7 = i.xx;
+ v2b = (((v_7 == bool2(int(0), int(1)))) ? (true.xx) : (v_6));
}
[numthreads(1, 1, 1)]
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.ir.fxc.hlsl
index a2633f2..d48859e 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_all.wgsl.expected.ir.fxc.hlsl
@@ -20,18 +20,42 @@
} else {
break;
}
- v2f[i] = 1.0f;
- v3f[i] = 1.0f;
- v4f[i] = 1.0f;
- v2i[i] = int(1);
- v3i[i] = int(1);
- v4i[i] = int(1);
- v2u[i] = 1u;
- v3u[i] = 1u;
- v4u[i] = 1u;
- v2b[i] = true;
- v3b[i] = true;
- v4b[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ float3 v_2 = v3f;
+ float3 v_3 = i.xxx;
+ v3f = (((v_3 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v_2));
+ float4 v_4 = v4f;
+ float4 v_5 = i.xxxx;
+ v4f = (((v_5 == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_4));
+ int2 v_6 = v2i;
+ int2 v_7 = i.xx;
+ v2i = (((v_7 == int2(int(0), int(1)))) ? (int(1).xx) : (v_6));
+ int3 v_8 = v3i;
+ int3 v_9 = i.xxx;
+ v3i = (((v_9 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_8));
+ int4 v_10 = v4i;
+ int4 v_11 = i.xxxx;
+ v4i = (((v_11 == int4(int(0), int(1), int(2), int(3)))) ? (int(1).xxxx) : (v_10));
+ uint2 v_12 = v2u;
+ uint2 v_13 = i.xx;
+ v2u = (((v_13 == uint2(int(0), int(1)))) ? (1u.xx) : (v_12));
+ uint3 v_14 = v3u;
+ uint3 v_15 = i.xxx;
+ v3u = (((v_15 == uint3(int(0), int(1), int(2)))) ? (1u.xxx) : (v_14));
+ uint4 v_16 = v4u;
+ uint4 v_17 = i.xxxx;
+ v4u = (((v_17 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_16));
+ bool2 v_18 = v2b;
+ bool2 v_19 = i.xx;
+ v2b = (((v_19 == bool2(int(0), int(1)))) ? (true.xx) : (v_18));
+ bool3 v_20 = v3b;
+ bool3 v_21 = i.xxx;
+ v3b = (((v_21 == bool3(int(0), int(1), int(2)))) ? (true.xxx) : (v_20));
+ bool4 v_22 = v4b;
+ bool4 v_23 = i.xxxx;
+ v4b = (((v_23 == bool4(int(0), int(1), int(2), int(3)))) ? (true.xxxx) : (v_22));
{
i = (i + int(1));
}
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.ir.fxc.hlsl
index 3d27cfa..6df324f 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_repeated.wgsl.expected.ir.fxc.hlsl
@@ -16,14 +16,30 @@
} else {
break;
}
- v2f[i] = 1.0f;
- v3i[i] = int(1);
- v4u[i] = 1u;
- v2b[i] = true;
- v2f_2[i] = 1.0f;
- v3i_2[i] = int(1);
- v4u_2[i] = 1u;
- v2b_2[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ int3 v_2 = v3i;
+ int3 v_3 = i.xxx;
+ v3i = (((v_3 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_2));
+ uint4 v_4 = v4u;
+ uint4 v_5 = i.xxxx;
+ v4u = (((v_5 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_4));
+ bool2 v_6 = v2b;
+ bool2 v_7 = i.xx;
+ v2b = (((v_7 == bool2(int(0), int(1)))) ? (true.xx) : (v_6));
+ float2 v_8 = v2f_2;
+ float2 v_9 = i.xx;
+ v2f_2 = (((v_9 == float2(int(0), int(1)))) ? (1.0f.xx) : (v_8));
+ int3 v_10 = v3i_2;
+ int3 v_11 = i.xxx;
+ v3i_2 = (((v_11 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_10));
+ uint4 v_12 = v4u_2;
+ uint4 v_13 = i.xxxx;
+ v4u_2 = (((v_13 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_12));
+ bool2 v_14 = v2b_2;
+ bool2 v_15 = i.xx;
+ v2b_2 = (((v_15 == bool2(int(0), int(1)))) ? (true.xx) : (v_14));
{
i = (i + int(1));
}
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.ir.fxc.hlsl
index 69fe60a..2876a60 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/loop_types_some.wgsl.expected.ir.fxc.hlsl
@@ -20,10 +20,18 @@
} else {
break;
}
- v2f[i] = 1.0f;
- v2i[i] = int(1);
- v2u[i] = 1u;
- v2b[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ int2 v_2 = v2i;
+ int2 v_3 = i.xx;
+ v2i = (((v_3 == int2(int(0), int(1)))) ? (int(1).xx) : (v_2));
+ uint2 v_4 = v2u;
+ uint2 v_5 = i.xx;
+ v2u = (((v_5 == uint2(int(0), int(1)))) ? (1u.xx) : (v_4));
+ bool2 v_6 = v2b;
+ bool2 v_7 = i.xx;
+ v2b = (((v_7 == bool2(int(0), int(1)))) ? (true.xx) : (v_6));
{
i = (i + int(1));
}
@@ -31,13 +39,29 @@
}
}
int i = int(0);
- v3f[i] = 1.0f;
- v4f[i] = 1.0f;
- v3i[i] = int(1);
- v4i[i] = int(1);
- v3u[i] = 1u;
- v4u[i] = 1u;
- v3b[i] = true;
- v4b[i] = true;
+ float3 v_8 = v3f;
+ float3 v_9 = i.xxx;
+ v3f = (((v_9 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v_8));
+ float4 v_10 = v4f;
+ float4 v_11 = i.xxxx;
+ v4f = (((v_11 == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_10));
+ int3 v_12 = v3i;
+ int3 v_13 = i.xxx;
+ v3i = (((v_13 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_12));
+ int4 v_14 = v4i;
+ int4 v_15 = i.xxxx;
+ v4i = (((v_15 == int4(int(0), int(1), int(2), int(3)))) ? (int(1).xxxx) : (v_14));
+ uint3 v_16 = v3u;
+ uint3 v_17 = i.xxx;
+ v3u = (((v_17 == uint3(int(0), int(1), int(2)))) ? (1u.xxx) : (v_16));
+ uint4 v_18 = v4u;
+ uint4 v_19 = i.xxxx;
+ v4u = (((v_19 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_18));
+ bool3 v_20 = v3b;
+ bool3 v_21 = i.xxx;
+ v3b = (((v_21 == bool3(int(0), int(1), int(2)))) ? (true.xxx) : (v_20));
+ bool4 v_22 = v4b;
+ bool4 v_23 = i.xxxx;
+ v4b = (((v_23 == bool4(int(0), int(1), int(2), int(3)))) ? (true.xxxx) : (v_22));
}
diff --git a/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.ir.fxc.hlsl
index 7d6c6e4..0fc73a3 100644
--- a/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/fxc/vector_assignment_in_loop/no_loop.wgsl.expected.ir.fxc.hlsl
@@ -14,17 +14,41 @@
bool3 v3b = (false).xxx;
bool4 v4b = (false).xxxx;
int i = int(0);
- v2f[i] = 1.0f;
- v3f[i] = 1.0f;
- v4f[i] = 1.0f;
- v2i[i] = int(1);
- v3i[i] = int(1);
- v4i[i] = int(1);
- v2u[i] = 1u;
- v3u[i] = 1u;
- v4u[i] = 1u;
- v2b[i] = true;
- v3b[i] = true;
- v4b[i] = true;
+ float2 v = v2f;
+ float2 v_1 = i.xx;
+ v2f = (((v_1 == float2(int(0), int(1)))) ? (1.0f.xx) : (v));
+ float3 v_2 = v3f;
+ float3 v_3 = i.xxx;
+ v3f = (((v_3 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v_2));
+ float4 v_4 = v4f;
+ float4 v_5 = i.xxxx;
+ v4f = (((v_5 == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_4));
+ int2 v_6 = v2i;
+ int2 v_7 = i.xx;
+ v2i = (((v_7 == int2(int(0), int(1)))) ? (int(1).xx) : (v_6));
+ int3 v_8 = v3i;
+ int3 v_9 = i.xxx;
+ v3i = (((v_9 == int3(int(0), int(1), int(2)))) ? (int(1).xxx) : (v_8));
+ int4 v_10 = v4i;
+ int4 v_11 = i.xxxx;
+ v4i = (((v_11 == int4(int(0), int(1), int(2), int(3)))) ? (int(1).xxxx) : (v_10));
+ uint2 v_12 = v2u;
+ uint2 v_13 = i.xx;
+ v2u = (((v_13 == uint2(int(0), int(1)))) ? (1u.xx) : (v_12));
+ uint3 v_14 = v3u;
+ uint3 v_15 = i.xxx;
+ v3u = (((v_15 == uint3(int(0), int(1), int(2)))) ? (1u.xxx) : (v_14));
+ uint4 v_16 = v4u;
+ uint4 v_17 = i.xxxx;
+ v4u = (((v_17 == uint4(int(0), int(1), int(2), int(3)))) ? (1u.xxxx) : (v_16));
+ bool2 v_18 = v2b;
+ bool2 v_19 = i.xx;
+ v2b = (((v_19 == bool2(int(0), int(1)))) ? (true.xx) : (v_18));
+ bool3 v_20 = v3b;
+ bool3 v_21 = i.xxx;
+ v3b = (((v_21 == bool3(int(0), int(1), int(2)))) ? (true.xxx) : (v_20));
+ bool4 v_22 = v4b;
+ bool4 v_23 = i.xxxx;
+ v4b = (((v_23 == bool4(int(0), int(1), int(2), int(3)))) ? (true.xxxx) : (v_22));
}
diff --git a/test/tint/bug/tint/2059.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/tint/2059.wgsl.expected.ir.fxc.hlsl
index 0fd28a0..10d187e 100644
--- a/test/tint/bug/tint/2059.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/tint/2059.wgsl.expected.ir.fxc.hlsl
@@ -231,7 +231,28 @@
uint v_41 = c;
float v_42 = float(((c * 3u) + 1u));
float v_43 = float(((c * 3u) + 2u));
- m[v_41] = float3(v_42, v_43, float(((c * 3u) + 3u)));
+ float3 v_44 = float3(v_42, v_43, float(((c * 3u) + 3u)));
+ switch(v_41) {
+ case 0u:
+ {
+ m[0u] = v_44;
+ break;
+ }
+ case 1u:
+ {
+ m[1u] = v_44;
+ break;
+ }
+ case 2u:
+ {
+ m[2u] = v_44;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
{
c = (c + 1u);
}
@@ -240,33 +261,33 @@
}
float3x3 a = m;
v_40(0u, a);
- S v_44 = {m};
- S a_1 = v_44;
+ S v_45 = {m};
+ S a_1 = v_45;
v_39(0u, a_1);
- float3x3 v_45[1] = (float3x3[1])0;
- S2 v_46 = {v_45};
- S2 a_2 = v_46;
+ float3x3 v_46[1] = (float3x3[1])0;
+ S2 v_47 = {v_46};
+ S2 a_2 = v_47;
v_36(0u, a_2);
- S v_47 = {m};
- S3 v_48 = {v_47};
- S3 a_3 = v_48;
+ S v_48 = {m};
+ S3 v_49 = {v_48};
+ S3 a_3 = v_49;
v_30(0u, a_3);
- S v_49 = {m};
- S v_50[1] = (S[1])0;
- S4 v_51 = {v_50};
- S4 a_4 = v_51;
+ S v_50 = {m};
+ S v_51[1] = (S[1])0;
+ S4 v_52 = {v_51};
+ S4 a_4 = v_52;
v_26(0u, a_4);
- float3x3 v_52[1] = (float3x3[1])0;
- float3x3 a_5[1] = v_52;
+ float3x3 v_53[1] = (float3x3[1])0;
+ float3x3 a_5[1] = v_53;
v_17(0u, a_5);
- S v_53 = {m};
- S v_54[1] = (S[1])0;
- S a_6[1] = v_54;
+ S v_54 = {m};
+ S v_55[1] = (S[1])0;
+ S a_6[1] = v_55;
v_12(0u, a_6);
- float3x3 v_55[1] = (float3x3[1])0;
- S2 v_56 = {v_55};
- S2 v_57[1] = (S2[1])0;
- S2 a_7[1] = v_57;
+ float3x3 v_56[1] = (float3x3[1])0;
+ S2 v_57 = {v_56};
+ S2 v_58[1] = (S2[1])0;
+ S2 a_7[1] = v_58;
v_6(0u, a_7);
}
diff --git a/test/tint/bug/tint/534.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/tint/534.wgsl.expected.ir.fxc.hlsl
index 83f7d28..040f13e 100644
--- a/test/tint/bug/tint/534.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/tint/534.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
struct main_inputs {
uint3 GlobalInvocationID : SV_DispatchThreadID;
};
@@ -28,12 +26,10 @@
if ((uniforms[0u].x == 1u)) {
srcTexCoord[1u] = ((size.y - dstTexCoord.y) - 1u);
}
- Texture2D<float4> v_1 = src;
- int2 v_2 = int2(srcTexCoord);
- float4 srcColor = float4(v_1.Load(int3(v_2, int(0))));
- Texture2D<float4> v_3 = tint_symbol;
- int2 v_4 = int2(dstTexCoord);
- float4 dstColor = float4(v_3.Load(int3(v_4, int(0))));
+ int2 v_1 = int2(srcTexCoord);
+ float4 srcColor = float4(src.Load(int3(v_1, int(int(0)))));
+ int2 v_2 = int2(dstTexCoord);
+ float4 dstColor = float4(tint_symbol.Load(int3(v_2, int(int(0)))));
bool success = true;
uint4 srcColorBits = (0u).xxxx;
uint4 dstColorBits = tint_v4f32_to_v4u32(dstColor);
@@ -44,8 +40,10 @@
} else {
break;
}
- uint v_5 = i;
- srcColorBits[v_5] = ConvertToFp16FloatValue(srcColor[i]);
+ uint v_3 = i;
+ uint v_4 = ConvertToFp16FloatValue(srcColor[i]);
+ uint4 v_5 = srcColorBits;
+ srcColorBits = (((v_3.xxxx == uint4(int(0), int(1), int(2), int(3)))) ? (v_4.xxxx) : (v_5));
bool v_6 = false;
if (success) {
v_6 = (srcColorBits[i] == dstColorBits[i]);
@@ -72,8 +70,3 @@
main_inner(inputs.GlobalInvocationID);
}
-FXC validation failure:
-<scrubbed_path>(40,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/bug/tint/980.wgsl.expected.ir.fxc.hlsl b/test/tint/bug/tint/980.wgsl.expected.ir.fxc.hlsl
index d60f572..e5d0c5d 100644
--- a/test/tint/bug/tint/980.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/bug/tint/980.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
struct main_inputs {
uint idx : SV_GroupIndex;
};
@@ -8,13 +6,15 @@
RWByteAddressBuffer io : register(u0);
float3 Bad(uint index, float3 rd) {
float3 normal = (0.0f).xxx;
- normal[index] = -(float(sign(rd[index])));
+ float v_1 = -(float(sign(rd[index])));
+ float3 v_2 = normal;
+ normal = (((index.xxx == float3(int(0), int(1), int(2)))) ? (v_1.xxx) : (v_2));
return normalize(normal);
}
void main_inner(uint idx) {
- uint v_1 = io.Load(12u);
- io.Store3(0u, asuint(Bad(v_1, asfloat(io.Load3(0u)))));
+ uint v_3 = io.Load(12u);
+ io.Store3(0u, asuint(Bad(v_3, asfloat(io.Load3(0u)))));
}
[numthreads(1, 1, 1)]
@@ -22,8 +22,3 @@
main_inner(inputs.idx);
}
-FXC validation failure:
-<scrubbed_path>(9,3-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.ir.fxc.hlsl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.ir.fxc.hlsl
index a6d2f00..0595fe8 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
struct OuterS {
float2x4 m1;
};
@@ -11,12 +9,42 @@
[numthreads(1, 1, 1)]
void main() {
OuterS s1 = (OuterS)0;
- s1.m1[uniforms[0u].x] = (1.0f).xxxx;
- s1.m1[uniforms[0u].x][uniforms[0u].x] = 1.0f;
+ uint v = uniforms[0u].x;
+ switch(v) {
+ case 0u:
+ {
+ s1.m1[0u] = (1.0f).xxxx;
+ break;
+ }
+ case 1u:
+ {
+ s1.m1[1u] = (1.0f).xxxx;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ uint v_1 = uniforms[0u].x;
+ uint v_2 = uniforms[0u].x;
+ switch(v_1) {
+ case 0u:
+ {
+ float4 v_3 = s1.m1[0u];
+ s1.m1[0u] = (((v_2.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_3));
+ break;
+ }
+ case 1u:
+ {
+ float4 v_4 = s1.m1[1u];
+ s1.m1[1u] = (((v_2.xxxx == float4(int(0), int(1), int(2), int(3)))) ? (1.0f.xxxx) : (v_4));
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
}
-FXC validation failure:
-<scrubbed_path>(12,3-23): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.ir.fxc.hlsl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.ir.fxc.hlsl
index 26172b0..1b0ff6b 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.ir.fxc.hlsl
@@ -1,5 +1,3 @@
-SKIP: FAILED
-
struct OuterS {
float3 v1;
};
@@ -11,11 +9,8 @@
[numthreads(1, 1, 1)]
void main() {
OuterS s1 = (OuterS)0;
- s1.v1[uniforms[0u].x] = 1.0f;
+ float3 v = s1.v1;
+ float3 v_1 = uniforms[0u].x.xxx;
+ s1.v1 = (((v_1 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v));
}
-FXC validation failure:
-<scrubbed_path>(12,3-23): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.ir.fxc.hlsl b/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.ir.fxc.hlsl
index c380d42..5a7f3d5 100644
--- a/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.ir.fxc.hlsl
@@ -15,8 +15,12 @@
OuterS s1 = (OuterS)0;
float3 v = (0.0f).xxx;
uint v_1 = uniforms[0u].x;
- v[s1.a1[v_1]] = 1.0f;
- uint v_2 = uniforms[0u].x;
- v[f(s1.a1[v_2])] = 1.0f;
+ float3 v_2 = v;
+ float3 v_3 = s1.a1[v_1].xxx;
+ v = (((v_3 == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v_2));
+ uint v_4 = uniforms[0u].x;
+ uint v_5 = f(s1.a1[v_4]);
+ float3 v_6 = v;
+ v = (((v_5.xxx == float3(int(0), int(1), int(2)))) ? (1.0f.xxx) : (v_6));
}
diff --git a/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.ir.fxc.hlsl b/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.ir.fxc.hlsl
index b99a5f0..d5f7a21 100644
--- a/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/statements/compound_assign/complex_lhs.wgsl.expected.ir.fxc.hlsl
@@ -18,7 +18,9 @@
S x = (S)0;
int v = foo();
int v_1 = bar();
- x.a[v][v_1] = (x.a[v][v_1] + int(5));
+ int4 v_2 = x.a[v];
+ int4 v_3 = (x.a[v][v_1] + int(5)).xxxx;
+ x.a[v] = (((v_1.xxxx == int4(int(0), int(1), int(2), int(3)))) ? (v_3) : (v_2));
}
[numthreads(1, 1, 1)]
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 90e9bef..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,3 +0,0 @@
-SKIP: FAILED
-
-test timed out after 2m0s
\ No newline at end of file
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 90e9bef..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/control-flow-in-function/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,3 +0,0 @@
-SKIP: FAILED
-
-test timed out after 2m0s
\ No newline at end of file
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index dd6a20e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,177 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 c = (0.0f).xxxx;
- int a = 0;
- int i1 = 0;
- int i2 = 0;
- int i3 = 0;
- int i4 = 0;
- int i5 = 0;
- int i6 = 0;
- int i7 = 0;
- int i8_1 = 0;
- c = float4(0.0f, 0.0f, 0.0f, 1.0f);
- a = 0;
- {
- while(true) {
- {
- while(true) {
- int x_46 = a;
- c[x_46] = 1.0f;
- i1 = 0;
- {
- while(true) {
- if ((i1 < 1)) {
- } else {
- break;
- }
- i2 = 0;
- {
- while(true) {
- if ((i2 < 1)) {
- } else {
- break;
- }
- i3 = 0;
- {
- while(true) {
- if ((i3 < 1)) {
- } else {
- break;
- }
- i4 = 0;
- {
- while(true) {
- if ((i4 < 1)) {
- } else {
- break;
- }
- i5 = 0;
- {
- while(true) {
- if ((i5 < 1)) {
- } else {
- break;
- }
- i6 = 0;
- {
- while(true) {
- if ((i6 < 1)) {
- } else {
- break;
- }
- i7 = 0;
- {
- while(true) {
- if ((i7 < 1)) {
- } else {
- break;
- }
- i8_1 = 0;
- {
- while(true) {
- if ((i8_1 < 17)) {
- } else {
- break;
- }
- a = (a + 1);
- {
- i8_1 = (i8_1 + 1);
- }
- continue;
- }
- }
- {
- i7 = (i7 + 1);
- }
- continue;
- }
- }
- {
- i6 = (i6 + 1);
- }
- continue;
- }
- }
- {
- i5 = (i5 + 1);
- }
- continue;
- }
- }
- {
- i4 = (i4 + 1);
- }
- continue;
- }
- }
- {
- i3 = (i3 + 1);
- }
- continue;
- }
- }
- {
- i2 = (i2 + 1);
- }
- continue;
- }
- }
- {
- i1 = (i1 + 1);
- }
- continue;
- }
- }
- {
- float x_123 = gl_FragCoord.x;
- if (!((x_123 < -1.0f))) { break; }
- }
- continue;
- }
- }
- {
- float x_126 = gl_FragCoord.y;
- if (!((x_126 < -1.0f))) { break; }
- }
- continue;
- }
- }
- x_GLF_color = c;
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_1 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(32,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(30,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 5effb80..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-blockfrequency-several-for-loops/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,195 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 c = (0.0f).xxxx;
- int a = 0;
- int i1 = 0;
- int i2 = 0;
- int i3 = 0;
- int i4 = 0;
- int i5 = 0;
- int i6 = 0;
- int i7 = 0;
- int i8_1 = 0;
- c = float4(0.0f, 0.0f, 0.0f, 1.0f);
- a = 0;
- {
- while(true) {
- {
- while(true) {
- int x_46 = a;
- c[x_46] = 1.0f;
- i1 = 0;
- {
- while(true) {
- int x_52 = i1;
- if ((x_52 < 1)) {
- } else {
- break;
- }
- i2 = 0;
- {
- while(true) {
- int x_59 = i2;
- if ((x_59 < 1)) {
- } else {
- break;
- }
- i3 = 0;
- {
- while(true) {
- int x_66 = i3;
- if ((x_66 < 1)) {
- } else {
- break;
- }
- i4 = 0;
- {
- while(true) {
- int x_73 = i4;
- if ((x_73 < 1)) {
- } else {
- break;
- }
- i5 = 0;
- {
- while(true) {
- int x_80 = i5;
- if ((x_80 < 1)) {
- } else {
- break;
- }
- i6 = 0;
- {
- while(true) {
- int x_87 = i6;
- if ((x_87 < 1)) {
- } else {
- break;
- }
- i7 = 0;
- {
- while(true) {
- int x_94 = i7;
- if ((x_94 < 1)) {
- } else {
- break;
- }
- i8_1 = 0;
- {
- while(true) {
- int x_101 = i8_1;
- if ((x_101 < 17)) {
- } else {
- break;
- }
- int x_104 = a;
- a = (x_104 + 1);
- {
- int x_106 = i8_1;
- i8_1 = (x_106 + 1);
- }
- continue;
- }
- }
- {
- int x_108 = i7;
- i7 = (x_108 + 1);
- }
- continue;
- }
- }
- {
- int x_110 = i6;
- i6 = (x_110 + 1);
- }
- continue;
- }
- }
- {
- int x_112 = i5;
- i5 = (x_112 + 1);
- }
- continue;
- }
- }
- {
- int x_114 = i4;
- i4 = (x_114 + 1);
- }
- continue;
- }
- }
- {
- int x_116 = i3;
- i3 = (x_116 + 1);
- }
- continue;
- }
- }
- {
- int x_118 = i2;
- i2 = (x_118 + 1);
- }
- continue;
- }
- }
- {
- int x_120 = i1;
- i1 = (x_120 + 1);
- }
- continue;
- }
- }
- {
- float x_123 = gl_FragCoord.x;
- if (!((x_123 < -1.0f))) { break; }
- }
- continue;
- }
- }
- {
- float x_126 = gl_FragCoord.y;
- if (!((x_126 < -1.0f))) { break; }
- }
- continue;
- }
- }
- float4 x_128 = c;
- x_GLF_color = x_128;
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_1 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(32,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(30,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 3185918..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,80 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b1) {
- uint4 x_6[5];
-};
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v = (0.0f).xxxx;
- int i = 0;
- float v_1 = float(asint(x_6[1u].x));
- float v_2 = float(asint(x_6[2u].x));
- float v_3 = float(asint(x_6[3u].x));
- v = float4(v_1, v_2, v_3, float(asint(x_6[0u].x)));
- i = asint(x_6[4u].x);
- {
- while(true) {
- int v_4 = i;
- if ((v_4 < asint(x_6[0u].x))) {
- } else {
- break;
- }
- float4 v_5 = float4(v.x, v.y, v.z, v.w);
- float4 v_6 = float4(v.x, v.y, v.z, v.w);
- float4 v_7 = float4(v.x, v.y, v.z, v.w);
- float4x4 v_8 = float4x4(v_5, v_6, v_7, float4(v.x, v.y, v.z, v.w));
- float v_9 = v_8[0u][i];
- if ((v_9 > asfloat(x_9[0u].x))) {
- int x_96 = i;
- float4 v_10 = v;
- float4 v_11 = float4((asfloat(x_9[1u].x)).xxxx);
- float4 v_12 = clamp(v_10, v_11, float4((asfloat(x_9[0u].x)).xxxx));
- v[x_96] = v_12[asint(x_6[1u].x)];
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- float4 v_13 = v;
- if (all((v_13 == float4((float(asint(x_6[1u].x))).xxxx)))) {
- float v_14 = float(asint(x_6[1u].x));
- float v_15 = float(asint(x_6[4u].x));
- float v_16 = float(asint(x_6[4u].x));
- x_GLF_color = float4(v_14, v_15, v_16, float(asint(x_6[1u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_6[4u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_17 = {x_GLF_color};
- return v_17;
-}
-
-main_outputs main() {
- main_out v_18 = main_inner();
- main_outputs v_19 = {v_18.x_GLF_color_1};
- return v_19;
-}
-
-FXC validation failure:
-<scrubbed_path>(42,9-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(26,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index de9f7f8..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-clamp-vector-component-condition-using-matrix/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,101 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b1) {
- uint4 x_6[5];
-};
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v = (0.0f).xxxx;
- int i = 0;
- int x_40 = asint(x_6[1u].x);
- int x_43 = asint(x_6[2u].x);
- int x_46 = asint(x_6[3u].x);
- int x_49 = asint(x_6[0u].x);
- float v_1 = float(x_40);
- float v_2 = float(x_43);
- float v_3 = float(x_46);
- v = float4(v_1, v_2, v_3, float(x_49));
- int x_53 = asint(x_6[4u].x);
- i = x_53;
- {
- while(true) {
- int x_58 = i;
- int x_60 = asint(x_6[0u].x);
- if ((x_58 < x_60)) {
- } else {
- break;
- }
- float4 x_63 = v;
- float4 x_64 = v;
- float4 x_65 = v;
- float4 x_66 = v;
- int x_88 = i;
- float x_92 = asfloat(x_9[0u].x);
- float4 v_4 = float4(x_63[0u], x_63[1u], x_63[2u], x_63[3u]);
- float4 v_5 = float4(x_64[0u], x_64[1u], x_64[2u], x_64[3u]);
- float4 v_6 = float4(x_65[0u], x_65[1u], x_65[2u], x_65[3u]);
- if ((float4x4(v_4, v_5, v_6, float4(x_66[0u], x_66[1u], x_66[2u], x_66[3u]))[0u][x_88] > x_92)) {
- int x_96 = i;
- float4 x_97 = v;
- float x_99 = asfloat(x_9[1u].x);
- float x_102 = asfloat(x_9[0u].x);
- int x_106 = asint(x_6[1u].x);
- float4 v_7 = float4(x_99, x_99, x_99, x_99);
- v[x_96] = clamp(x_97, v_7, float4(x_102, x_102, x_102, x_102))[x_106];
- }
- {
- int x_109 = i;
- i = (x_109 + 1);
- }
- continue;
- }
- }
- float4 x_111 = v;
- int x_113 = asint(x_6[1u].x);
- float x_114 = float(x_113);
- if (all((x_111 == float4(x_114, x_114, x_114, x_114)))) {
- int x_122 = asint(x_6[1u].x);
- int x_125 = asint(x_6[4u].x);
- int x_128 = asint(x_6[4u].x);
- int x_131 = asint(x_6[1u].x);
- float v_8 = float(x_122);
- float v_9 = float(x_125);
- float v_10 = float(x_128);
- x_GLF_color = float4(v_8, v_9, v_10, float(x_131));
- } else {
- int x_135 = asint(x_6[4u].x);
- float x_136 = float(x_135);
- x_GLF_color = float4(x_136, x_136, x_136, x_136);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_11 = {x_GLF_color};
- return v_11;
-}
-
-main_outputs main() {
- main_out v_12 = main_inner();
- main_outputs v_13 = {v_12.x_GLF_color_1};
- return v_13;
-}
-
-FXC validation failure:
-<scrubbed_path>(54,9-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(31,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index dcdc528..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,67 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v = (0.0f).xxxx;
- int i = 0;
- v = float4((float(asint(x_6[3u].x))).xxxx);
- i = asint(x_6[0u].x);
- {
- while(true) {
- int v_1 = i;
- if ((v_1 < asint(x_6[3u].x))) {
- } else {
- break;
- }
- int x_50 = i;
- v[uint3(0u, 1u, 2u)[x_50]] = float(i);
- {
- i = (i + 1);
- }
- continue;
- }
- }
- float4 v_2 = v;
- float v_3 = float(asint(x_6[0u].x));
- float v_4 = float(asint(x_6[1u].x));
- float v_5 = float(asint(x_6[2u].x));
- if (all((v_2 == float4(v_3, v_4, v_5, float(asint(x_6[3u].x)))))) {
- float v_6 = float(asint(x_6[1u].x));
- float v_7 = float(asint(x_6[0u].x));
- float v_8 = float(asint(x_6[0u].x));
- x_GLF_color = float4(v_6, v_7, v_8, float(asint(x_6[1u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_6[0u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_9 = {x_GLF_color};
- return v_9;
-}
-
-main_outputs main() {
- main_out v_10 = main_inner();
- main_outputs v_11 = {v_10.x_GLF_color_1};
- return v_11;
-}
-
-FXC validation failure:
-<scrubbed_path>(27,7-32): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(20,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 138ce89..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-dag-combiner-combine-casts-legalize-vector-types-xyz-swizzle-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,83 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v = (0.0f).xxxx;
- int i = 0;
- int x_36 = asint(x_6[3u].x);
- float x_37 = float(x_36);
- v = float4(x_37, x_37, x_37, x_37);
- int x_40 = asint(x_6[0u].x);
- i = x_40;
- {
- while(true) {
- int x_45 = i;
- int x_47 = asint(x_6[3u].x);
- if ((x_45 < x_47)) {
- } else {
- break;
- }
- int x_50 = i;
- int x_51 = i;
- v[uint3(0u, 1u, 2u)[x_50]] = float(x_51);
- {
- int x_55 = i;
- i = (x_55 + 1);
- }
- continue;
- }
- }
- float4 x_57 = v;
- int x_59 = asint(x_6[0u].x);
- int x_62 = asint(x_6[1u].x);
- int x_65 = asint(x_6[2u].x);
- int x_68 = asint(x_6[3u].x);
- float v_1 = float(x_59);
- float v_2 = float(x_62);
- float v_3 = float(x_65);
- if (all((x_57 == float4(v_1, v_2, v_3, float(x_68))))) {
- int x_77 = asint(x_6[1u].x);
- int x_80 = asint(x_6[0u].x);
- int x_83 = asint(x_6[0u].x);
- int x_86 = asint(x_6[1u].x);
- float v_4 = float(x_77);
- float v_5 = float(x_80);
- float v_6 = float(x_83);
- x_GLF_color = float4(v_4, v_5, v_6, float(x_86));
- } else {
- int x_90 = asint(x_6[0u].x);
- float x_91 = float(x_90);
- x_GLF_color = float4(x_91, x_91, x_91, x_91);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_7 = {x_GLF_color};
- return v_7;
-}
-
-main_outputs main() {
- main_out v_8 = main_inner();
- main_outputs v_9 = {v_8.x_GLF_color_1};
- return v_9;
-}
-
-FXC validation failure:
-<scrubbed_path>(32,7-32): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(23,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index b262d9c..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,131 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-static int x_GLF_global_loop_count = 0;
-cbuffer cbuffer_x_7 : register(b1) {
- uint4 x_7[18];
-};
-cbuffer cbuffer_x_12 : register(b0) {
- uint4 x_12[4];
-};
-cbuffer cbuffer_x_15 : register(b2) {
- uint4 x_15[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-static bool continue_execution = true;
-void main_1() {
- float4x4 m = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- float4 v = (0.0f).xxxx;
- float f = 0.0f;
- int a = 0;
- int b = 0;
- float zero = 0.0f;
- x_GLF_global_loop_count = 0;
- float v_1 = asfloat(x_7[1u].x);
- float v_2 = asfloat(x_7[2u].x);
- float v_3 = asfloat(x_7[3u].x);
- float4 v_4 = float4(v_1, v_2, v_3, asfloat(x_7[4u].x));
- float v_5 = asfloat(x_7[5u].x);
- float v_6 = asfloat(x_7[6u].x);
- float v_7 = asfloat(x_7[7u].x);
- float4 v_8 = float4(v_5, v_6, v_7, asfloat(x_7[8u].x));
- float v_9 = asfloat(x_7[9u].x);
- float v_10 = asfloat(x_7[10u].x);
- float v_11 = asfloat(x_7[11u].x);
- float4 v_12 = float4(v_9, v_10, v_11, asfloat(x_7[12u].x));
- float v_13 = asfloat(x_7[13u].x);
- float v_14 = asfloat(x_7[14u].x);
- float v_15 = asfloat(x_7[15u].x);
- m = float4x4(v_4, v_8, v_12, float4(v_13, v_14, v_15, asfloat(x_7[16u].x)));
- float v_16 = asfloat(x_7[1u].x);
- float v_17 = asfloat(x_7[2u].x);
- float v_18 = asfloat(x_7[3u].x);
- v = float4(v_16, v_17, v_18, asfloat(x_7[4u].x));
- f = asfloat(x_7[1u].x);
- a = asint(x_12[0u].x);
- {
- while(true) {
- if ((x_GLF_global_loop_count < 10)) {
- } else {
- break;
- }
- x_GLF_global_loop_count = (x_GLF_global_loop_count + 1);
- int x_121 = min(max(a, 0), 3);
- float v_19 = v[x_121];
- v[x_121] = (v_19 + asfloat(x_7[1u].x));
- b = asint(x_12[2u].x);
- {
- while(true) {
- if ((x_GLF_global_loop_count < 10)) {
- } else {
- break;
- }
- x_GLF_global_loop_count = (x_GLF_global_loop_count + 1);
- float v_20 = f;
- float v_21 = v[min(max(b, 0), 3)];
- float4 v_22 = m[min(max(b, 0), 3)];
- f = (v_20 + (v_21 * v_22[a]));
- {
- b = (b - 1);
- }
- continue;
- }
- }
- int x_153 = a;
- int v_23 = min(max(x_153, 0), 3);
- m[1][v_23] = asfloat(x_7[1u].x);
- int v_24 = asint(x_15[0u].x);
- if ((v_24 == asint(x_12[0u].x))) {
- continue_execution = false;
- }
- int v_25 = asint(x_15[0u].x);
- if ((v_25 == asint(x_12[1u].x))) {
- continue_execution = false;
- }
- {
- a = (a + 1);
- }
- continue;
- }
- }
- zero = asfloat(x_7[0u].x);
- float v_26 = f;
- if (!((v_26 == asfloat(x_7[17u].x)))) {
- zero = asfloat(x_7[1u].x);
- }
- float v_27 = f;
- float v_28 = zero;
- float v_29 = float(asint(x_12[0u].x));
- x_GLF_color = float4(v_27, v_28, v_29, f);
-}
-
-main_out main_inner() {
- main_1();
- main_out v_30 = {x_GLF_color};
- return v_30;
-}
-
-main_outputs main() {
- main_out v_31 = main_inner();
- main_outputs v_32 = {v_31.x_GLF_color_1};
- if (!(continue_execution)) {
- discard;
- }
- main_outputs v_33 = v_32;
- return v_33;
-}
-
-FXC validation failure:
-<scrubbed_path>(61,7-14): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(53,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index fc6d64e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-global-loop-counter-float-accumulate-matrix/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,156 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-static int x_GLF_global_loop_count = 0;
-cbuffer cbuffer_x_7 : register(b1) {
- uint4 x_7[18];
-};
-cbuffer cbuffer_x_12 : register(b0) {
- uint4 x_12[4];
-};
-cbuffer cbuffer_x_15 : register(b2) {
- uint4 x_15[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-static bool continue_execution = true;
-void main_1() {
- float4x4 m = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- float4 v = (0.0f).xxxx;
- float f = 0.0f;
- int a = 0;
- int b = 0;
- float zero = 0.0f;
- x_GLF_global_loop_count = 0;
- float x_62 = asfloat(x_7[1u].x);
- float x_64 = asfloat(x_7[2u].x);
- float x_66 = asfloat(x_7[3u].x);
- float x_68 = asfloat(x_7[4u].x);
- float x_70 = asfloat(x_7[5u].x);
- float x_72 = asfloat(x_7[6u].x);
- float x_74 = asfloat(x_7[7u].x);
- float x_76 = asfloat(x_7[8u].x);
- float x_78 = asfloat(x_7[9u].x);
- float x_80 = asfloat(x_7[10u].x);
- float x_82 = asfloat(x_7[11u].x);
- float x_84 = asfloat(x_7[12u].x);
- float x_86 = asfloat(x_7[13u].x);
- float x_88 = asfloat(x_7[14u].x);
- float x_90 = asfloat(x_7[15u].x);
- float x_92 = asfloat(x_7[16u].x);
- float4 v_1 = float4(x_62, x_64, x_66, x_68);
- float4 v_2 = float4(x_70, x_72, x_74, x_76);
- float4 v_3 = float4(x_78, x_80, x_82, x_84);
- m = float4x4(v_1, v_2, v_3, float4(x_86, x_88, x_90, x_92));
- float x_99 = asfloat(x_7[1u].x);
- float x_101 = asfloat(x_7[2u].x);
- float x_103 = asfloat(x_7[3u].x);
- float x_105 = asfloat(x_7[4u].x);
- v = float4(x_99, x_101, x_103, x_105);
- float x_108 = asfloat(x_7[1u].x);
- f = x_108;
- int x_110 = asint(x_12[0u].x);
- a = x_110;
- {
- while(true) {
- int x_115 = x_GLF_global_loop_count;
- if ((x_115 < 10)) {
- } else {
- break;
- }
- int x_118 = x_GLF_global_loop_count;
- x_GLF_global_loop_count = (x_118 + 1);
- int x_120 = a;
- int x_121 = min(max(x_120, 0), 3);
- float x_123 = asfloat(x_7[1u].x);
- float x_125 = v[x_121];
- v[x_121] = (x_125 + x_123);
- int x_129 = asint(x_12[2u].x);
- b = x_129;
- {
- while(true) {
- int x_134 = x_GLF_global_loop_count;
- if ((x_134 < 10)) {
- } else {
- break;
- }
- int x_137 = x_GLF_global_loop_count;
- x_GLF_global_loop_count = (x_137 + 1);
- int x_139 = b;
- float x_142 = v[min(max(x_139, 0), 3)];
- int x_143 = b;
- int x_145 = a;
- float x_147 = m[min(max(x_143, 0), 3)][x_145];
- float x_149 = f;
- f = (x_149 + (x_142 * x_147));
- {
- int x_151 = b;
- b = (x_151 - 1);
- }
- continue;
- }
- }
- int x_153 = a;
- float x_156 = asfloat(x_7[1u].x);
- m[1][min(max(x_153, 0), 3)] = x_156;
- int x_159 = asint(x_15[0u].x);
- int x_161 = asint(x_12[0u].x);
- if ((x_159 == x_161)) {
- continue_execution = false;
- }
- int x_166 = asint(x_15[0u].x);
- int x_168 = asint(x_12[1u].x);
- if ((x_166 == x_168)) {
- continue_execution = false;
- }
- {
- int x_172 = a;
- a = (x_172 + 1);
- }
- continue;
- }
- }
- float x_175 = asfloat(x_7[0u].x);
- zero = x_175;
- float x_176 = f;
- float x_178 = asfloat(x_7[17u].x);
- if (!((x_176 == x_178))) {
- float x_183 = asfloat(x_7[1u].x);
- zero = x_183;
- }
- float x_184 = f;
- float x_185 = zero;
- int x_187 = asint(x_12[0u].x);
- float x_189 = f;
- x_GLF_color = float4(x_184, x_185, float(x_187), x_189);
-}
-
-main_out main_inner() {
- main_1();
- main_out v_4 = {x_GLF_color};
- return v_4;
-}
-
-main_outputs main() {
- main_out v_5 = main_inner();
- main_outputs v_6 = {v_5.x_GLF_color_1};
- if (!(continue_execution)) {
- discard;
- }
- main_outputs v_7 = v_6;
- return v_7;
-}
-
-FXC validation failure:
-<scrubbed_path>(72,7-14): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(60,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 11faf9e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,65 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[4];
-};
-cbuffer cbuffer_x_9 : register(b1) {
- uint4 x_9[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float3x3 m = float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int a = 0;
- float3 arr[2] = (float3[2])0;
- float3 v = (0.0f).xxx;
- float x_46 = float(asint(x_6[0u].x));
- float3 v_1 = float3(x_46, 0.0f, 0.0f);
- float3 v_2 = float3(0.0f, x_46, 0.0f);
- m = float3x3(v_1, v_2, float3(0.0f, 0.0f, x_46));
- a = asint(x_6[0u].x);
- int x_53 = a;
- int x_54 = a;
- m[x_53][x_54] = asfloat(x_9[0u].x);
- float3 v_3[2] = {m[1], m[1]};
- arr = v_3;
- v = float3((asfloat(x_9[1u].x)).xxx);
- v = (v + arr[a]);
- float3 v_4 = v;
- float v_5 = float(asint(x_6[1u].x));
- float v_6 = float(asint(x_6[2u].x));
- if (all((v_4 == float3(v_5, v_6, float(asint(x_6[1u].x)))))) {
- float v_7 = float(asint(x_6[0u].x));
- float v_8 = float(asint(x_6[3u].x));
- float v_9 = float(asint(x_6[3u].x));
- x_GLF_color = float4(v_7, v_8, v_9, float(asint(x_6[0u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_6[3u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_10 = {x_GLF_color};
- return v_10;
-}
-
-main_outputs main() {
- main_out v_11 = main_inner();
- main_outputs v_12 = {v_11.x_GLF_color_1};
- return v_12;
-}
-
-FXC validation failure:
-<scrubbed_path>(29,3-9): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 84639a6..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-array-matrix-element/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,83 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[4];
-};
-cbuffer cbuffer_x_9 : register(b1) {
- uint4 x_9[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float3x3 m = float3x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int a = 0;
- float3 arr[2] = (float3[2])0;
- float3 v = (0.0f).xxx;
- int x_45 = asint(x_6[0u].x);
- float x_46 = float(x_45);
- float3 v_1 = float3(x_46, 0.0f, 0.0f);
- float3 v_2 = float3(0.0f, x_46, 0.0f);
- m = float3x3(v_1, v_2, float3(0.0f, 0.0f, x_46));
- int x_52 = asint(x_6[0u].x);
- a = x_52;
- int x_53 = a;
- int x_54 = a;
- float x_56 = asfloat(x_9[0u].x);
- m[x_53][x_54] = x_56;
- float3 x_59 = m[1];
- float3 x_61 = m[1];
- float3 v_3[2] = {x_59, x_61};
- arr = v_3;
- float x_64 = asfloat(x_9[1u].x);
- v = float3(x_64, x_64, x_64);
- int x_66 = a;
- float3 x_68 = arr[x_66];
- float3 x_69 = v;
- v = (x_69 + x_68);
- float3 x_71 = v;
- int x_73 = asint(x_6[1u].x);
- int x_76 = asint(x_6[2u].x);
- int x_79 = asint(x_6[1u].x);
- float v_4 = float(x_73);
- float v_5 = float(x_76);
- if (all((x_71 == float3(v_4, v_5, float(x_79))))) {
- int x_88 = asint(x_6[0u].x);
- int x_91 = asint(x_6[3u].x);
- int x_94 = asint(x_6[3u].x);
- int x_97 = asint(x_6[0u].x);
- float v_6 = float(x_88);
- float v_7 = float(x_91);
- float v_8 = float(x_94);
- x_GLF_color = float4(v_6, v_7, v_8, float(x_97));
- } else {
- int x_101 = asint(x_6[3u].x);
- float x_102 = float(x_101);
- x_GLF_color = float4(x_102, x_102, x_102, x_102);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_9 = {x_GLF_color};
- return v_9;
-}
-
-main_outputs main() {
- main_out v_10 = main_inner();
- main_outputs v_11 = {v_10.x_GLF_color_1};
- return v_11;
-}
-
-FXC validation failure:
-<scrubbed_path>(32,3-9): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 8ece67a..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,67 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_9 : register(b1) {
- uint4 x_9[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int a = 0;
- float4 v = (0.0f).xxxx;
- float3x4 m = float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- float4x4 indexable = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- a = asint(x_6[0u].x);
- v = float4((asfloat(x_9[2u].x)).xxxx);
- float x_49 = asfloat(x_9[3u].x);
- float4 v_1 = float4(x_49, 0.0f, 0.0f, 0.0f);
- float4 v_2 = float4(0.0f, x_49, 0.0f, 0.0f);
- m = float3x4(v_1, v_2, float4(0.0f, 0.0f, x_49, 0.0f));
- int x_54 = a;
- int x_55 = a;
- m[x_54][x_55] = asfloat(x_9[0u].x);
- int x_59 = a;
- int x_78 = a;
- int x_79 = a;
- float4 v_3 = float4(m[0u].x, m[0u].y, m[0u].z, m[0u].w);
- float4 v_4 = float4(m[1u].x, m[1u].y, m[1u].z, m[1u].w);
- indexable = float4x4(v_3, v_4, float4(m[2u].x, m[2u].y, m[2u].z, m[2u].w), float4(0.0f, 0.0f, 0.0f, 1.0f));
- v[x_59] = (v[x_59] + indexable[x_78][x_79]);
- float v_5 = v.y;
- if ((v_5 == asfloat(x_9[1u].x))) {
- float v_6 = float(asint(x_6[0u].x));
- float v_7 = float(asint(x_6[1u].x));
- float v_8 = float(asint(x_6[1u].x));
- x_GLF_color = float4(v_6, v_7, v_8, float(asint(x_6[0u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_6[1u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_9 = {x_GLF_color};
- return v_9;
-}
-
-main_outputs main() {
- main_out v_10 = main_inner();
- main_outputs v_11 = {v_10.x_GLF_color_1};
- return v_11;
-}
-
-FXC validation failure:
-<scrubbed_path>(30,3-9): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index e33b357..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-increment-vector-component-with-matrix-copy/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,80 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_9 : register(b1) {
- uint4 x_9[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int a = 0;
- float4 v = (0.0f).xxxx;
- float3x4 m = float3x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- float4x4 indexable = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int x_44 = asint(x_6[0u].x);
- a = x_44;
- float x_46 = asfloat(x_9[2u].x);
- v = float4(x_46, x_46, x_46, x_46);
- float x_49 = asfloat(x_9[3u].x);
- float4 v_1 = float4(x_49, 0.0f, 0.0f, 0.0f);
- float4 v_2 = float4(0.0f, x_49, 0.0f, 0.0f);
- m = float3x4(v_1, v_2, float4(0.0f, 0.0f, x_49, 0.0f));
- int x_54 = a;
- int x_55 = a;
- float x_57 = asfloat(x_9[0u].x);
- m[x_54][x_55] = x_57;
- int x_59 = a;
- float3x4 x_60 = m;
- int x_78 = a;
- int x_79 = a;
- float4 v_3 = float4(x_60[0u][0u], x_60[0u][1u], x_60[0u][2u], x_60[0u][3u]);
- float4 v_4 = float4(x_60[1u][0u], x_60[1u][1u], x_60[1u][2u], x_60[1u][3u]);
- indexable = float4x4(v_3, v_4, float4(x_60[2u][0u], x_60[2u][1u], x_60[2u][2u], x_60[2u][3u]), float4(0.0f, 0.0f, 0.0f, 1.0f));
- float x_81 = indexable[x_78][x_79];
- float x_83 = v[x_59];
- v[x_59] = (x_83 + x_81);
- float x_87 = v.y;
- float x_89 = asfloat(x_9[1u].x);
- if ((x_87 == x_89)) {
- int x_95 = asint(x_6[0u].x);
- int x_98 = asint(x_6[1u].x);
- int x_101 = asint(x_6[1u].x);
- int x_104 = asint(x_6[0u].x);
- float v_5 = float(x_95);
- float v_6 = float(x_98);
- float v_7 = float(x_101);
- x_GLF_color = float4(v_5, v_6, v_7, float(x_104));
- } else {
- int x_108 = asint(x_6[1u].x);
- float x_109 = float(x_108);
- x_GLF_color = float4(x_109, x_109, x_109, x_109);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_8 = {x_GLF_color};
- return v_8;
-}
-
-main_outputs main() {
- main_out v_9 = main_inner();
- main_outputs v_10 = {v_9.x_GLF_color_1};
- return v_10;
-}
-
-FXC validation failure:
-<scrubbed_path>(33,3-9): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 7277d76..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,57 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_8 : register(b1) {
- uint4 x_8[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 color = (0.0f).xxxx;
- float v = asfloat(x_6[0u].x);
- float v_1 = asfloat(x_6[0u].x);
- float v_2 = asfloat(x_6[0u].x);
- color = float4(v, v_1, v_2, asfloat(x_6[1u].x));
- int x_38 = asint(x_8[1u].x);
- switch(((1 | x_38) ^ 1)) {
- case 0:
- {
- int x_44 = asint(x_8[0u].x);
- color[x_44] = asfloat(x_6[1u].x);
- break;
- }
- default:
- {
- break;
- }
- }
- x_GLF_color = color;
-}
-
-main_out main_inner() {
- main_1();
- main_out v_3 = {x_GLF_color};
- return v_3;
-}
-
-main_outputs main() {
- main_out v_4 = main_inner();
- main_outputs v_5 = {v_4.x_GLF_color_1};
- return v_5;
-}
-
-FXC validation failure:
-internal error: compilation aborted unexpectedly
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index d2172f3..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-inst-combine-simplify-demanded-switch-or-xor/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,60 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_8 : register(b1) {
- uint4 x_8[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 color = (0.0f).xxxx;
- float x_29 = asfloat(x_6[0u].x);
- float x_31 = asfloat(x_6[0u].x);
- float x_33 = asfloat(x_6[0u].x);
- float x_35 = asfloat(x_6[1u].x);
- color = float4(x_29, x_31, x_33, x_35);
- int x_38 = asint(x_8[1u].x);
- switch(((1 | x_38) ^ 1)) {
- case 0:
- {
- int x_44 = asint(x_8[0u].x);
- float x_46 = asfloat(x_6[1u].x);
- color[x_44] = x_46;
- break;
- }
- default:
- {
- break;
- }
- }
- float4 x_48 = color;
- x_GLF_color = x_48;
-}
-
-main_out main_inner() {
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main() {
- main_out v_1 = main_inner();
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-internal error: compilation aborted unexpectedly
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 3399f32..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,52 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_8 : register(b1) {
- uint4 x_8[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2 v1 = (0.0f).xx;
- float x_35 = asfloat(x_6[0u].x);
- v1 = float2((x_35).xx);
- int x_38 = asint(x_8[0u].x);
- v1[x_38] = ldexp(v1.y, -256);
- float2 v = v1;
- float2 v_1 = float2(x_35, 0.0f);
- if ((mul(float2x2(v_1, float2(0.0f, x_35)), v)[0u] == x_35)) {
- float x_53 = float(x_38);
- float x_56 = float(asint(x_8[1u].x));
- x_GLF_color = float4(x_53, x_56, x_56, x_53);
- } else {
- x_GLF_color = float4((float(asint(x_8[1u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_2 = {x_GLF_color};
- return v_2;
-}
-
-main_outputs main() {
- main_out v_3 = main_inner();
- main_outputs v_4 = {v_3.x_GLF_color_1};
- return v_4;
-}
-
-FXC validation failure:
-<scrubbed_path>(22,3-10): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 256e059..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-ldexp-undefined-mat-vec-multiply/0.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,56 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_8 : register(b1) {
- uint4 x_8[2];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2 v1 = (0.0f).xx;
- float x_35 = asfloat(x_6[0u].x);
- v1 = float2(x_35, x_35);
- int x_38 = asint(x_8[0u].x);
- float x_40 = v1.y;
- v1[x_38] = ldexp(x_40, -256);
- float2 x_43 = v1;
- float2 v = float2(x_35, 0.0f);
- if ((mul(float2x2(v, float2(0.0f, x_35)), x_43)[0u] == x_35)) {
- float x_53 = float(x_38);
- int x_55 = asint(x_8[1u].x);
- float x_56 = float(x_55);
- x_GLF_color = float4(x_53, x_56, x_56, x_53);
- } else {
- int x_59 = asint(x_8[1u].x);
- float x_60 = float(x_59);
- x_GLF_color = float4(x_60, x_60, x_60, x_60);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_1 = {x_GLF_color};
- return v_1;
-}
-
-main_outputs main() {
- main_out v_2 = main_inner();
- main_outputs v_3 = {v_2.x_GLF_color_1};
- return v_3;
-}
-
-FXC validation failure:
-<scrubbed_path>(23,3-10): error X3500: array reference cannot be used as an l-value; not natively addressable
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 718e3cc..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,96 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_7 : register(b1) {
- uint4 x_7[2];
-};
-cbuffer cbuffer_x_10 : register(b0) {
- uint4 x_10[4];
-};
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2x3 m23 = float2x3((0.0f).xxx, (0.0f).xxx);
- int i = 0;
- float x_46 = asfloat(x_7[1u].x);
- float3 v = float3(x_46, 0.0f, 0.0f);
- m23 = float2x3(v, float3(0.0f, x_46, 0.0f));
- i = 1;
- {
- while(true) {
- bool x_80 = false;
- bool x_81 = false;
- int v_1 = i;
- if ((v_1 < asint(x_10[3u].x))) {
- } else {
- break;
- }
- int x_60 = asint(x_10[0u].x);
- int x_62 = asint(x_10[2u].x);
- float v_2 = m23[x_60][x_62];
- m23[x_60][x_62] = (v_2 + asfloat(x_7[0u].x));
- float v_3 = gl_FragCoord.y;
- if ((v_3 < asfloat(x_7[0u].x))) {
- }
- x_81 = true;
- if (true) {
- x_80 = (gl_FragCoord.x < 0.0f);
- x_81 = x_80;
- }
- if (!(x_81)) {
- break;
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- float v_4 = float(asint(x_10[1u].x));
- float v_5 = float(asint(x_10[1u].x));
- float3 v_6 = float3(v_4, v_5, float(asint(x_10[1u].x)));
- float v_7 = float(asint(x_10[1u].x));
- float v_8 = float(asint(x_10[1u].x));
- float2x3 x_108 = float2x3(v_6, float3(v_7, v_8, float(asint(x_10[0u].x))));
- bool v_9 = all((m23[0u] == x_108[0u]));
- if ((v_9 & all((m23[1u] == x_108[1u])))) {
- float v_10 = float(asint(x_10[0u].x));
- float v_11 = float(asint(x_10[1u].x));
- float v_12 = float(asint(x_10[1u].x));
- x_GLF_color = float4(v_10, v_11, v_12, float(asint(x_10[0u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_10[1u].x))).xxxx);
- }
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_13 = {x_GLF_color};
- return v_13;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_14 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_15 = {v_14.x_GLF_color_1};
- return v_15;
-}
-
-FXC validation failure:
-<scrubbed_path>(41,7-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(30,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index c71e57a..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-loop-increment-matrix-element-break-after-first-iteration/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,115 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_7 : register(b1) {
- uint4 x_7[2];
-};
-cbuffer cbuffer_x_10 : register(b0) {
- uint4 x_10[4];
-};
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2x3 m23 = float2x3((0.0f).xxx, (0.0f).xxx);
- int i = 0;
- float x_46 = asfloat(x_7[1u].x);
- float3 v = float3(x_46, 0.0f, 0.0f);
- m23 = float2x3(v, float3(0.0f, x_46, 0.0f));
- i = 1;
- {
- while(true) {
- bool x_80 = false;
- bool x_81_phi = false;
- int x_54 = i;
- int x_56 = asint(x_10[3u].x);
- if ((x_54 < x_56)) {
- } else {
- break;
- }
- int x_60 = asint(x_10[0u].x);
- int x_62 = asint(x_10[2u].x);
- float x_64 = asfloat(x_7[0u].x);
- float x_66 = m23[x_60][x_62];
- m23[x_60][x_62] = (x_66 + x_64);
- float x_70 = gl_FragCoord.y;
- float x_72 = asfloat(x_7[0u].x);
- if ((x_70 < x_72)) {
- }
- x_81_phi = true;
- if (true) {
- float x_79 = gl_FragCoord.x;
- x_80 = (x_79 < 0.0f);
- x_81_phi = x_80;
- }
- bool x_81 = x_81_phi;
- if (!(x_81)) {
- break;
- }
- {
- int x_85 = i;
- i = (x_85 + 1);
- }
- continue;
- }
- }
- float2x3 x_87 = m23;
- int x_89 = asint(x_10[1u].x);
- int x_92 = asint(x_10[1u].x);
- int x_95 = asint(x_10[1u].x);
- int x_98 = asint(x_10[1u].x);
- int x_101 = asint(x_10[1u].x);
- int x_104 = asint(x_10[0u].x);
- float v_1 = float(x_89);
- float v_2 = float(x_92);
- float3 v_3 = float3(v_1, v_2, float(x_95));
- float v_4 = float(x_98);
- float v_5 = float(x_101);
- float2x3 x_108 = float2x3(v_3, float3(v_4, v_5, float(x_104)));
- bool v_6 = all((x_87[0u] == x_108[0u]));
- if ((v_6 & all((x_87[1u] == x_108[1u])))) {
- int x_122 = asint(x_10[0u].x);
- int x_125 = asint(x_10[1u].x);
- int x_128 = asint(x_10[1u].x);
- int x_131 = asint(x_10[0u].x);
- float v_7 = float(x_122);
- float v_8 = float(x_125);
- float v_9 = float(x_128);
- x_GLF_color = float4(v_7, v_8, v_9, float(x_131));
- } else {
- int x_135 = asint(x_10[1u].x);
- float x_136 = float(x_135);
- x_GLF_color = float4(x_136, x_136, x_136, x_136);
- }
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_10 = {x_GLF_color};
- return v_10;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_11 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_12 = {v_11.x_GLF_color_1};
- return v_12;
-}
-
-FXC validation failure:
-<scrubbed_path>(43,7-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(30,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 03fccdf..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,95 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_10 : register(b1) {
- uint4 x_10[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v0 = (0.0f).xxxx;
- float4 v1 = (0.0f).xxxx;
- int a = 0;
- int c = 0;
- v0 = float4((asfloat(x_6[1u].x)).xxxx);
- v1 = float4((asfloat(x_6[0u].x)).xxxx);
- a = asint(x_10[1u].x);
- {
- while(true) {
- int v = a;
- if ((v < asint(x_10[0u].x))) {
- } else {
- break;
- }
- c = asint(x_10[3u].x);
- {
- while(true) {
- int v_1 = c;
- if ((v_1 < asint(x_10[2u].x))) {
- } else {
- break;
- }
- int x_69 = min(max(c, 0), 3);
- float v_2 = v0[x_69];
- v0[x_69] = (v_2 - asfloat(x_6[1u].x));
- int v_3 = asint(x_10[1u].x);
- if ((v_3 == asint(x_10[3u].x))) {
- int x_83 = a;
- float v_4 = asfloat(x_6[1u].x);
- float v_5 = asfloat(x_6[1u].x);
- float4 v_6 = float4(v_4, v_5, asfloat(x_6[1u].x), 3.0f);
- float4 v_7 = smoothstep(v_6, (1.0f).xxxx, v0);
- v1[x_83] = v_7[a];
- }
- {
- c = (c + 1);
- }
- continue;
- }
- }
- {
- a = (a + 1);
- }
- continue;
- }
- }
- float v_8 = v1.x;
- if ((v_8 == asfloat(x_6[0u].x))) {
- float v_9 = float(asint(x_10[1u].x));
- float v_10 = float(asint(x_10[3u].x));
- float v_11 = float(asint(x_10[3u].x));
- x_GLF_color = float4(v_9, v_10, v_11, float(asint(x_10[1u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_10[3u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_12 = {x_GLF_color};
- return v_12;
-}
-
-main_outputs main() {
- main_out v_13 = main_inner();
- main_outputs v_14 = {v_13.x_GLF_color_1};
- return v_14;
-}
-
-FXC validation failure:
-<scrubbed_path>(42,11-18): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(34,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(26,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index fe1be4e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-nested-loop-undefined-smoothstep-never-executed/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,114 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b0) {
- uint4 x_6[2];
-};
-cbuffer cbuffer_x_10 : register(b1) {
- uint4 x_10[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 v0 = (0.0f).xxxx;
- float4 v1 = (0.0f).xxxx;
- int a = 0;
- int c = 0;
- float x_41 = asfloat(x_6[1u].x);
- v0 = float4(x_41, x_41, x_41, x_41);
- float x_44 = asfloat(x_6[0u].x);
- v1 = float4(x_44, x_44, x_44, x_44);
- int x_47 = asint(x_10[1u].x);
- a = x_47;
- {
- while(true) {
- int x_52 = a;
- int x_54 = asint(x_10[0u].x);
- if ((x_52 < x_54)) {
- } else {
- break;
- }
- int x_58 = asint(x_10[3u].x);
- c = x_58;
- {
- while(true) {
- int x_63 = c;
- int x_65 = asint(x_10[2u].x);
- if ((x_63 < x_65)) {
- } else {
- break;
- }
- int x_68 = c;
- int x_69 = min(max(x_68, 0), 3);
- float x_71 = asfloat(x_6[1u].x);
- float x_73 = v0[x_69];
- v0[x_69] = (x_73 - x_71);
- int x_77 = asint(x_10[1u].x);
- int x_79 = asint(x_10[3u].x);
- if ((x_77 == x_79)) {
- int x_83 = a;
- float x_85 = asfloat(x_6[1u].x);
- float x_87 = asfloat(x_6[1u].x);
- float x_89 = asfloat(x_6[1u].x);
- float4 x_91 = v0;
- int x_93 = a;
- v1[x_83] = smoothstep(float4(x_85, x_87, x_89, 3.0f), (1.0f).xxxx, x_91)[x_93];
- }
- {
- int x_96 = c;
- c = (x_96 + 1);
- }
- continue;
- }
- }
- {
- int x_98 = a;
- a = (x_98 + 1);
- }
- continue;
- }
- }
- float x_101 = v1.x;
- float x_103 = asfloat(x_6[0u].x);
- if ((x_101 == x_103)) {
- int x_109 = asint(x_10[1u].x);
- int x_112 = asint(x_10[3u].x);
- int x_115 = asint(x_10[3u].x);
- int x_118 = asint(x_10[1u].x);
- float v = float(x_109);
- float v_1 = float(x_112);
- float v_2 = float(x_115);
- x_GLF_color = float4(v, v_1, v_2, float(x_118));
- } else {
- int x_122 = asint(x_10[3u].x);
- float x_123 = float(x_122);
- x_GLF_color = float4(x_123, x_123, x_123, x_123);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_3 = {x_GLF_color};
- return v_3;
-}
-
-main_outputs main() {
- main_out v_4 = main_inner();
- main_outputs v_5 = {v_4.x_GLF_color_1};
- return v_5;
-}
-
-FXC validation failure:
-<scrubbed_path>(50,11-18): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(39,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(29,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index e812c4c..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,91 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_5 : register(b0) {
- uint4 x_5[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2x2 m = float2x2((0.0f).xx, (0.0f).xx);
- float f = 0.0f;
- int i = 0;
- int j = 0;
- if ((asint(x_5[1u].x) == 1)) {
- float2 v = float2(f, 0.0f);
- m = float2x2(v, float2(0.0f, f));
- }
- i = asint(x_5[1u].x);
- {
- while(true) {
- int v_1 = i;
- if ((v_1 < asint(x_5[0u].x))) {
- } else {
- break;
- }
- j = asint(x_5[1u].x);
- {
- while(true) {
- int v_2 = j;
- if ((v_2 < asint(x_5[0u].x))) {
- } else {
- break;
- }
- int x_66 = i;
- int x_67 = j;
- int v_3 = i;
- int v_4 = (v_3 * asint(x_5[0u].x));
- m[x_66][x_67] = float((v_4 + j));
- {
- j = (j + 1);
- }
- continue;
- }
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- float v_5 = float(asint(x_5[1u].x));
- float2 v_6 = float2(v_5, float(asint(x_5[2u].x)));
- float v_7 = float(asint(x_5[0u].x));
- float2x2 x_95 = float2x2(v_6, float2(v_7, float(asint(x_5[3u].x))));
- bool v_8 = all((m[0u] == x_95[0u]));
- if ((v_8 & all((m[1u] == x_95[1u])))) {
- float v_9 = float(asint(x_5[2u].x));
- float v_10 = float(asint(x_5[1u].x));
- float v_11 = float(asint(x_5[1u].x));
- x_GLF_color = float4(v_9, v_10, v_11, float(asint(x_5[2u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_5[1u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_12 = {x_GLF_color};
- return v_12;
-}
-
-main_outputs main() {
- main_out v_13 = main_inner();
- main_outputs v_14 = {v_13.x_GLF_color_1};
- return v_14;
-}
-
-FXC validation failure:
-<scrubbed_path>(43,11-17): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(33,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(25,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index c1d51cb..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-reinitialize-matrix-after-undefined-value/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,111 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_5 : register(b0) {
- uint4 x_5[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float2x2 m = float2x2((0.0f).xx, (0.0f).xx);
- float f = 0.0f;
- int i = 0;
- int j = 0;
- int x_36 = asint(x_5[1u].x);
- if ((x_36 == 1)) {
- float x_40 = f;
- float2 v = float2(x_40, 0.0f);
- m = float2x2(v, float2(0.0f, x_40));
- }
- int x_45 = asint(x_5[1u].x);
- i = x_45;
- {
- while(true) {
- int x_50 = i;
- int x_52 = asint(x_5[0u].x);
- if ((x_50 < x_52)) {
- } else {
- break;
- }
- int x_56 = asint(x_5[1u].x);
- j = x_56;
- {
- while(true) {
- int x_61 = j;
- int x_63 = asint(x_5[0u].x);
- if ((x_61 < x_63)) {
- } else {
- break;
- }
- int x_66 = i;
- int x_67 = j;
- int x_68 = i;
- int x_70 = asint(x_5[0u].x);
- int x_72 = j;
- m[x_66][x_67] = float(((x_68 * x_70) + x_72));
- {
- int x_76 = j;
- j = (x_76 + 1);
- }
- continue;
- }
- }
- {
- int x_78 = i;
- i = (x_78 + 1);
- }
- continue;
- }
- }
- float2x2 x_80 = m;
- int x_82 = asint(x_5[1u].x);
- int x_85 = asint(x_5[2u].x);
- int x_88 = asint(x_5[0u].x);
- int x_91 = asint(x_5[3u].x);
- float v_1 = float(x_82);
- float2 v_2 = float2(v_1, float(x_85));
- float v_3 = float(x_88);
- float2x2 x_95 = float2x2(v_2, float2(v_3, float(x_91)));
- bool v_4 = all((x_80[0u] == x_95[0u]));
- if ((v_4 & all((x_80[1u] == x_95[1u])))) {
- int x_109 = asint(x_5[2u].x);
- int x_112 = asint(x_5[1u].x);
- int x_115 = asint(x_5[1u].x);
- int x_118 = asint(x_5[2u].x);
- float v_5 = float(x_109);
- float v_6 = float(x_112);
- float v_7 = float(x_115);
- x_GLF_color = float4(v_5, v_6, v_7, float(x_118));
- } else {
- int x_122 = asint(x_5[1u].x);
- float x_123 = float(x_122);
- x_GLF_color = float4(x_123, x_123, x_123, x_123);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_8 = {x_GLF_color};
- return v_8;
-}
-
-main_outputs main() {
- main_out v_9 = main_inner();
- main_outputs v_10 = {v_9.x_GLF_color_1};
- return v_10;
-}
-
-FXC validation failure:
-<scrubbed_path>(50,11-17): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(38,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(28,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 590f760..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,70 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int4 a = (0).xxxx;
- int i = 0;
- int sum = 0;
- a = (0).xxxx;
- i = 0;
- {
- while(true) {
- int v = i;
- if ((v < (asint(x_7[0u].w) + 1))) {
- } else {
- break;
- }
- int v_1 = i;
- int v_2 = asint(x_7[0u].x);
- int v_3 = i;
- uint v_4 = (uint(min(max(v_1, v_2), v_3)) * 4u);
- if ((asint(x_7[(v_4 / 16u)][((v_4 % 16u) / 4u)]) == 1)) {
- int x_57 = i;
- a[x_57] = 5;
- } else {
- int x_59 = i;
- a[x_59] = i;
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- sum = (((a.x + a.y) + a.z) + a.w);
- if ((sum == 10)) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- } else {
- x_GLF_color = (0.0f).xxxx;
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_5 = {x_GLF_color};
- return v_5;
-}
-
-main_outputs main() {
- main_out v_6 = main_inner();
- main_outputs v_7 = {v_6.x_GLF_color_1};
- return v_7;
-}
-
-FXC validation failure:
-<scrubbed_path>(21,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 0c15cfa..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,79 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int4 a = (0).xxxx;
- int i = 0;
- int sum = 0;
- a = (0).xxxx;
- i = 0;
- {
- while(true) {
- int x_40 = i;
- int x_42 = asint(x_7[0u].w);
- if ((x_40 < (x_42 + 1))) {
- } else {
- break;
- }
- int x_46 = i;
- int x_48 = asint(x_7[0u].x);
- int x_49 = i;
- uint v = (uint(min(max(x_46, x_48), x_49)) * 4u);
- int x_52 = asint(x_7[(v / 16u)][((v % 16u) / 4u)]);
- if ((x_52 == 1)) {
- int x_57 = i;
- a[x_57] = 5;
- } else {
- int x_59 = i;
- int x_60 = i;
- a[x_59] = x_60;
- }
- {
- int x_62 = i;
- i = (x_62 + 1);
- }
- continue;
- }
- }
- int x_65 = a.x;
- int x_67 = a.y;
- int x_70 = a.z;
- int x_73 = a.w;
- sum = (((x_65 + x_67) + x_70) + x_73);
- int x_75 = sum;
- if ((x_75 == 10)) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- } else {
- x_GLF_color = (0.0f).xxxx;
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_1 = {x_GLF_color};
- return v_1;
-}
-
-main_outputs main() {
- main_out v_2 = main_inner();
- main_outputs v_3 = {v_2.x_GLF_color_1};
- return v_3;
-}
-
-FXC validation failure:
-<scrubbed_path>(21,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 3c75f33..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,105 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[2];
-};
-cbuffer cbuffer_x_11 : register(b1) {
- uint4 x_11[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 color = (0.0f).xxxx;
- int i = 0;
- int j = 0;
- int k = 0;
- color = (1.0f).xxxx;
- i = asint(x_7[0u].x);
- {
- while(true) {
- int v = i;
- if ((v < asint(x_7[1u].x))) {
- } else {
- break;
- }
- int x_47 = i;
- switch(x_47) {
- case 2:
- {
- int x_83 = i;
- color[x_83] = asfloat(x_11[0u].x);
- break;
- }
- case 1:
- {
- j = asint(x_7[0u].x);
- {
- while(true) {
- if ((i > i)) {
- } else {
- break;
- }
- k = asint(x_7[0u].x);
- {
- while(true) {
- if ((k < i)) {
- } else {
- break;
- }
- int x_71 = k;
- color[x_71] = asfloat(x_11[0u].x);
- {
- k = (k + 1);
- }
- continue;
- }
- }
- {
- j = (j + 1);
- }
- continue;
- }
- }
- int x_79 = i;
- color[x_79] = asfloat(x_11[0u].x);
- break;
- }
- default:
- {
- break;
- }
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- x_GLF_color = color;
-}
-
-main_out main_inner() {
- main_1();
- main_out v_1 = {x_GLF_color};
- return v_1;
-}
-
-main_outputs main() {
- main_out v_2 = main_inner();
- main_outputs v_3 = {v_2.x_GLF_color_1};
- return v_3;
-}
-
-FXC validation failure:
-<scrubbed_path>(25,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index d4c544a..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-tail-duplicator-for-for-for/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,120 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[2];
-};
-cbuffer cbuffer_x_11 : register(b1) {
- uint4 x_11[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4 color = (0.0f).xxxx;
- int i = 0;
- int j = 0;
- int k = 0;
- color = (1.0f).xxxx;
- int x_37 = asint(x_7[0u].x);
- i = x_37;
- {
- while(true) {
- int x_42 = i;
- int x_44 = asint(x_7[1u].x);
- if ((x_42 < x_44)) {
- } else {
- break;
- }
- int x_47 = i;
- switch(x_47) {
- case 2:
- {
- int x_83 = i;
- float x_85 = asfloat(x_11[0u].x);
- color[x_83] = x_85;
- break;
- }
- case 1:
- {
- int x_52 = asint(x_7[0u].x);
- j = x_52;
- {
- while(true) {
- int x_57 = i;
- int x_58 = i;
- if ((x_57 > x_58)) {
- } else {
- break;
- }
- int x_62 = asint(x_7[0u].x);
- k = x_62;
- {
- while(true) {
- int x_67 = k;
- int x_68 = i;
- if ((x_67 < x_68)) {
- } else {
- break;
- }
- int x_71 = k;
- float x_73 = asfloat(x_11[0u].x);
- color[x_71] = x_73;
- {
- int x_75 = k;
- k = (x_75 + 1);
- }
- continue;
- }
- }
- {
- int x_77 = j;
- j = (x_77 + 1);
- }
- continue;
- }
- }
- int x_79 = i;
- float x_81 = asfloat(x_11[0u].x);
- color[x_79] = x_81;
- break;
- }
- default:
- {
- break;
- }
- }
- {
- int x_87 = i;
- i = (x_87 + 1);
- }
- continue;
- }
- }
- float4 x_89 = color;
- x_GLF_color = x_89;
-}
-
-main_out main_inner() {
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main() {
- main_out v_1 = main_inner();
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(26,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 69df49a..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,105 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b1) {
- uint4 x_6[4];
-};
-cbuffer cbuffer_x_10 : register(b0) {
- uint4 x_10[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-int tint_mod_i32(int lhs, int rhs) {
- int v = ((((rhs == 0) | ((lhs == -2147483648) & (rhs == -1)))) ? (1) : (rhs));
- return (lhs - ((lhs / v) * v));
-}
-
-void main_1() {
- float4x4 m0 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int c = 0;
- float4x4 m1 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- float x_41 = float(asint(x_6[1u].x));
- float4 v_1 = float4(x_41, 0.0f, 0.0f, 0.0f);
- float4 v_2 = float4(0.0f, x_41, 0.0f, 0.0f);
- float4 v_3 = float4(0.0f, 0.0f, x_41, 0.0f);
- m0 = float4x4(v_1, v_2, v_3, float4(0.0f, 0.0f, 0.0f, x_41));
- c = asint(x_6[2u].x);
- {
- while(true) {
- int v_4 = c;
- if ((v_4 < asint(x_6[0u].x))) {
- } else {
- break;
- }
- m1 = m0;
- int x_59 = c;
- int x_61 = asint(x_6[3u].x);
- int x_64 = asint(x_6[2u].x);
- float4 v_5 = m1[tint_mod_i32(x_59, x_61)];
- v_5[x_64] = asfloat(x_10[0u].x);
- int x_68 = c;
- int x_70 = asint(x_6[3u].x);
- int x_73 = asint(x_6[2u].x);
- float4 v_6 = m0[tint_mod_i32(x_68, x_70)];
- v_6[x_73] = asfloat(x_10[0u].x);
- {
- c = (c + 1);
- }
- continue;
- }
- }
- float v_7 = float(asint(x_6[1u].x));
- float v_8 = float(asint(x_6[2u].x));
- float v_9 = float(asint(x_6[1u].x));
- float4 v_10 = float4(v_7, v_8, v_9, float(asint(x_6[1u].x)));
- float v_11 = float(asint(x_6[1u].x));
- float v_12 = float(asint(x_6[2u].x));
- float v_13 = float(asint(x_6[1u].x));
- float4 v_14 = float4(v_11, v_12, v_13, float(asint(x_6[1u].x)));
- float v_15 = float(asint(x_6[1u].x));
- float v_16 = float(asint(x_6[2u].x));
- float v_17 = float(asint(x_6[1u].x));
- float4 v_18 = float4(v_15, v_16, v_17, float(asint(x_6[1u].x)));
- float v_19 = float(asint(x_6[1u].x));
- float v_20 = float(asint(x_6[2u].x));
- float v_21 = float(asint(x_6[1u].x));
- float4x4 x_132 = float4x4(v_10, v_14, v_18, float4(v_19, v_20, v_21, float(asint(x_6[1u].x))));
- bool v_22 = all((m0[0u] == x_132[0u]));
- bool v_23 = (v_22 & all((m0[1u] == x_132[1u])));
- bool v_24 = (v_23 & all((m0[2u] == x_132[2u])));
- if ((v_24 & all((m0[3u] == x_132[3u])))) {
- float v_25 = float(asint(x_6[2u].x));
- float v_26 = float(asint(x_6[1u].x));
- float v_27 = float(asint(x_6[1u].x));
- x_GLF_color = float4(v_25, v_26, v_27, float(asint(x_6[2u].x)));
- } else {
- x_GLF_color = float4((float(asint(x_6[1u].x))).xxxx);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_28 = {x_GLF_color};
- return v_28;
-}
-
-main_outputs main() {
- main_out v_29 = main_inner();
- main_outputs v_30 = {v_29.x_GLF_color_1};
- return v_30;
-}
-
-FXC validation failure:
-<scrubbed_path>(19,19-25): warning X3556: integer divides may be much slower, try using uints if possible.
-<scrubbed_path>(44,7-15): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(33,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 1c59b70..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-unused-matrix-copy-inside-loop/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,133 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_6 : register(b1) {
- uint4 x_6[4];
-};
-cbuffer cbuffer_x_10 : register(b0) {
- uint4 x_10[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-int tint_mod_i32(int lhs, int rhs) {
- int v = ((((rhs == 0) | ((lhs == -2147483648) & (rhs == -1)))) ? (1) : (rhs));
- return (lhs - ((lhs / v) * v));
-}
-
-void main_1() {
- float4x4 m0 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int c = 0;
- float4x4 m1 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int x_40 = asint(x_6[1u].x);
- float x_41 = float(x_40);
- float4 v_1 = float4(x_41, 0.0f, 0.0f, 0.0f);
- float4 v_2 = float4(0.0f, x_41, 0.0f, 0.0f);
- float4 v_3 = float4(0.0f, 0.0f, x_41, 0.0f);
- m0 = float4x4(v_1, v_2, v_3, float4(0.0f, 0.0f, 0.0f, x_41));
- int x_48 = asint(x_6[2u].x);
- c = x_48;
- {
- while(true) {
- int x_53 = c;
- int x_55 = asint(x_6[0u].x);
- if ((x_53 < x_55)) {
- } else {
- break;
- }
- float4x4 x_58 = m0;
- m1 = x_58;
- int x_59 = c;
- int x_61 = asint(x_6[3u].x);
- int x_64 = asint(x_6[2u].x);
- float x_66 = asfloat(x_10[0u].x);
- m1[tint_mod_i32(x_59, x_61)][x_64] = x_66;
- int x_68 = c;
- int x_70 = asint(x_6[3u].x);
- int x_73 = asint(x_6[2u].x);
- float x_75 = asfloat(x_10[0u].x);
- m0[tint_mod_i32(x_68, x_70)][x_73] = x_75;
- {
- int x_77 = c;
- c = (x_77 + 1);
- }
- continue;
- }
- }
- float4x4 x_79 = m0;
- int x_81 = asint(x_6[1u].x);
- int x_84 = asint(x_6[2u].x);
- int x_87 = asint(x_6[1u].x);
- int x_90 = asint(x_6[1u].x);
- int x_93 = asint(x_6[1u].x);
- int x_96 = asint(x_6[2u].x);
- int x_99 = asint(x_6[1u].x);
- int x_102 = asint(x_6[1u].x);
- int x_105 = asint(x_6[1u].x);
- int x_108 = asint(x_6[2u].x);
- int x_111 = asint(x_6[1u].x);
- int x_114 = asint(x_6[1u].x);
- int x_117 = asint(x_6[1u].x);
- int x_120 = asint(x_6[2u].x);
- int x_123 = asint(x_6[1u].x);
- int x_126 = asint(x_6[1u].x);
- float v_4 = float(x_81);
- float v_5 = float(x_84);
- float v_6 = float(x_87);
- float4 v_7 = float4(v_4, v_5, v_6, float(x_90));
- float v_8 = float(x_93);
- float v_9 = float(x_96);
- float v_10 = float(x_99);
- float4 v_11 = float4(v_8, v_9, v_10, float(x_102));
- float v_12 = float(x_105);
- float v_13 = float(x_108);
- float v_14 = float(x_111);
- float4 v_15 = float4(v_12, v_13, v_14, float(x_114));
- float v_16 = float(x_117);
- float v_17 = float(x_120);
- float v_18 = float(x_123);
- float4x4 x_132 = float4x4(v_7, v_11, v_15, float4(v_16, v_17, v_18, float(x_126)));
- bool v_19 = all((x_79[0u] == x_132[0u]));
- bool v_20 = (v_19 & all((x_79[1u] == x_132[1u])));
- bool v_21 = (v_20 & all((x_79[2u] == x_132[2u])));
- if ((v_21 & all((x_79[3u] == x_132[3u])))) {
- int x_156 = asint(x_6[2u].x);
- int x_159 = asint(x_6[1u].x);
- int x_162 = asint(x_6[1u].x);
- int x_165 = asint(x_6[2u].x);
- float v_22 = float(x_156);
- float v_23 = float(x_159);
- float v_24 = float(x_162);
- x_GLF_color = float4(v_22, v_23, v_24, float(x_165));
- } else {
- int x_169 = asint(x_6[1u].x);
- float x_170 = float(x_169);
- x_GLF_color = float4(x_170, x_170, x_170, x_170);
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_25 = {x_GLF_color};
- return v_25;
-}
-
-main_outputs main() {
- main_out v_26 = main_inner();
- main_outputs v_27 = {v_26.x_GLF_color_1};
- return v_27;
-}
-
-FXC validation failure:
-<scrubbed_path>(19,19-25): warning X3556: integer divides may be much slower, try using uints if possible.
-<scrubbed_path>(48,7-34): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(35,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index 0673328..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,114 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-static float4 gl_FragCoord = (0.0f).xxxx;
-static bool continue_execution = true;
-int tint_f32_to_i32(float value) {
- return (((value <= 2147483520.0f)) ? ((((value >= -2147483648.0f)) ? (int(value)) : (-2147483648))) : (2147483647));
-}
-
-void main_1() {
- float2 v = (0.0f).xx;
- float floats[9] = (float[9])0;
- int one = 0;
- int i = 0;
- bool alwaysFalse = false;
- v = (0.0f).xx;
- floats[1] = 0.0f;
- one = tint_f32_to_i32(asfloat(x_9[0u].y));
- {
- while(true) {
- i = 0;
- {
- while(true) {
- if ((i < one)) {
- } else {
- break;
- }
- if ((i == 0)) {
- float v_1 = asfloat(x_9[0u].x);
- alwaysFalse = (v_1 > asfloat(x_9[0u].y));
- if (!(alwaysFalse)) {
- int x_73 = one;
- floats[x_73] = 1.0f;
- x_GLF_color = float4(1.0f, 1.0f, 0.0f, 1.0f);
- }
- int x_75 = one;
- v[x_75] = 1.0f;
- if (alwaysFalse) {
- continue_execution = false;
- }
- if ((asfloat(x_9[0u].y) < 0.0f)) {
- x_GLF_color = float4(0.0f, 1.0f, 0.0f, 1.0f);
- }
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- {
- int x_87 = one;
- if (!((x_87 < 0))) { break; }
- }
- continue;
- }
- }
- bool x_102 = false;
- bool x_103 = false;
- if ((gl_FragCoord.y >= 0.0f)) {
- bool x_97 = (v.y == 1.0f);
- x_103 = x_97;
- if (x_97) {
- x_102 = (floats[1] == 1.0f);
- x_103 = x_102;
- }
- if (x_103) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- }
- } else {
- x_GLF_color = (0.0f).xxxx;
- }
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_2 = {x_GLF_color};
- return v_2;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_3 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_4 = {v_3.x_GLF_color_1};
- if (!(continue_execution)) {
- discard;
- }
- main_outputs v_5 = v_4;
- return v_5;
-}
-
-FXC validation failure:
-<scrubbed_path>(51,13-19): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(37,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(34,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index f2c5dab..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/create-color-in-do-while-for-loop/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,127 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-static float4 gl_FragCoord = (0.0f).xxxx;
-static bool continue_execution = true;
-int tint_f32_to_i32(float value) {
- return (((value <= 2147483520.0f)) ? ((((value >= -2147483648.0f)) ? (int(value)) : (-2147483648))) : (2147483647));
-}
-
-void main_1() {
- float2 v = (0.0f).xx;
- float floats[9] = (float[9])0;
- int one = 0;
- int i = 0;
- bool alwaysFalse = false;
- v = (0.0f).xx;
- floats[1] = 0.0f;
- float x_46 = asfloat(x_9[0u].y);
- one = tint_f32_to_i32(x_46);
- {
- while(true) {
- i = 0;
- {
- while(true) {
- int x_56 = i;
- int x_57 = one;
- if ((x_56 < x_57)) {
- } else {
- break;
- }
- int x_60 = i;
- if ((x_60 == 0)) {
- float x_65 = asfloat(x_9[0u].x);
- float x_67 = asfloat(x_9[0u].y);
- alwaysFalse = (x_65 > x_67);
- bool x_69 = alwaysFalse;
- if (!(x_69)) {
- int x_73 = one;
- floats[x_73] = 1.0f;
- x_GLF_color = float4(1.0f, 1.0f, 0.0f, 1.0f);
- }
- int x_75 = one;
- v[x_75] = 1.0f;
- bool x_77 = alwaysFalse;
- if (x_77) {
- continue_execution = false;
- }
- float x_81 = asfloat(x_9[0u].y);
- if ((x_81 < 0.0f)) {
- x_GLF_color = float4(0.0f, 1.0f, 0.0f, 1.0f);
- }
- }
- {
- int x_85 = i;
- i = (x_85 + 1);
- }
- continue;
- }
- }
- {
- int x_87 = one;
- if (!((x_87 < 0))) { break; }
- }
- continue;
- }
- }
- bool x_102 = false;
- bool x_103_phi = false;
- float x_90 = gl_FragCoord.y;
- if ((x_90 >= 0.0f)) {
- float x_96 = v.y;
- bool x_97 = (x_96 == 1.0f);
- x_103_phi = x_97;
- if (x_97) {
- float x_101 = floats[1];
- x_102 = (x_101 == 1.0f);
- x_103_phi = x_102;
- }
- bool x_103 = x_103_phi;
- if (x_103) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- }
- } else {
- x_GLF_color = (0.0f).xxxx;
- }
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_1 = {x_GLF_color};
- return v_1;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_2 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_3 = {v_2.x_GLF_color_1};
- if (!(continue_execution)) {
- discard;
- }
- main_outputs v_4 = v_3;
- return v_4;
-}
-
-FXC validation failure:
-<scrubbed_path>(57,13-19): error X3500: array reference cannot be used as an l-value; not natively addressable
-<scrubbed_path>(38,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(35,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index ac5ea90..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,90 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-static float4 gl_FragCoord = (0.0f).xxxx;
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4x4 m44 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int x_10 = 0;
- m44 = float4x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f), float4(9.0f, 10.0f, 11.0f, 12.0f), float4(13.0f, 14.0f, 15.0f, 16.0f));
- x_10 = 0;
- {
- while(true) {
- int x_11 = 0;
- int x_9 = 0;
- if ((x_10 < 4)) {
- } else {
- break;
- }
- if ((gl_FragCoord.y < 0.0f)) {
- break;
- }
- x_11 = 0;
- {
- while(true) {
- int x_8 = 0;
- if ((x_11 < 4)) {
- } else {
- break;
- }
- {
- float4 v = m44[x_10];
- int v_1 = x_11;
- float v_2 = m44[x_10][x_11];
- v[v_1] = (v_2 + asfloat(x_7[0u].x));
- x_8 = (x_11 + 1);
- x_11 = x_8;
- }
- continue;
- }
- }
- {
- x_9 = (x_10 + 1);
- x_10 = x_9;
- }
- continue;
- }
- }
- float x_77 = m44[1].y;
- float4 x_79_1 = (0.0f).xxxx;
- x_79_1[0u] = (x_77 - 6.0f);
- float4 x_79 = x_79_1;
- float x_81 = m44[2].z;
- float4 x_83_1 = x_79;
- x_83_1[3u] = (x_81 - 11.0f);
- x_GLF_color = x_83_1;
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_3 = {x_GLF_color};
- return v_3;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_4 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_5 = {v_4.x_GLF_color_1};
- return v_5;
-}
-
-FXC validation failure:
-<scrubbed_path>(25,5-15): error X3511: unable to unroll loop, loop does not appear to terminate in a timely manner (435 iterations) or unrolled loop is too large, use the [unroll(n)] attribute to force an exact higher number
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 123414e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/nested-for-break-mat-color/0.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,93 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-static float4 gl_FragCoord = (0.0f).xxxx;
-cbuffer cbuffer_x_7 : register(b0) {
- uint4 x_7[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- float4x4 m44 = float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx);
- int x_10_phi = 0;
- m44 = float4x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f), float4(9.0f, 10.0f, 11.0f, 12.0f), float4(13.0f, 14.0f, 15.0f, 16.0f));
- x_10_phi = 0;
- {
- while(true) {
- int x_9 = 0;
- int x_11_phi = 0;
- int x_10 = x_10_phi;
- if ((x_10 < 4)) {
- } else {
- break;
- }
- float x_63 = gl_FragCoord.y;
- if ((x_63 < 0.0f)) {
- break;
- }
- x_11_phi = 0;
- {
- while(true) {
- int x_8 = 0;
- int x_11 = x_11_phi;
- if ((x_11 < 4)) {
- } else {
- break;
- }
- {
- float x_72 = asfloat(x_7[0u].x);
- float x_74 = m44[x_10][x_11];
- m44[x_10][x_11] = (x_74 + x_72);
- x_8 = (x_11 + 1);
- x_11_phi = x_8;
- }
- continue;
- }
- }
- {
- x_9 = (x_10 + 1);
- x_10_phi = x_9;
- }
- continue;
- }
- }
- float x_77 = m44[1].y;
- float4 x_79_1 = (0.0f).xxxx;
- x_79_1[0u] = (x_77 - 6.0f);
- float4 x_79 = x_79_1;
- float x_81 = m44[2].z;
- float4 x_83_1 = x_79;
- x_83_1[3u] = (x_81 - 11.0f);
- float4 x_83 = x_83_1;
- x_GLF_color = x_83;
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_1 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(25,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index c73e49a..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,127 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_13 : register(b0) {
- uint4 x_13[1];
-};
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-int tint_mod_i32(int lhs, int rhs) {
- int v = ((((rhs == 0) | ((lhs == -2147483648) & (rhs == -1)))) ? (1) : (rhs));
- return (lhs - ((lhs / v) * v));
-}
-
-float compute_value_f1_f1_(inout float limit, inout float thirty_two) {
- float result = 0.0f;
- int i = 0;
- result = -0.5f;
- i = 1;
- {
- while(true) {
- if ((i < 800)) {
- } else {
- break;
- }
- if ((tint_mod_i32(i, 32) == 0)) {
- result = (result + 0.40000000596046447754f);
- } else {
- float x_149 = thirty_two;
- float v_1 = float(i);
- float v_2 = round(x_149);
- float v_3 = float(i);
- if (((v_1 - (v_2 * floor((v_3 / round(x_149))))) <= 0.00999999977648258209f)) {
- result = (result + 100.0f);
- }
- }
- float v_4 = float(i);
- if ((v_4 >= limit)) {
- float x_163 = result;
- return x_163;
- }
- {
- i = (i + 1);
- }
- continue;
- }
- }
- float x_166 = result;
- return x_166;
-}
-
-void main_1() {
- float3 c = (0.0f).xxx;
- float thirty_two_1 = 0.0f;
- float param = 0.0f;
- float param_1 = 0.0f;
- float param_2 = 0.0f;
- float param_3 = 0.0f;
- int i_1 = 0;
- c = float3(7.0f, 8.0f, 9.0f);
- thirty_two_1 = round((asfloat(x_13[0u].x) / 8.0f));
- param = gl_FragCoord.x;
- param_1 = thirty_two_1;
- float x_69 = compute_value_f1_f1_(param, param_1);
- c[0u] = x_69;
- param_2 = gl_FragCoord.y;
- param_3 = thirty_two_1;
- float x_74 = compute_value_f1_f1_(param_2, param_3);
- c[1u] = x_74;
- float2 v_5 = float2(c.x, c.y);
- float4x2 x_87 = float4x2(v_5, float2(c.z, 1.0f), float2(1.0f, 0.0f), float2(1.0f, 0.0f));
- float v_6 = mul(float3x3(float3(1.0f, 0.0f, 0.0f), float3(0.0f, 1.0f, 0.0f), float3(0.0f, 0.0f, 1.0f)), c)[0u];
- c[2u] = (v_6 + float3(x_87[0u][0u], x_87[0u][1u], x_87[1u][0u])[1u]);
- i_1 = 0;
- {
- while(true) {
- if ((i_1 < 3)) {
- } else {
- break;
- }
- if ((c[i_1] >= 1.0f)) {
- int x_108 = i_1;
- c[x_108] = (c[i_1] * c[i_1]);
- if ((gl_FragCoord.y < 0.0f)) {
- break;
- }
- }
- {
- i_1 = (i_1 + 1);
- }
- continue;
- }
- }
- float3 x_126 = normalize(abs(c));
- x_GLF_color = float4(x_126[0u], x_126[1u], x_126[2u], 1.0f);
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_7 = {x_GLF_color};
- return v_7;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_8 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_9 = {v_8.x_GLF_color_1};
- return v_9;
-}
-
-FXC validation failure:
-<scrubbed_path>(21,19-25): warning X3556: integer divides may be much slower, try using uints if possible.
-<scrubbed_path>(85,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 6757463..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/stable-colorgrid-modulo-vec3-values-from-matrix/1.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,151 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-struct main_inputs {
- float4 gl_FragCoord_param : SV_Position;
-};
-
-
-cbuffer cbuffer_x_13 : register(b0) {
- uint4 x_13[1];
-};
-static float4 gl_FragCoord = (0.0f).xxxx;
-static float4 x_GLF_color = (0.0f).xxxx;
-int tint_mod_i32(int lhs, int rhs) {
- int v = ((((rhs == 0) | ((lhs == -2147483648) & (rhs == -1)))) ? (1) : (rhs));
- return (lhs - ((lhs / v) * v));
-}
-
-float compute_value_f1_f1_(inout float limit, inout float thirty_two) {
- float result = 0.0f;
- int i = 0;
- result = -0.5f;
- i = 1;
- {
- while(true) {
- int x_136 = i;
- if ((x_136 < 800)) {
- } else {
- break;
- }
- int x_139 = i;
- if ((tint_mod_i32(x_139, 32) == 0)) {
- float x_145 = result;
- result = (x_145 + 0.40000000596046447754f);
- } else {
- int x_147 = i;
- float x_149 = thirty_two;
- float v_1 = float(x_147);
- float v_2 = round(x_149);
- float v_3 = float(x_147);
- if (((v_1 - (v_2 * floor((v_3 / round(x_149))))) <= 0.00999999977648258209f)) {
- float x_155 = result;
- result = (x_155 + 100.0f);
- }
- }
- int x_157 = i;
- float x_159 = limit;
- if ((float(x_157) >= x_159)) {
- float x_163 = result;
- return x_163;
- }
- {
- int x_164 = i;
- i = (x_164 + 1);
- }
- continue;
- }
- }
- float x_166 = result;
- return x_166;
-}
-
-void main_1() {
- float3 c = (0.0f).xxx;
- float thirty_two_1 = 0.0f;
- float param = 0.0f;
- float param_1 = 0.0f;
- float param_2 = 0.0f;
- float param_3 = 0.0f;
- int i_1 = 0;
- c = float3(7.0f, 8.0f, 9.0f);
- float x_63 = asfloat(x_13[0u].x);
- thirty_two_1 = round((x_63 / 8.0f));
- float x_67 = gl_FragCoord.x;
- param = x_67;
- float x_68 = thirty_two_1;
- param_1 = x_68;
- float x_69 = compute_value_f1_f1_(param, param_1);
- c[0u] = x_69;
- float x_72 = gl_FragCoord.y;
- param_2 = x_72;
- float x_73 = thirty_two_1;
- param_3 = x_73;
- float x_74 = compute_value_f1_f1_(param_2, param_3);
- c[1u] = x_74;
- float3 x_76 = c;
- float3 x_79 = c;
- float2 v_4 = float2(x_79[0u], x_79[1u]);
- float4x2 x_87 = float4x2(v_4, float2(x_79[2u], 1.0f), float2(1.0f, 0.0f), float2(1.0f, 0.0f));
- float v_5 = mul(float3x3(float3(1.0f, 0.0f, 0.0f), float3(0.0f, 1.0f, 0.0f), float3(0.0f, 0.0f, 1.0f)), x_76)[0u];
- c[2u] = (v_5 + float3(x_87[0u][0u], x_87[0u][1u], x_87[1u][0u])[1u]);
- i_1 = 0;
- {
- while(true) {
- int x_99 = i_1;
- if ((x_99 < 3)) {
- } else {
- break;
- }
- int x_102 = i_1;
- float x_104 = c[x_102];
- if ((x_104 >= 1.0f)) {
- int x_108 = i_1;
- int x_109 = i_1;
- float x_111 = c[x_109];
- int x_112 = i_1;
- float x_114 = c[x_112];
- c[x_108] = (x_111 * x_114);
- float x_118 = gl_FragCoord.y;
- if ((x_118 < 0.0f)) {
- break;
- }
- }
- {
- int x_122 = i_1;
- i_1 = (x_122 + 1);
- }
- continue;
- }
- }
- float3 x_124 = c;
- float3 x_126 = normalize(abs(x_124));
- x_GLF_color = float4(x_126[0u], x_126[1u], x_126[2u], 1.0f);
-}
-
-main_out main_inner(float4 gl_FragCoord_param) {
- gl_FragCoord = gl_FragCoord_param;
- main_1();
- main_out v_6 = {x_GLF_color};
- return v_6;
-}
-
-main_outputs main(main_inputs inputs) {
- main_out v_7 = main_inner(float4(inputs.gl_FragCoord_param.xyz, (1.0f / inputs.gl_FragCoord_param[3u])));
- main_outputs v_8 = {v_7.x_GLF_color_1};
- return v_8;
-}
-
-FXC validation failure:
-<scrubbed_path>(21,19-25): warning X3556: integer divides may be much slower, try using uints if possible.
-<scrubbed_path>(99,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index eaa6d46..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,77 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_8 : register(b0) {
- uint4 x_8[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int x = 0;
- float4 matrix_u = (0.0f).xxxx;
- int b = 0;
- float4 matrix_b = (0.0f).xxxx;
- float4 x_42 = (0.0f).xxxx;
- x = 4;
- {
- while(true) {
- if ((x >= 1)) {
- } else {
- break;
- }
- int x_11 = x;
- matrix_u[x_11] = 1.0f;
- {
- x = (x - 1);
- }
- continue;
- }
- }
- b = 4;
- {
- while(true) {
- if ((asfloat(x_8[0u].x) < -1.0f)) {
- } else {
- break;
- }
- int x_14 = b;
- if ((b > 1)) {
- x_42 = min(matrix_b, matrix_b);
- } else {
- x_42 = matrix_u;
- }
- matrix_b[x_14] = x_42.y;
- {
- b = (b - 1);
- }
- continue;
- }
- }
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-}
-
-main_out main_inner() {
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main() {
- main_out v_1 = main_inner();
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(28,7-20): error X3504: literal loop terminated early due to out of bounds array access
-<scrubbed_path>(22,5-15): warning X3557: loop only executes for 0 iteration(s), forcing loop to unroll
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 5aa7d2e..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/two-loops-matrix/0.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,86 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_8 : register(b0) {
- uint4 x_8[4];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int x = 0;
- float4 matrix_u = (0.0f).xxxx;
- int b = 0;
- float4 matrix_b = (0.0f).xxxx;
- float4 x_42 = (0.0f).xxxx;
- x = 4;
- {
- while(true) {
- int x_10 = x;
- if ((x_10 >= 1)) {
- } else {
- break;
- }
- int x_11 = x;
- matrix_u[x_11] = 1.0f;
- {
- int x_12 = x;
- x = (x_12 - 1);
- }
- continue;
- }
- }
- b = 4;
- {
- while(true) {
- float x_55 = asfloat(x_8[0u].x);
- if ((x_55 < -1.0f)) {
- } else {
- break;
- }
- int x_14 = b;
- int x_15 = b;
- if ((x_15 > 1)) {
- float4 x_62 = matrix_b;
- float4 x_63 = matrix_b;
- x_42 = min(x_62, x_63);
- } else {
- float4 x_65 = matrix_u;
- x_42 = x_65;
- }
- float x_67 = x_42.y;
- matrix_b[x_14] = x_67;
- {
- int x_16 = b;
- b = (x_16 - 1);
- }
- continue;
- }
- }
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
-}
-
-main_out main_inner() {
- main_1();
- main_out v = {x_GLF_color};
- return v;
-}
-
-main_outputs main() {
- main_out v_1 = main_inner();
- main_outputs v_2 = {v_1.x_GLF_color_1};
- return v_2;
-}
-
-FXC validation failure:
-<scrubbed_path>(29,7-20): error X3504: literal loop terminated early due to out of bounds array access
-<scrubbed_path>(22,5-15): warning X3557: loop only executes for 0 iteration(s), forcing loop to unroll
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.spvasm.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.spvasm.expected.ir.fxc.hlsl
deleted file mode 100644
index da28904..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.spvasm.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,115 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int idx = int(0);
- float4x3 m43 = float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int ll_1 = int(0);
- int GLF_live6rows = int(0);
- int z = int(0);
- int ll_2 = int(0);
- int ctr = int(0);
- float4x3 tempm43 = float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int ll_3 = int(0);
- int c = int(0);
- int d = int(0);
- float GLF_live6sums[9] = (float[9])0;
- idx = int(0);
- m43 = float4x3(float3(1.0f, 0.0f, 0.0f), float3(0.0f, 1.0f, 0.0f), float3(0.0f, 0.0f, 1.0f), (0.0f).xxx);
- ll_1 = int(0);
- GLF_live6rows = int(2);
- {
- while(true) {
- int v = ll_1;
- if ((v >= asint(x_9[0u].x))) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- break;
- }
- ll_1 = (ll_1 + int(1));
- z = asint(x_9[0u].x);
- ll_2 = int(0);
- ctr = int(0);
- {
- while(true) {
- if ((ctr < int(1))) {
- } else {
- break;
- }
- int v_1 = ll_2;
- if ((v_1 >= asint(x_9[0u].x))) {
- break;
- }
- ll_2 = (ll_2 + int(1));
- tempm43 = m43;
- ll_3 = int(0);
- c = int(0);
- {
- while(true) {
- if ((int(1) < z)) {
- } else {
- break;
- }
- d = int(0);
- int x_29 = c;
- int x_30 = c;
- int x_31 = c;
- int x_32 = d;
- int x_33 = d;
- int x_34 = d;
- int v_2 = ((((x_29 >= int(0)) & (x_30 < int(4)))) ? (x_31) : (int(0)));
- tempm43[v_2][((((x_32 >= int(0)) & (x_33 < int(3)))) ? (x_34) : (int(0)))] = 1.0f;
- {
- c = (c + int(1));
- }
- continue;
- }
- }
- int x_117 = ((((idx >= int(0)) & (idx < int(9)))) ? (idx) : (int(0)));
- float v_3 = GLF_live6sums[x_117];
- int v_4 = ctr;
- GLF_live6sums[x_117] = (v_3 + m43[v_4].y);
- {
- ctr = (ctr + int(1));
- }
- continue;
- }
- }
- idx = (idx + int(1));
- {
- }
- continue;
- }
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_5 = {x_GLF_color};
- return v_5;
-}
-
-main_outputs main() {
- main_out v_6 = main_inner();
- main_outputs v_7 = {v_6.x_GLF_color_1};
- return v_7;
-}
-
-FXC validation failure:
-<scrubbed_path>(57,13-23): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(43,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(32,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.wgsl.expected.ir.fxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.wgsl.expected.ir.fxc.hlsl
deleted file mode 100644
index 034fa8d..0000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/write-before-break/0-opt.wgsl.expected.ir.fxc.hlsl
+++ /dev/null
@@ -1,130 +0,0 @@
-SKIP: FAILED
-
-struct main_out {
- float4 x_GLF_color_1;
-};
-
-struct main_outputs {
- float4 main_out_x_GLF_color_1 : SV_Target0;
-};
-
-
-cbuffer cbuffer_x_9 : register(b0) {
- uint4 x_9[1];
-};
-static float4 x_GLF_color = (0.0f).xxxx;
-void main_1() {
- int idx = int(0);
- float4x3 m43 = float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int ll_1 = int(0);
- int GLF_live6rows = int(0);
- int z = int(0);
- int ll_2 = int(0);
- int ctr = int(0);
- float4x3 tempm43 = float4x3((0.0f).xxx, (0.0f).xxx, (0.0f).xxx, (0.0f).xxx);
- int ll_3 = int(0);
- int c = int(0);
- int d = int(0);
- float GLF_live6sums[9] = (float[9])0;
- idx = int(0);
- m43 = float4x3(float3(1.0f, 0.0f, 0.0f), float3(0.0f, 1.0f, 0.0f), float3(0.0f, 0.0f, 1.0f), (0.0f).xxx);
- ll_1 = int(0);
- GLF_live6rows = int(2);
- {
- while(true) {
- int x_18 = ll_1;
- int x_19 = asint(x_9[0u].x);
- if ((x_18 >= x_19)) {
- x_GLF_color = float4(1.0f, 0.0f, 0.0f, 1.0f);
- break;
- }
- int x_20 = ll_1;
- ll_1 = (x_20 + int(1));
- int x_22 = asint(x_9[0u].x);
- z = x_22;
- ll_2 = int(0);
- ctr = int(0);
- {
- while(true) {
- int x_23 = ctr;
- if ((x_23 < int(1))) {
- } else {
- break;
- }
- int x_24 = ll_2;
- int x_25 = asint(x_9[0u].x);
- if ((x_24 >= x_25)) {
- break;
- }
- int x_26 = ll_2;
- ll_2 = (x_26 + int(1));
- float4x3 x_98 = m43;
- tempm43 = x_98;
- ll_3 = int(0);
- c = int(0);
- {
- while(true) {
- int x_28 = z;
- if ((int(1) < x_28)) {
- } else {
- break;
- }
- d = int(0);
- int x_29 = c;
- int x_30 = c;
- int x_31 = c;
- int x_32 = d;
- int x_33 = d;
- int x_34 = d;
- int v = ((((x_29 >= int(0)) & (x_30 < int(4)))) ? (x_31) : (int(0)));
- tempm43[v][((((x_32 >= int(0)) & (x_33 < int(3)))) ? (x_34) : (int(0)))] = 1.0f;
- {
- int x_35 = c;
- c = (x_35 + int(1));
- }
- continue;
- }
- }
- int x_37 = idx;
- int x_38 = idx;
- int x_39 = idx;
- int x_117 = ((((x_37 >= int(0)) & (x_38 < int(9)))) ? (x_39) : (int(0)));
- int x_40 = ctr;
- float x_119 = m43[x_40].y;
- float x_121 = GLF_live6sums[x_117];
- GLF_live6sums[x_117] = (x_121 + x_119);
- {
- int x_41 = ctr;
- ctr = (x_41 + int(1));
- }
- continue;
- }
- }
- int x_43 = idx;
- idx = (x_43 + int(1));
- {
- }
- continue;
- }
- }
-}
-
-main_out main_inner() {
- main_1();
- main_out v_1 = {x_GLF_color};
- return v_1;
-}
-
-main_outputs main() {
- main_out v_2 = main_inner();
- main_outputs v_3 = {v_2.x_GLF_color_1};
- return v_3;
-}
-
-FXC validation failure:
-<scrubbed_path>(64,13-23): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(46,9-19): error X3511: forced to unroll loop, but unrolling failed.
-<scrubbed_path>(32,5-15): error X3511: forced to unroll loop, but unrolling failed.
-
-
-tint executable returned error: exit status 1
