tint: Resolve @builtin() args as expressions
This CL makes the builtin argument resolve as a shadowable enumerator
expression.
Bug: tint:1841
Bug: tint:1845
Change-Id: I2aaa2c63025752f25c113cf2fb38f4d91c2c16c2
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/120680
Kokoro: Ben Clayton <bclayton@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: James Price <jrprice@google.com>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 9870ccd..3207ebb 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -825,6 +825,7 @@
libtint_source_set("libtint_spv_reader_src") {
sources = [
+ "reader/spirv/attributes.h",
"reader/spirv/construct.cc",
"reader/spirv/construct.h",
"reader/spirv/entry_point_info.cc",
@@ -916,6 +917,7 @@
deps = [
":libtint_ast_src",
":libtint_base_src",
+ ":libtint_builtins_src",
":libtint_constant_src",
":libtint_program_src",
":libtint_sem_src",
@@ -981,6 +983,7 @@
deps = [
":libtint_ast_src",
":libtint_base_src",
+ ":libtint_builtins_src",
":libtint_constant_src",
":libtint_program_src",
":libtint_sem_src",
@@ -1001,6 +1004,7 @@
deps = [
":libtint_ast_src",
":libtint_base_src",
+ ":libtint_builtins_src",
":libtint_constant_src",
":libtint_program_src",
":libtint_sem_src",
@@ -1740,6 +1744,7 @@
deps = [
":libtint_base_src",
+ ":libtint_builtins_src",
":libtint_unittests_ast_helper",
":libtint_wgsl_reader_src",
]
@@ -1781,6 +1786,7 @@
]
deps = [
+ ":libtint_builtins_src",
":libtint_wgsl_writer_src",
":tint_unittests_ast_src",
]
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 2fe2161..79f19a4 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -575,6 +575,7 @@
if(${TINT_BUILD_SPV_READER})
list(APPEND TINT_LIB_SRCS
+ reader/spirv/attributes.h
reader/spirv/construct.h
reader/spirv/construct.cc
reader/spirv/entry_point_info.h
diff --git a/src/tint/ast/builtin_attribute.cc b/src/tint/ast/builtin_attribute.cc
index e3f9d7b..44231c0 100644
--- a/src/tint/ast/builtin_attribute.cc
+++ b/src/tint/ast/builtin_attribute.cc
@@ -25,8 +25,10 @@
BuiltinAttribute::BuiltinAttribute(ProgramID pid,
NodeID nid,
const Source& src,
- builtin::BuiltinValue b)
- : Base(pid, nid, src), builtin(b) {}
+ const Expression* b)
+ : Base(pid, nid, src), builtin(b) {
+ TINT_ASSERT_PROGRAM_IDS_EQUAL(AST, b, program_id);
+}
BuiltinAttribute::~BuiltinAttribute() = default;
@@ -37,7 +39,8 @@
const BuiltinAttribute* BuiltinAttribute::Clone(CloneContext* ctx) const {
// Clone arguments outside of create() call to have deterministic ordering
auto src = ctx->Clone(source);
- return ctx->dst->create<BuiltinAttribute>(src, builtin);
+ auto b = ctx->Clone(builtin);
+ return ctx->dst->create<BuiltinAttribute>(src, b);
}
} // namespace tint::ast
diff --git a/src/tint/ast/builtin_attribute.h b/src/tint/ast/builtin_attribute.h
index 6f9b156..2ed6a2d 100644
--- a/src/tint/ast/builtin_attribute.h
+++ b/src/tint/ast/builtin_attribute.h
@@ -18,7 +18,11 @@
#include <string>
#include "src/tint/ast/attribute.h"
-#include "src/tint/builtin/builtin_value.h"
+
+// Forward declarations
+namespace tint::ast {
+class Expression;
+}
namespace tint::ast {
@@ -30,7 +34,7 @@
/// @param nid the unique node identifier
/// @param src the source of this node
/// @param builtin the builtin value
- BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, builtin::BuiltinValue builtin);
+ BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, const Expression* builtin);
~BuiltinAttribute() override;
/// @returns the WGSL name for the attribute
@@ -43,7 +47,7 @@
const BuiltinAttribute* Clone(CloneContext* ctx) const override;
/// The builtin value
- const builtin::BuiltinValue builtin;
+ const Expression* const builtin;
};
} // namespace tint::ast
diff --git a/src/tint/ast/builtin_attribute_test.cc b/src/tint/ast/builtin_attribute_test.cc
index 3421e0f..00192b8 100644
--- a/src/tint/ast/builtin_attribute_test.cc
+++ b/src/tint/ast/builtin_attribute_test.cc
@@ -12,7 +12,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "gtest/gtest-spi.h"
+
#include "src/tint/ast/test_helper.h"
+#include "src/tint/builtin/builtin_value.h"
namespace tint::ast {
namespace {
@@ -20,8 +23,27 @@
using BuiltinAttributeTest = TestHelper;
TEST_F(BuiltinAttributeTest, Creation) {
- auto* d = create<BuiltinAttribute>(builtin::BuiltinValue::kFragDepth);
- EXPECT_EQ(builtin::BuiltinValue::kFragDepth, d->builtin);
+ auto* d = Builtin(builtin::BuiltinValue::kFragDepth);
+ CheckIdentifier(Symbols(), d->builtin, "frag_depth");
+}
+
+TEST_F(BuiltinAttributeTest, Assert_Null_Builtin) {
+ EXPECT_FATAL_FAILURE(
+ {
+ ProgramBuilder b;
+ b.Builtin(nullptr);
+ },
+ "internal compiler error");
+}
+
+TEST_F(BuiltinAttributeTest, Assert_DifferentProgramID_Builtin) {
+ EXPECT_FATAL_FAILURE(
+ {
+ ProgramBuilder b1;
+ ProgramBuilder b2;
+ b1.Builtin(b2.Expr("bang"));
+ },
+ "internal compiler error");
}
} // namespace
diff --git a/src/tint/ast/variable_test.cc b/src/tint/ast/variable_test.cc
index 35fca4a..0b46026 100644
--- a/src/tint/ast/variable_test.cc
+++ b/src/tint/ast/variable_test.cc
@@ -16,6 +16,7 @@
#include "src/tint/ast/id_attribute.h"
#include "src/tint/ast/test_helper.h"
+#include "src/tint/builtin/builtin_value.h"
using namespace tint::number_suffixes; // NOLINT
diff --git a/src/tint/builtin/builtin_value.cc b/src/tint/builtin/builtin_value.cc
index 740ebcc..150ac7b 100644
--- a/src/tint/builtin/builtin_value.cc
+++ b/src/tint/builtin/builtin_value.cc
@@ -28,6 +28,9 @@
/// @param str the string to parse
/// @returns the parsed enum, or BuiltinValue::kUndefined if the string could not be parsed.
BuiltinValue ParseBuiltinValue(std::string_view str) {
+ if (str == "__point_size") {
+ return BuiltinValue::kPointSize;
+ }
if (str == "frag_depth") {
return BuiltinValue::kFragDepth;
}
@@ -71,6 +74,8 @@
switch (value) {
case BuiltinValue::kUndefined:
return out << "undefined";
+ case BuiltinValue::kPointSize:
+ return out << "__point_size";
case BuiltinValue::kFragDepth:
return out << "frag_depth";
case BuiltinValue::kFrontFacing:
@@ -85,8 +90,6 @@
return out << "local_invocation_index";
case BuiltinValue::kNumWorkgroups:
return out << "num_workgroups";
- case BuiltinValue::kPointSize:
- return out << "point_size";
case BuiltinValue::kPosition:
return out << "position";
case BuiltinValue::kSampleIndex:
diff --git a/src/tint/builtin/builtin_value.h b/src/tint/builtin/builtin_value.h
index 1d5b4d4..4f8753f 100644
--- a/src/tint/builtin/builtin_value.h
+++ b/src/tint/builtin/builtin_value.h
@@ -30,6 +30,7 @@
/// Builtin value defined with `@builtin(<name>)`.
enum class BuiltinValue {
kUndefined,
+ kPointSize,
kFragDepth,
kFrontFacing,
kGlobalInvocationId,
@@ -37,7 +38,6 @@
kLocalInvocationId,
kLocalInvocationIndex,
kNumWorkgroups,
- kPointSize, // Tint-internal enum entry - not parsed
kPosition,
kSampleIndex,
kSampleMask,
@@ -56,12 +56,11 @@
BuiltinValue ParseBuiltinValue(std::string_view str);
constexpr const char* kBuiltinValueStrings[] = {
- "frag_depth", "front_facing",
- "global_invocation_id", "instance_index",
- "local_invocation_id", "local_invocation_index",
- "num_workgroups", "position",
- "sample_index", "sample_mask",
- "vertex_index", "workgroup_id",
+ "__point_size", "frag_depth", "front_facing",
+ "global_invocation_id", "instance_index", "local_invocation_id",
+ "local_invocation_index", "num_workgroups", "position",
+ "sample_index", "sample_mask", "vertex_index",
+ "workgroup_id",
};
} // namespace tint::builtin
diff --git a/src/tint/builtin/builtin_value_bench.cc b/src/tint/builtin/builtin_value_bench.cc
index 50d677e..4d2e562 100644
--- a/src/tint/builtin/builtin_value_bench.cc
+++ b/src/tint/builtin/builtin_value_bench.cc
@@ -31,90 +31,97 @@
void BuiltinValueParser(::benchmark::State& state) {
const char* kStrings[] = {
- "fragdeccth",
- "flaget3",
- "fVag_depth",
+ "_ccpoint_siz",
+ "_3poi_ile",
+ "__poiVt_size",
+ "__point_size",
+ "1_point_size",
+ "__pointJsqze",
+ "__lloint_siz77",
+ "frqqgppepHHh",
+ "fv_dcpt",
+ "frabGdeth",
"frag_depth",
- "frag1depth",
- "fraJqqepth",
- "fra7ll_depth",
- "fonHHpp_facing",
- "fron_facg",
- "frGnt_fbcin",
+ "frag_veiith",
+ "fr8g_depWWh",
+ "Mragxxepth",
+ "ggroXtfacing",
+ "Vot_fuciXg",
+ "front_fac3ng",
"front_facing",
- "front_facvnii",
- "frWWnt_faci8g",
- "fxxonM_facig",
- "gXobalgginvocationid",
- "goVal_uvocatioX_id",
- "global_in3ocation_id",
+ "front_fEcing",
+ "fronPPfaTTing",
+ "ddroxxtfacing",
+ "global_invocatio44_id",
+ "global_invocaSSioVV_id",
+ "22loRal_invoRtion_id",
"global_invocation_id",
- "global_invocation_iE",
- "TTobal_invocationPPid",
- "globdd_invocatioxx_id",
- "instance44index",
- "instaVVce_SSndex",
- "Rnstane_ind2Rx",
+ "globalFinvoction_id",
+ "gloal_invocation_id",
+ "RRlHOOaV_invoction_id",
+ "instance_ydex",
+ "instGlr77cnn_index",
+ "instan04e_index",
"instance_index",
- "inFtanceind9x",
- "insance_index",
- "inRRancV_OOHdex",
- "local_nvocytion_id",
- "llGcnnl_inv77catirrn_id",
- "local_invoca4i00n_id",
+ "insacoo_inex",
+ "izstane_index",
+ "nippance_in11ex",
+ "local_invXXcation_id",
+ "lIIcal_i5599ocation_inn",
+ "HHrrcal_inSSocation_Yaa",
"local_invocation_id",
- "loool_nvocaton_id",
- "local_inozztion_id",
- "p11cal_invocatiiin_i",
- "local_invocation_iXXdex",
- "local_invnnIIati99n55index",
- "localYirrHHocaationSSindex",
+ "lokkal_invocatini",
+ "jocal_invocRRongid",
+ "local_inocatbon_i",
+ "local_injocation_index",
+ "local_invocatio_index",
+ "locl_invocqtion_ndex",
"local_invocation_index",
- "lkkal_invHcation_idx",
- "gRcal_invocatioj_inex",
- "lcal_invcbtion_index",
+ "localNNinvocaton_index",
+ "local_invocatin_ivvdx",
+ "locl_invocatioQQ_index",
+ "num_workgffus",
"num_workgroujs",
- "num_worgroups",
- "nuq_orkgoups",
+ "num_wrkgNNwoup8",
"num_workgroups",
- "nm_workgroNNps",
- "um_workgrovps",
- "nQQm_orkgroups",
- "posftrn",
- "pojition",
- "poswNN82n",
+ "numworkgroups",
+ "num_workrrroups",
+ "num_worGgroups",
+ "pFFsition",
+ "pEiio",
+ "prrsitio",
"position",
- "positon",
- "porrition",
- "pGsition",
- "sample_inFFex",
- "samleinex",
- "sample_indrr",
+ "sition",
+ "poJJDtin",
+ "poi8i",
+ "smpke11nde",
+ "samle_index",
+ "saple_Jndex",
"sample_index",
- "sample_iex",
- "DaplX_JJndex",
- "8amleinde",
- "saplekmak",
- "samle_mask",
- "saJple_mak",
+ "cample_index",
+ "sample_indOx",
+ "savvKKl___inttex",
+ "sam8le_xx5k",
+ "sampqq__msk",
+ "sampleqmask",
"sample_mask",
- "sample_cask",
- "sample_maOk",
- "__attpvve_KKask",
- "vrtex5inxxe8",
- "v__rex_qFdex",
- "veqqtex_idex",
+ "33amOe_mas66",
+ "samoott6QQmask",
+ "66mple_mask",
+ "verzzx_in6Oxx",
+ "vertex_yyndex",
+ "vetxHHZnZex",
"vertex_index",
- "veOtx_33nde66",
- "v6ootex_indttQx",
- "ver66ex_inex",
- "worzzroup6Oxd",
- "workgroyyp_id",
- "wokrHHZpZid",
+ "vWWteq_in44ex",
+ "vrtex_OOndex",
+ "hrteYooindx",
+ "wogroup_i",
+ "wokgrouF_id",
+ "worgrwup_id",
"workgroup_id",
- "wWWkgqoup44id",
- "wrkgroOOp_id",
- "hrkgYooup_d",
+ "workGKou_if",
+ "worKKgrouq_id",
+ "w3rkgrommp_id",
};
for (auto _ : state) {
for (auto* str : kStrings) {
diff --git a/src/tint/builtin/builtin_value_test.cc b/src/tint/builtin/builtin_value_test.cc
index b245250..ae615bc 100644
--- a/src/tint/builtin/builtin_value_test.cc
+++ b/src/tint/builtin/builtin_value_test.cc
@@ -43,6 +43,7 @@
}
static constexpr Case kValidCases[] = {
+ {"__point_size", BuiltinValue::kPointSize},
{"frag_depth", BuiltinValue::kFragDepth},
{"front_facing", BuiltinValue::kFrontFacing},
{"global_invocation_id", BuiltinValue::kGlobalInvocationId},
@@ -58,42 +59,45 @@
};
static constexpr Case kInvalidCases[] = {
- {"fragdeccth", BuiltinValue::kUndefined},
- {"flaget3", BuiltinValue::kUndefined},
- {"fVag_depth", BuiltinValue::kUndefined},
- {"1ront_facing", BuiltinValue::kUndefined},
- {"front_fJcqng", BuiltinValue::kUndefined},
- {"frllnt_facin77", BuiltinValue::kUndefined},
- {"global_invoqqtionppHid", BuiltinValue::kUndefined},
- {"clvbal_inocaionid", BuiltinValue::kUndefined},
- {"global_Gvocation_id", BuiltinValue::kUndefined},
- {"invtance_iniiex", BuiltinValue::kUndefined},
- {"8nstanceWWindex", BuiltinValue::kUndefined},
- {"insxxanceindex", BuiltinValue::kUndefined},
- {"lXcal_invoation_igg", BuiltinValue::kUndefined},
- {"Xocal_nvocatin_Vd", BuiltinValue::kUndefined},
- {"local_invoca3ion_id", BuiltinValue::kUndefined},
- {"local_invocation_indeE", BuiltinValue::kUndefined},
- {"loTTal_invPPcatin_index", BuiltinValue::kUndefined},
- {"loal_invocadxxion_index", BuiltinValue::kUndefined},
- {"num_work44roups", BuiltinValue::kUndefined},
- {"num_wVVrkgSSoups", BuiltinValue::kUndefined},
- {"Rum_wokgrou2Rs", BuiltinValue::kUndefined},
- {"oFi9ion", BuiltinValue::kUndefined},
- {"postion", BuiltinValue::kUndefined},
- {"ROOoHiiVn", BuiltinValue::kUndefined},
- {"samply_inde", BuiltinValue::kUndefined},
- {"snrrmpl77l_indGx", BuiltinValue::kUndefined},
- {"00ample4index", BuiltinValue::kUndefined},
- {"smoo_mask", BuiltinValue::kUndefined},
- {"sampzemask", BuiltinValue::kUndefined},
- {"ppaplii1_mas", BuiltinValue::kUndefined},
- {"vertex_iXXdex", BuiltinValue::kUndefined},
- {"5nnertex_99IIdex", BuiltinValue::kUndefined},
- {"verYeaaHHrrndeSS", BuiltinValue::kUndefined},
- {"workkgHo_i", BuiltinValue::kUndefined},
- {"worRgoupjid", BuiltinValue::kUndefined},
- {"wrkgrupbid", BuiltinValue::kUndefined},
+ {"_ccpoint_siz", BuiltinValue::kUndefined},
+ {"_3poi_ile", BuiltinValue::kUndefined},
+ {"__poiVt_size", BuiltinValue::kUndefined},
+ {"frag1depth", BuiltinValue::kUndefined},
+ {"fraJqqepth", BuiltinValue::kUndefined},
+ {"fra7ll_depth", BuiltinValue::kUndefined},
+ {"fonHHpp_facing", BuiltinValue::kUndefined},
+ {"fron_facg", BuiltinValue::kUndefined},
+ {"frGnt_fbcin", BuiltinValue::kUndefined},
+ {"glvbal_iinvocation_id", BuiltinValue::kUndefined},
+ {"gl8bal_invocation_WWd", BuiltinValue::kUndefined},
+ {"Mlobal_invocaton_xxd", BuiltinValue::kUndefined},
+ {"isXance_indegg", BuiltinValue::kUndefined},
+ {"insanc_iXVex", BuiltinValue::kUndefined},
+ {"instance_in3ex", BuiltinValue::kUndefined},
+ {"local_Envocation_id", BuiltinValue::kUndefined},
+ {"localiPPvocatioTT_id", BuiltinValue::kUndefined},
+ {"localxxnvocationddid", BuiltinValue::kUndefined},
+ {"loca44_invocation_index", BuiltinValue::kUndefined},
+ {"local_invocSStionVVindex", BuiltinValue::kUndefined},
+ {"locRR_invocat22n_index", BuiltinValue::kUndefined},
+ {"nuF_workrou9s", BuiltinValue::kUndefined},
+ {"numworkgroups", BuiltinValue::kUndefined},
+ {"nuRRworVgOOHups", BuiltinValue::kUndefined},
+ {"posytio", BuiltinValue::kUndefined},
+ {"77orritllnon", BuiltinValue::kUndefined},
+ {"04osition", BuiltinValue::kUndefined},
+ {"smpe_oonde", BuiltinValue::kUndefined},
+ {"smpl_inzzex", BuiltinValue::kUndefined},
+ {"saiip11eindep", BuiltinValue::kUndefined},
+ {"sample_XXask", BuiltinValue::kUndefined},
+ {"samII99l55_mask", BuiltinValue::kUndefined},
+ {"samaale_SSrHHYk", BuiltinValue::kUndefined},
+ {"verkkeH_de", BuiltinValue::kUndefined},
+ {"verRg_injex", BuiltinValue::kUndefined},
+ {"vrtexinbex", BuiltinValue::kUndefined},
+ {"workjroup_id", BuiltinValue::kUndefined},
+ {"wrkgroup_id", BuiltinValue::kUndefined},
+ {"qorkgro_id", BuiltinValue::kUndefined},
};
using BuiltinValueParseTest = testing::TestWithParam<Case>;
diff --git a/src/tint/inspector/inspector.cc b/src/tint/inspector/inspector.cc
index e3706cf..b7455c7 100644
--- a/src/tint/inspector/inspector.cc
+++ b/src/tint/inspector/inspector.cc
@@ -28,7 +28,9 @@
#include "src/tint/ast/module.h"
#include "src/tint/ast/override.h"
#include "src/tint/ast/var.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/builtin/extension.h"
+#include "src/tint/sem/builtin_enum_expression.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/module.h"
@@ -698,11 +700,10 @@
// Base case: check for builtin
auto* builtin_declaration = ast::GetAttribute<ast::BuiltinAttribute>(attributes);
- if (!builtin_declaration || builtin_declaration->builtin != builtin) {
+ if (!builtin_declaration) {
return false;
}
-
- return true;
+ return program_->Sem().Get(builtin_declaration)->Value() == builtin;
}
std::vector<ResourceBinding> Inspector::GetStorageBufferResourceBindingsImpl(
diff --git a/src/tint/inspector/inspector.h b/src/tint/inspector/inspector.h
index 5854125..baaf8aa 100644
--- a/src/tint/inspector/inspector.h
+++ b/src/tint/inspector/inspector.h
@@ -25,6 +25,7 @@
#include "tint/override_id.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/inspector/entry_point.h"
#include "src/tint/inspector/resource_binding.h"
#include "src/tint/inspector/scalar.h"
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index f55b12c..933ae57 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -37,7 +37,7 @@
num_workgroups
sample_index
sample_mask
- @internal point_size
+ __point_size
}
// https://gpuweb.github.io/gpuweb/wgsl/#filterable-triggering-rules
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index f132900..03cc315 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -3445,15 +3445,17 @@
/// @param source the source information
/// @param builtin the builtin value
/// @returns the builtin attribute pointer
- const ast::BuiltinAttribute* Builtin(const Source& source, builtin::BuiltinValue builtin) {
- return create<ast::BuiltinAttribute>(source, builtin);
+ template <typename BUILTIN>
+ const ast::BuiltinAttribute* Builtin(const Source& source, BUILTIN&& builtin) {
+ return create<ast::BuiltinAttribute>(source, Expr(std::forward<BUILTIN>(builtin)));
}
/// Creates an ast::BuiltinAttribute
/// @param builtin the builtin value
/// @returns the builtin attribute pointer
- const ast::BuiltinAttribute* Builtin(builtin::BuiltinValue builtin) {
- return create<ast::BuiltinAttribute>(source_, builtin);
+ template <typename BUILTIN>
+ const ast::BuiltinAttribute* Builtin(BUILTIN&& builtin) {
+ return create<ast::BuiltinAttribute>(source_, Expr(std::forward<BUILTIN>(builtin)));
}
/// Creates an ast::InterpolateAttribute
diff --git a/src/tint/reader/spirv/attributes.h b/src/tint/reader/spirv/attributes.h
new file mode 100644
index 0000000..9014332
--- /dev/null
+++ b/src/tint/reader/spirv/attributes.h
@@ -0,0 +1,81 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TINT_READER_SPIRV_ATTRIBUTES_H_
+#define SRC_TINT_READER_SPIRV_ATTRIBUTES_H_
+
+#include "src/tint/ast/attribute.h"
+#include "src/tint/builtin/builtin_value.h"
+#include "src/tint/program_builder.h"
+#include "src/tint/utils/enum_set.h"
+#include "src/tint/utils/vector.h"
+
+namespace tint::reader::spirv {
+
+/// Attributes holds a vector of ast::Attribute pointers, and a enum-set of flags used to hold
+/// additional metadata.
+struct Attributes {
+ /// Flags used by #flags.
+ enum class Flags {
+ kHasBuiltinSampleMask,
+ };
+
+ /// Adds the attributes and flags of @p other to this.
+ /// @param other the other Attributes to combine into this
+ void Add(const Attributes& other) {
+ for (auto* attr : other.list) {
+ list.Push(attr);
+ }
+ for (auto flag : other.flags) {
+ flags.Add(flag);
+ }
+ }
+
+ /// Adds the attribute @p attr to the list of attributes
+ /// @param attr the attribute to add to this
+ void Add(const ast::Attribute* attr) { list.Push(attr); }
+
+ /// Adds the builtin to the attribute list, also marking any necessary flags
+ /// @param builder the program builder
+ /// @param source the source of the builtin attribute
+ /// @param builtin the builtin attribute to add
+ void Add(ProgramBuilder& builder, const Source& source, builtin::BuiltinValue builtin) {
+ Add(builder.Builtin(source, builtin));
+ if (builtin == builtin::BuiltinValue::kSampleMask) {
+ flags.Add(Flags::kHasBuiltinSampleMask);
+ }
+ }
+
+ /// @returns true if the attribute list contains an attribute with the type `T`.
+ template <typename T>
+ bool Has() const {
+ return ast::HasAttribute<T>(list);
+ }
+
+ /// @returns the attribute with type `T` in the list, or nullptr if no attribute of the given
+ /// type exists in list.
+ template <typename T>
+ const T* Get() const {
+ return ast::GetAttribute<T>(list);
+ }
+
+ /// The attributes
+ utils::Vector<const ast::Attribute*, 8> list;
+ /// The additional metadata flags
+ utils::EnumSet<Flags> flags;
+};
+
+} // namespace tint::reader::spirv
+
+#endif // SRC_TINT_READER_SPIRV_ATTRIBUTES_H_
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index 12c46c1..f94be97 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -756,15 +756,6 @@
mutable const ast::BlockStatement* continuing = nullptr;
};
-/// @param decos a list of parsed decorations
-/// @returns true if the decorations include a SampleMask builtin
-bool HasBuiltinSampleMask(utils::VectorRef<const ast::Attribute*> decos) {
- if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(decos)) {
- return builtin->builtin == builtin::BuiltinValue::kSampleMask;
- }
- return false;
-}
-
} // namespace
BlockInfo::BlockInfo(const spvtools::opt::BasicBlock& bb) : basic_block(&bb), id(bb.id()) {}
@@ -956,7 +947,7 @@
}
builder_.Func(decl.source, decl.name, std::move(decl.params),
- decl.return_type->Build(builder_), body, std::move(decl.attributes));
+ decl.return_type->Build(builder_), body, std::move(decl.attributes.list));
}
if (ep_info_ && !ep_info_->inner_name.empty()) {
@@ -994,12 +985,12 @@
bool FunctionEmitter::EmitPipelineInput(std::string var_name,
const Type* var_type,
- AttributeList* attrs,
utils::Vector<int, 8> index_prefix,
const Type* tip_type,
const Type* forced_param_type,
- ParameterList* params,
- StatementList* statements) {
+ Attributes& attrs,
+ ParameterList& params,
+ StatementList& statements) {
// TODO(dneto): Handle structs where the locations are annotated on members.
tip_type = tip_type->UnwrapAlias();
if (auto* ref_type = tip_type->As<Reference>()) {
@@ -1015,8 +1006,8 @@
const Type* vec_ty = ty_.Vector(matrix_type->type, matrix_type->rows);
for (int col = 0; col < num_columns; col++) {
index_prefix.Back() = col;
- if (!EmitPipelineInput(var_name, var_type, attrs, index_prefix, vec_ty,
- forced_param_type, params, statements)) {
+ if (!EmitPipelineInput(var_name, var_type, index_prefix, vec_ty, forced_param_type,
+ attrs, params, statements)) {
return false;
}
}
@@ -1030,8 +1021,8 @@
const Type* elem_ty = array_type->type;
for (int i = 0; i < static_cast<int>(array_type->size); i++) {
index_prefix.Back() = i;
- if (!EmitPipelineInput(var_name, var_type, attrs, index_prefix, elem_ty,
- forced_param_type, params, statements)) {
+ if (!EmitPipelineInput(var_name, var_type, index_prefix, elem_ty, forced_param_type,
+ attrs, params, statements)) {
return false;
}
}
@@ -1042,38 +1033,36 @@
index_prefix.Push(0);
for (size_t i = 0; i < members.size(); ++i) {
index_prefix.Back() = static_cast<int>(i);
- AttributeList member_attrs(*attrs);
+ Attributes member_attrs(attrs);
if (!parser_impl_.ConvertPipelineDecorations(
struct_type,
parser_impl_.GetMemberPipelineDecorations(*struct_type,
static_cast<int>(i)),
- &member_attrs)) {
+ member_attrs)) {
return false;
}
- if (!EmitPipelineInput(var_name, var_type, &member_attrs, index_prefix, members[i],
- forced_param_type, params, statements)) {
+ if (!EmitPipelineInput(var_name, var_type, index_prefix, members[i],
+ forced_param_type, member_attrs, params, statements)) {
return false;
}
// Copy the location as updated by nested expansion of the member.
- parser_impl_.SetLocation(attrs,
- ast::GetAttribute<ast::LocationAttribute>(member_attrs));
+ parser_impl_.SetLocation(attrs, member_attrs.Get<ast::LocationAttribute>());
}
return success();
},
[&](Default) {
- const bool is_builtin = ast::HasAttribute<ast::BuiltinAttribute>(*attrs);
+ const bool is_builtin = attrs.Has<ast::BuiltinAttribute>();
const Type* param_type = is_builtin ? forced_param_type : tip_type;
const auto param_name = namer_.MakeDerivedName(var_name + "_param");
// Create the parameter.
- // TODO(dneto): Note: If the parameter has non-location decorations,
- // then those decoration AST nodes will be reused between multiple
- // elements of a matrix, array, or structure. Normally that's
- // disallowed but currently the SPIR-V reader will make duplicates when
- // the entire AST is cloned at the top level of the SPIR-V reader flow.
+ // TODO(dneto): Note: If the parameter has non-location decorations, then those
+ // decoration AST nodes will be reused between multiple elements of a matrix, array, or
+ // structure. Normally that's disallowed but currently the SPIR-V reader will make
+ // duplicates when the entire AST is cloned at the top level of the SPIR-V reader flow.
// Consider rewriting this to avoid this node-sharing.
- params->Push(builder_.Param(param_name, param_type->Build(builder_), *attrs));
+ params.Push(builder_.Param(param_name, param_type->Build(builder_), attrs.list));
// Add a body statement to copy the parameter to the corresponding
// private variable.
@@ -1101,27 +1090,25 @@
}
if (is_builtin && (tip_type != forced_param_type)) {
- // The parameter will have the WGSL type, but we need bitcast to
- // the variable store type.
+ // The parameter will have the WGSL type, but we need bitcast to the variable store
+ // type.
param_value = builder_.Bitcast(tip_type->Build(builder_), param_value);
}
- statements->Push(builder_.Assign(store_dest, param_value));
+ statements.Push(builder_.Assign(store_dest, param_value));
- // Increment the location attribute, in case more parameters will
- // follow.
+ // Increment the location attribute, in case more parameters will follow.
IncrementLocation(attrs);
return success();
});
}
-void FunctionEmitter::IncrementLocation(AttributeList* attributes) {
- for (auto*& attr : *attributes) {
+void FunctionEmitter::IncrementLocation(Attributes& attributes) {
+ for (auto*& attr : attributes.list) {
if (auto* loc_attr = attr->As<ast::LocationAttribute>()) {
// Replace this location attribute with a new one with one higher index.
- // The old one doesn't leak because it's kept in the builder's AST node
- // list.
+ // The old one doesn't leak because it's kept in the builder's AST node list.
attr = builder_.Location(
loc_attr->source, AInt(loc_attr->expr->As<ast::IntLiteralExpression>()->value + 1));
}
@@ -1130,12 +1117,12 @@
bool FunctionEmitter::EmitPipelineOutput(std::string var_name,
const Type* var_type,
- AttributeList* decos,
utils::Vector<int, 8> index_prefix,
const Type* tip_type,
const Type* forced_member_type,
- StructMemberList* return_members,
- ExpressionList* return_exprs) {
+ Attributes& attrs,
+ StructMemberList& return_members,
+ ExpressionList& return_exprs) {
tip_type = tip_type->UnwrapAlias();
if (auto* ref_type = tip_type->As<Reference>()) {
tip_type = ref_type->type;
@@ -1150,8 +1137,8 @@
const Type* vec_ty = ty_.Vector(matrix_type->type, matrix_type->rows);
for (int col = 0; col < num_columns; col++) {
index_prefix.Back() = col;
- if (!EmitPipelineOutput(var_name, var_type, std::move(decos), index_prefix, vec_ty,
- forced_member_type, return_members, return_exprs)) {
+ if (!EmitPipelineOutput(var_name, var_type, index_prefix, vec_ty,
+ forced_member_type, attrs, return_members, return_exprs)) {
return false;
}
}
@@ -1165,8 +1152,8 @@
const Type* elem_ty = array_type->type;
for (int i = 0; i < static_cast<int>(array_type->size); i++) {
index_prefix.Back() = i;
- if (!EmitPipelineOutput(var_name, var_type, std::move(decos), index_prefix, elem_ty,
- forced_member_type, return_members, return_exprs)) {
+ if (!EmitPipelineOutput(var_name, var_type, index_prefix, elem_ty,
+ forced_member_type, attrs, return_members, return_exprs)) {
return false;
}
}
@@ -1177,39 +1164,37 @@
index_prefix.Push(0);
for (int i = 0; i < static_cast<int>(members.size()); ++i) {
index_prefix.Back() = i;
- AttributeList member_attrs(*decos);
+ Attributes member_attrs(attrs);
if (!parser_impl_.ConvertPipelineDecorations(
struct_type, parser_impl_.GetMemberPipelineDecorations(*struct_type, i),
- &member_attrs)) {
+ member_attrs)) {
return false;
}
- if (!EmitPipelineOutput(var_name, var_type, &member_attrs, index_prefix,
+ if (!EmitPipelineOutput(var_name, var_type, index_prefix,
members[static_cast<size_t>(i)], forced_member_type,
- return_members, return_exprs)) {
+ member_attrs, return_members, return_exprs)) {
return false;
}
// Copy the location as updated by nested expansion of the member.
- parser_impl_.SetLocation(decos,
- ast::GetAttribute<ast::LocationAttribute>(member_attrs));
+ parser_impl_.SetLocation(attrs, member_attrs.Get<ast::LocationAttribute>());
}
return success();
},
[&](Default) {
- const bool is_builtin = ast::HasAttribute<ast::BuiltinAttribute>(*decos);
+ const bool is_builtin = attrs.Has<ast::BuiltinAttribute>();
const Type* member_type = is_builtin ? forced_member_type : tip_type;
// Derive the member name directly from the variable name. They can't
// collide.
const auto member_name = namer_.MakeDerivedName(var_name);
// Create the member.
- // TODO(dneto): Note: If the parameter has non-location decorations,
- // then those decoration AST nodes will be reused between multiple
- // elements of a matrix, array, or structure. Normally that's
- // disallowed but currently the SPIR-V reader will make duplicates when
- // the entire AST is cloned at the top level of the SPIR-V reader flow.
+ // TODO(dneto): Note: If the parameter has non-location decorations, then those
+ // decoration AST nodes will be reused between multiple elements of a matrix, array, or
+ // structure. Normally that's disallowed but currently the SPIR-V reader will make
+ // duplicates when the entire AST is cloned at the top level of the SPIR-V reader flow.
// Consider rewriting this to avoid this node-sharing.
- return_members->Push(
- builder_.Member(member_name, member_type->Build(builder_), *decos));
+ return_members.Push(
+ builder_.Member(member_name, member_type->Build(builder_), attrs.list));
// Create an expression to evaluate the part of the variable indexed by
// the index_prefix.
@@ -1240,11 +1225,10 @@
// the variable store type.
load_source = builder_.Bitcast(forced_member_type->Build(builder_), load_source);
}
- return_exprs->Push(load_source);
+ return_exprs.Push(load_source);
- // Increment the location attribute, in case more parameters will
- // follow.
- IncrementLocation(decos);
+ // Increment the location attribute, in case more parameters will follow.
+ IncrementLocation(attrs);
return success();
});
@@ -1270,8 +1254,8 @@
TINT_ASSERT(Reader, opcode(var) == spv::Op::OpVariable);
auto* store_type = GetVariableStoreType(*var);
auto* forced_param_type = store_type;
- AttributeList param_decos;
- if (!parser_impl_.ConvertDecorationsForVariable(var_id, &forced_param_type, ¶m_decos,
+ Attributes param_attrs;
+ if (!parser_impl_.ConvertDecorationsForVariable(var_id, &forced_param_type, param_attrs,
true)) {
// This occurs, and is not an error, for the PointSize builtin.
if (!success()) {
@@ -1287,18 +1271,17 @@
const auto var_name = namer_.GetName(var_id);
bool ok = true;
- if (HasBuiltinSampleMask(param_decos)) {
+ if (param_attrs.flags.Contains(Attributes::Flags::kHasBuiltinSampleMask)) {
// In Vulkan SPIR-V, the sample mask is an array. In WGSL it's a scalar.
// Use the first element only.
auto* sample_mask_array_type = store_type->UnwrapRef()->UnwrapAlias()->As<Array>();
TINT_ASSERT(Reader, sample_mask_array_type);
- ok = EmitPipelineInput(var_name, store_type, ¶m_decos, {0},
- sample_mask_array_type->type, forced_param_type, &decl.params,
- &stmts);
+ ok = EmitPipelineInput(var_name, store_type, {0}, sample_mask_array_type->type,
+ forced_param_type, param_attrs, decl.params, stmts);
} else {
// The normal path.
- ok = EmitPipelineInput(var_name, store_type, ¶m_decos, {}, store_type,
- forced_param_type, &decl.params, &stmts);
+ ok = EmitPipelineInput(var_name, store_type, {}, store_type, forced_param_type,
+ param_attrs, decl.params, stmts);
}
if (!ok) {
return false;
@@ -1330,12 +1313,12 @@
// The SPIR-V gl_PerVertex variable has already been remapped to
// a gl_Position variable. Substitute the type.
const Type* param_type = ty_.Vector(ty_.F32(), 4);
- AttributeList out_decos{
- create<ast::BuiltinAttribute>(source, builtin::BuiltinValue::kPosition)};
-
const auto var_name = namer_.GetName(var_id);
return_members.Push(
- builder_.Member(var_name, param_type->Build(builder_), out_decos));
+ builder_.Member(var_name, param_type->Build(builder_),
+ utils::Vector{
+ builder_.Builtin(source, builtin::BuiltinValue::kPosition),
+ }));
return_exprs.Push(builder_.Expr(var_name));
} else {
@@ -1344,9 +1327,9 @@
TINT_ASSERT(Reader, opcode(var) == spv::Op::OpVariable);
const Type* store_type = GetVariableStoreType(*var);
const Type* forced_member_type = store_type;
- AttributeList out_decos;
+ Attributes out_attrs;
if (!parser_impl_.ConvertDecorationsForVariable(var_id, &forced_member_type,
- &out_decos, true)) {
+ out_attrs, true)) {
// This occurs, and is not an error, for the PointSize builtin.
if (!success()) {
// But exit early if an error was logged.
@@ -1357,19 +1340,20 @@
const auto var_name = namer_.GetName(var_id);
bool ok = true;
- if (HasBuiltinSampleMask(out_decos)) {
+ if (out_attrs.flags.Contains(Attributes::Flags::kHasBuiltinSampleMask)) {
// In Vulkan SPIR-V, the sample mask is an array. In WGSL it's a
// scalar. Use the first element only.
auto* sample_mask_array_type =
store_type->UnwrapRef()->UnwrapAlias()->As<Array>();
TINT_ASSERT(Reader, sample_mask_array_type);
- ok = EmitPipelineOutput(var_name, store_type, &out_decos, {0},
- sample_mask_array_type->type, forced_member_type,
- &return_members, &return_exprs);
+ ok = EmitPipelineOutput(var_name, store_type, {0}, sample_mask_array_type->type,
+ forced_member_type, out_attrs, return_members,
+ return_exprs);
} else {
// The normal path.
- ok = EmitPipelineOutput(var_name, store_type, &out_decos, {}, store_type,
- forced_member_type, &return_members, &return_exprs);
+ ok =
+ EmitPipelineOutput(var_name, store_type, {}, store_type, forced_member_type,
+ out_attrs, return_members, return_exprs);
}
if (!ok) {
return false;
@@ -1384,7 +1368,7 @@
} else {
// Create and register the result type.
auto* str = create<ast::Struct>(Source{}, builder_.Ident(return_struct_sym),
- return_members, AttributeList{});
+ return_members, utils::Empty);
parser_impl_.AddTypeDecl(return_struct_sym, str);
return_type = builder_.ty.Of(str);
@@ -1394,8 +1378,9 @@
}
}
- AttributeList fn_attrs;
- fn_attrs.Push(create<ast::StageAttribute>(source, ep_info_->stage));
+ utils::Vector<const ast::Attribute*, 2> fn_attrs{
+ create<ast::StageAttribute>(source, ep_info_->stage),
+ };
if (ep_info_->stage == ast::PipelineStage::kCompute) {
auto& size = ep_info_->workgroup_size;
@@ -1442,7 +1427,7 @@
: parser_impl_.ConvertType(param->type_id());
if (type != nullptr) {
- auto* ast_param = parser_impl_.MakeParameter(param->result_id(), type, AttributeList{});
+ auto* ast_param = parser_impl_.MakeParameter(param->result_id(), type, Attributes{});
// Parameters are treated as const declarations.
ast_params.Push(ast_param);
// The value is accessible by name.
@@ -1458,7 +1443,7 @@
decl->name = name;
decl->params = std::move(ast_params);
decl->return_type = ret_ty;
- decl->attributes.Clear();
+ decl->attributes = {};
return success();
}
@@ -2523,7 +2508,7 @@
}
auto* var = parser_impl_.MakeVar(inst.result_id(), builtin::AddressSpace::kUndefined,
builtin::Access::kUndefined, var_store_type, initializer,
- AttributeList{});
+ Attributes{});
auto* var_decl_stmt = create<ast::VariableDeclStatement>(Source{}, var);
AddStatement(var_decl_stmt);
auto* var_type = ty_.Reference(var_store_type, builtin::AddressSpace::kUndefined);
@@ -3370,7 +3355,7 @@
AddStatement(create<ast::VariableDeclStatement>(
Source{},
parser_impl_.MakeVar(id, builtin::AddressSpace::kUndefined, builtin::Access::kUndefined,
- store_type, nullptr, AttributeList{})));
+ store_type, nullptr, Attributes{})));
auto* type = ty_.Reference(store_type, builtin::AddressSpace::kUndefined);
identifier_types_.emplace(id, type);
}
diff --git a/src/tint/reader/spirv/function.h b/src/tint/reader/spirv/function.h
index 345896a..a07309d 100644
--- a/src/tint/reader/spirv/function.h
+++ b/src/tint/reader/spirv/function.h
@@ -25,6 +25,7 @@
#include <vector>
#include "src/tint/program_builder.h"
+#include "src/tint/reader/spirv/attributes.h"
#include "src/tint/reader/spirv/construct.h"
#include "src/tint/reader/spirv/parser_impl.h"
@@ -420,7 +421,6 @@
/// A FunctionEmitter emits a SPIR-V function onto a Tint AST module.
class FunctionEmitter {
- using AttributeList = utils::Vector<const ast::Attribute*, 8>;
using StructMemberList = utils::Vector<const ast::StructMember*, 8>;
using ExpressionList = utils::Vector<const ast::Expression*, 8>;
using ParameterList = utils::Vector<const ast::Parameter*, 8>;
@@ -473,32 +473,31 @@
/// @returns false if emission failed.
bool EmitEntryPointAsWrapper();
- /// Creates one or more entry point input parameters corresponding to a
- /// part of an input variable. The part of the input variable is specfied
- /// by the `index_prefix`, which successively indexes into the variable.
- /// Also generates the assignment statements that copy the input parameter
- /// to the corresponding part of the variable. Assumes the variable
- /// has already been created in the Private address space.
+ /// Creates one or more entry point input parameters corresponding to a part of an input
+ /// variable. The part of the input variable is specfied by the `index_prefix`, which
+ /// successively indexes into the variable. Also generates the assignment statements that copy
+ /// the input parameter to the corresponding part of the variable. Assumes the variable has
+ /// already been created in the Private address space.
/// @param var_name The name of the variable
/// @param var_type The store type of the variable
- /// @param decos The variable's decorations
- /// @param index_prefix Indices stepping into the variable, indicating
- /// what part of the variable to populate.
- /// @param tip_type The type of the component inside variable, after indexing
- /// with the indices in `index_prefix`.
- /// @param forced_param_type The type forced by WGSL, if the variable is a
- /// builtin, otherwise the same as var_type.
+ /// @param attributes The variable's attributes
+ /// @param index_prefix Indices stepping into the variable, indicating what part of the variable
+ /// to populate.
+ /// @param tip_type The type of the component inside variable, after indexing with the indices
+ /// in `index_prefix`.
+ /// @param forced_param_type The type forced by WGSL, if the variable is a builtin, otherwise
+ /// the same as var_type.
/// @param params The parameter list where the new parameter is appended.
/// @param statements The statement list where the assignment is appended.
/// @returns false if emission failed
bool EmitPipelineInput(std::string var_name,
const Type* var_type,
- AttributeList* decos,
utils::Vector<int, 8> index_prefix,
const Type* tip_type,
const Type* forced_param_type,
- ParameterList* params,
- StatementList* statements);
+ Attributes& attributes,
+ ParameterList& params,
+ StatementList& statements);
/// Creates one or more struct members from an output variable, and the
/// expressions that compute the value they contribute to the entry point
@@ -507,31 +506,31 @@
/// Assumes the variable has already been created in the Private address space
/// @param var_name The name of the variable
/// @param var_type The store type of the variable
- /// @param decos The variable's decorations
/// @param index_prefix Indices stepping into the variable, indicating what part of the variable
/// to populate.
/// @param tip_type The type of the component inside variable, after indexing with the indices
/// in `index_prefix`.
/// @param forced_member_type The type forced by WGSL, if the variable is a builtin, otherwise
/// the same as var_type.
+ /// @param attributes The variable's attributes
/// @param return_members The struct member list where the new member is added.
/// @param return_exprs The expression list where the return expression is added.
/// @returns false if emission failed
bool EmitPipelineOutput(std::string var_name,
const Type* var_type,
- AttributeList* decos,
utils::Vector<int, 8> index_prefix,
const Type* tip_type,
const Type* forced_member_type,
- StructMemberList* return_members,
- ExpressionList* return_exprs);
+ Attributes& attributes,
+ StructMemberList& return_members,
+ ExpressionList& return_exprs);
/// Updates the attribute list, replacing an existing Location attribute
/// with another having one higher location value. Does nothing if no
/// location attribute exists.
/// Assumes the list contains at most one Location attribute.
/// @param attributes the attribute list to modify
- void IncrementLocation(AttributeList* attributes);
+ void IncrementLocation(Attributes& attributes);
/// Create an ast::BlockStatement representing the body of the function.
/// This creates the statement stack, which is non-empty for the lifetime
@@ -976,7 +975,7 @@
/// Function return type
const Type* return_type;
/// Function attributes
- AttributeList attributes;
+ Attributes attributes;
};
/// Parse the function declaration, which comprises the name, parameters, and
diff --git a/src/tint/reader/spirv/namer.cc b/src/tint/reader/spirv/namer.cc
index 1233157..3e1f880 100644
--- a/src/tint/reader/spirv/namer.cc
+++ b/src/tint/reader/spirv/namer.cc
@@ -26,32 +26,146 @@
const char* kWGSLReservedWords[] = {
// Please keep this list sorted
- "array", "as", "asm",
- "bf16", "binding", "block",
- "bool", "break", "builtin",
- "case", "cast", "compute",
- "const", "continue", "default",
- "discard", "do", "else",
- "elseif", "entry_point", "enum",
- "f16", "f32", "fallthrough",
- "false", "fn", "for",
- "fragment", "i16", "i32",
- "i64", "i8", "if",
- "image", "import", "in",
- "let", "location", "loop",
- "mat2x2", "mat2x3", "mat2x4",
- "mat3x2", "mat3x3", "mat3x4",
- "mat4x2", "mat4x3", "mat4x4",
- "offset", "out", "override",
- "premerge", "private", "ptr",
- "regardless", "return", "set",
- "storage", "struct", "switch",
- "true", "type", "typedef",
- "u16", "u32", "u64",
- "u8", "uniform", "uniform_constant",
- "unless", "using", "var",
- "vec2", "vec3", "vec4",
- "vertex", "void", "while",
+ "array",
+ "as",
+ "asm",
+ "atomic",
+ "bf16",
+ "binding",
+ "block",
+ "bool",
+ "break",
+ "builtin",
+ "case",
+ "cast",
+ "compute",
+ "const",
+ "continue",
+ "default",
+ "discard",
+ "do",
+ "else",
+ "elseif",
+ "entry_point",
+ "enum",
+ "f16",
+ "f32",
+ "fallthrough",
+ "false",
+ "fn",
+ "for",
+ "frag_depth",
+ "fragment",
+ "front_facing",
+ "global_invocation_id",
+ "i16",
+ "i32",
+ "i64",
+ "i8",
+ "if",
+ "image",
+ "import",
+ "in",
+ "instance_index",
+ "let",
+ "local_invocation_id",
+ "local_invocation_index",
+ "location",
+ "loop",
+ "mat2x2",
+ "mat2x2f",
+ "mat2x2h",
+ "mat2x3",
+ "mat2x3f",
+ "mat2x3h",
+ "mat2x4",
+ "mat2x4f",
+ "mat2x4h",
+ "mat3x2",
+ "mat3x2f",
+ "mat3x2h",
+ "mat3x3",
+ "mat3x3f",
+ "mat3x3h",
+ "mat3x4",
+ "mat3x4f",
+ "mat3x4h",
+ "mat4x2",
+ "mat4x2f",
+ "mat4x2h",
+ "mat4x3",
+ "mat4x3f",
+ "mat4x3h",
+ "mat4x4",
+ "mat4x4f",
+ "mat4x4h",
+ "num_workgroups",
+ "offset",
+ "out",
+ "override",
+ "position",
+ "premerge",
+ "private",
+ "ptr",
+ "regardless",
+ "return",
+ "sample_index",
+ "sample_mask",
+ "sampler_comparison",
+ "sampler",
+ "set",
+ "storage",
+ "struct",
+ "switch",
+ "texture_1d",
+ "texture_2d_array",
+ "texture_2d",
+ "texture_3d",
+ "texture_cube_array",
+ "texture_cube",
+ "texture_depth_2d_array",
+ "texture_depth_2d",
+ "texture_depth_cube_array",
+ "texture_depth_cube",
+ "texture_depth_multisampled_2d",
+ "texture_external",
+ "texture_multisampled_2d",
+ "texture_storage_1d",
+ "texture_storage_2d_array",
+ "texture_storage_2d",
+ "texture_storage_3d",
+ "true",
+ "type",
+ "typedef",
+ "u16",
+ "u32",
+ "u64",
+ "u8",
+ "uniform_constant",
+ "uniform",
+ "unless",
+ "using",
+ "var",
+ "vec2",
+ "vec2f",
+ "vec2h",
+ "vec2i",
+ "vec2u",
+ "vec3",
+ "vec3f",
+ "vec3h",
+ "vec3i",
+ "vec3u",
+ "vec4",
+ "vec4f",
+ "vec4h",
+ "vec4i",
+ "vec4u",
+ "vertex_index",
+ "vertex",
+ "void",
+ "while",
+ "workgroup_id",
"workgroup",
};
diff --git a/src/tint/reader/spirv/parser_impl.cc b/src/tint/reader/spirv/parser_impl.cc
index 35df789..e615e14 100644
--- a/src/tint/reader/spirv/parser_impl.cc
+++ b/src/tint/reader/spirv/parser_impl.cc
@@ -461,49 +461,42 @@
return "SPIR-V type " + std::to_string(type_id);
}
-ParserImpl::AttributeList ParserImpl::ConvertMemberDecoration(uint32_t struct_type_id,
- uint32_t member_index,
- const Type* member_ty,
- const Decoration& decoration) {
+Attributes ParserImpl::ConvertMemberDecoration(uint32_t struct_type_id,
+ uint32_t member_index,
+ const Type* member_ty,
+ const Decoration& decoration) {
if (decoration.empty()) {
Fail() << "malformed SPIR-V decoration: it's empty";
return {};
}
+ Attributes out;
switch (static_cast<spv::Decoration>(decoration[0])) {
- case spv::Decoration::Offset:
+ case spv::Decoration::Offset: {
if (decoration.size() != 2) {
Fail() << "malformed Offset decoration: expected 1 literal operand, has "
<< decoration.size() - 1 << ": member " << member_index << " of "
<< ShowType(struct_type_id);
return {};
}
- return {
- builder_.MemberOffset(Source{}, AInt(decoration[1])),
- };
- case spv::Decoration::NonReadable:
- // WGSL doesn't have a member decoration for this. Silently drop it.
- return {};
- case spv::Decoration::NonWritable:
- // WGSL doesn't have a member decoration for this.
- return {};
- case spv::Decoration::ColMajor:
- // WGSL only supports column major matrices.
- return {};
- case spv::Decoration::RelaxedPrecision:
- // WGSL doesn't support relaxed precision.
- return {};
+ out.Add(builder_.MemberOffset(Source{}, AInt(decoration[1])));
+ break;
+ }
+ case spv::Decoration::NonReadable: // WGSL doesn't have a member decoration for this.
+ case spv::Decoration::NonWritable: // WGSL doesn't have a member decoration for this.
+ case spv::Decoration::ColMajor: // WGSL only supports column major matrices.
+ case spv::Decoration::RelaxedPrecision: // WGSL doesn't support relaxed precision.
+ break;
case spv::Decoration::RowMajor:
Fail() << "WGSL does not support row-major matrices: can't "
"translate member "
<< member_index << " of " << ShowType(struct_type_id);
- return {};
+ break;
case spv::Decoration::MatrixStride: {
if (decoration.size() != 2) {
- Fail() << "malformed MatrixStride decoration: expected 1 literal "
- "operand, has "
+ Fail() << "malformed MatrixStride decoration: expected 1 literal operand, has "
<< decoration.size() - 1 << ": member " << member_index << " of "
<< ShowType(struct_type_id);
- return {};
+ break;
}
uint32_t stride = decoration[1];
auto* ty = member_ty->UnwrapAlias();
@@ -513,31 +506,30 @@
auto* mat = ty->As<Matrix>();
if (!mat) {
Fail() << "MatrixStride cannot be applied to type " << ty->String();
- return {};
+ break;
}
uint32_t natural_stride = (mat->rows == 2) ? 8 : 16;
if (stride == natural_stride) {
- return {}; // Decoration matches the natural stride for the matrix
+ break; // Decoration matches the natural stride for the matrix
}
if (!member_ty->Is<Matrix>()) {
- Fail() << "custom matrix strides not currently supported on array of "
- "matrices";
- return {};
+ Fail() << "custom matrix strides not currently supported on array of matrices";
+ break;
}
- return {
- create<ast::StrideAttribute>(Source{}, decoration[1]),
- builder_.ASTNodes().Create<ast::DisableValidationAttribute>(
- builder_.ID(), builder_.AllocateNodeID(),
- ast::DisabledValidation::kIgnoreStrideAttribute),
- };
- }
- default:
- // TODO(dneto): Support the remaining member decorations.
+ out.Add(create<ast::StrideAttribute>(Source{}, decoration[1]));
+ out.Add(builder_.ASTNodes().Create<ast::DisableValidationAttribute>(
+ builder_.ID(), builder_.AllocateNodeID(),
+ ast::DisabledValidation::kIgnoreStrideAttribute));
break;
+ }
+ default: {
+ // TODO(dneto): Support the remaining member decorations.
+ Fail() << "unhandled member decoration: " << decoration[0] << " on member "
+ << member_index << " of " << ShowType(struct_type_id);
+ break;
+ }
}
- Fail() << "unhandled member decoration: " << decoration[0] << " on member " << member_index
- << " of " << ShowType(struct_type_id);
- return {};
+ return out;
}
bool ParserImpl::BuildInternalModule() {
@@ -1138,7 +1130,7 @@
}
bool is_non_writable = false;
- AttributeList ast_member_decorations;
+ Attributes ast_member_decorations;
for (auto& decoration : GetDecorationsForMember(type_id, member_index)) {
if (IsPipelineDecoration(decoration)) {
// IO decorations are handled when emitting the entry point.
@@ -1149,11 +1141,9 @@
// the members are non-writable.
is_non_writable = true;
} else {
- auto decos =
+ auto attrs =
ConvertMemberDecoration(type_id, member_index, ast_member_ty, decoration);
- for (auto* deco : decos) {
- ast_member_decorations.Push(deco);
- }
+ ast_member_decorations.Add(attrs);
if (!success_) {
return nullptr;
}
@@ -1168,7 +1158,7 @@
const auto member_name = namer_.GetMemberName(type_id, member_index);
auto* ast_struct_member =
builder_.Member(Source{}, member_name, ast_member_ty->Build(builder_),
- std::move(ast_member_decorations));
+ std::move(ast_member_decorations.list));
ast_members.Push(ast_struct_member);
}
@@ -1368,7 +1358,7 @@
break;
}
if (ast_type && ast_expr) {
- AttributeList spec_id_decos;
+ Attributes spec_id_attrs;
for (const auto& deco : GetDecorationsFor(inst.result_id())) {
if ((deco.size() == 2) && (deco[0] == uint32_t(spv::Decoration::SpecId))) {
const uint32_t id = deco[1];
@@ -1378,12 +1368,12 @@
<< inst.result_id() << " has SpecId " << id;
}
auto* cid = builder_.Id(Source{}, AInt(id));
- spec_id_decos.Push(cid);
+ spec_id_attrs.Add(cid);
break;
}
}
auto* ast_var =
- MakeOverride(inst.result_id(), ast_type, ast_expr, std::move(spec_id_decos));
+ MakeOverride(inst.result_id(), ast_type, ast_expr, std::move(spec_id_attrs));
if (ast_var) {
scalar_spec_constants_.insert(inst.result_id());
}
@@ -1506,7 +1496,7 @@
}
auto ast_access = VarAccess(ast_store_type, ast_address_space);
auto* ast_var = MakeVar(var.result_id(), ast_address_space, ast_access, ast_store_type,
- ast_initializer, utils::Empty);
+ ast_initializer, Attributes{});
// TODO(dneto): initializers (a.k.a. initializer expression)
if (ast_var) {
builder_.AST().AddGlobalVariable(ast_var);
@@ -1596,7 +1586,7 @@
builtin::Access access,
const Type* storage_type,
const ast::Expression* initializer,
- AttributeList decorations) {
+ Attributes attrs) {
if (storage_type == nullptr) {
Fail() << "internal error: can't make ast::Variable for null type";
return nullptr;
@@ -1608,14 +1598,14 @@
address_space = builtin::AddressSpace::kUndefined;
}
- if (!ConvertDecorationsForVariable(id, &storage_type, &decorations,
+ if (!ConvertDecorationsForVariable(id, &storage_type, attrs,
address_space != builtin::AddressSpace::kPrivate)) {
return nullptr;
}
auto sym = builder_.Symbols().Register(namer_.Name(id));
return builder_.Var(Source{}, sym, storage_type->Build(builder_), address_space, access,
- initializer, decorations);
+ initializer, std::move(attrs.list));
}
const ast::Let* ParserImpl::MakeLet(uint32_t id,
@@ -1628,28 +1618,27 @@
const ast::Override* ParserImpl::MakeOverride(uint32_t id,
const Type* type,
const ast::Expression* initializer,
- AttributeList decorations) {
- if (!ConvertDecorationsForVariable(id, &type, &decorations, false)) {
+ Attributes attrs) {
+ if (!ConvertDecorationsForVariable(id, &type, attrs, false)) {
return nullptr;
}
auto sym = builder_.Symbols().Register(namer_.Name(id));
- return builder_.Override(Source{}, sym, type->Build(builder_), initializer, decorations);
+ return builder_.Override(Source{}, sym, type->Build(builder_), initializer,
+ std::move(attrs.list));
}
-const ast::Parameter* ParserImpl::MakeParameter(uint32_t id,
- const Type* type,
- AttributeList decorations) {
- if (!ConvertDecorationsForVariable(id, &type, &decorations, false)) {
+const ast::Parameter* ParserImpl::MakeParameter(uint32_t id, const Type* type, Attributes attrs) {
+ if (!ConvertDecorationsForVariable(id, &type, attrs, false)) {
return nullptr;
}
auto sym = builder_.Symbols().Register(namer_.Name(id));
- return builder_.Param(Source{}, sym, type->Build(builder_), decorations);
+ return builder_.Param(Source{}, sym, type->Build(builder_), attrs.list);
}
bool ParserImpl::ConvertDecorationsForVariable(uint32_t id,
const Type** store_type,
- AttributeList* decorations,
+ Attributes& attrs,
bool transfer_pipeline_io) {
DecorationList non_builtin_pipeline_decorations;
for (auto& deco : GetDecorationsFor(id)) {
@@ -1709,7 +1698,7 @@
return false;
}
if (transfer_pipeline_io) {
- decorations->Push(create<ast::BuiltinAttribute>(Source{}, ast_builtin));
+ attrs.Add(builder_, Source{}, ast_builtin);
}
}
if (transfer_pipeline_io && IsPipelineDecoration(deco)) {
@@ -1720,19 +1709,18 @@
return Fail() << "malformed DescriptorSet decoration on ID " << id
<< ": has no operand";
}
- decorations->Push(builder_.Group(Source{}, AInt(deco[1])));
+ attrs.Add(builder_.Group(Source{}, AInt(deco[1])));
}
if (deco[0] == uint32_t(spv::Decoration::Binding)) {
if (deco.size() == 1) {
return Fail() << "malformed Binding decoration on ID " << id << ": has no operand";
}
- decorations->Push(builder_.Binding(Source{}, AInt(deco[1])));
+ attrs.Add(builder_.Binding(Source{}, AInt(deco[1])));
}
}
if (transfer_pipeline_io) {
- if (!ConvertPipelineDecorations(*store_type, non_builtin_pipeline_decorations,
- decorations)) {
+ if (!ConvertPipelineDecorations(*store_type, non_builtin_pipeline_decorations, attrs)) {
return false;
}
}
@@ -1753,11 +1741,11 @@
return result;
}
-void ParserImpl::SetLocation(AttributeList* attributes, const ast::Attribute* replacement) {
+void ParserImpl::SetLocation(Attributes& attributes, const ast::Attribute* replacement) {
if (!replacement) {
return;
}
- for (auto*& attribute : *attributes) {
+ for (auto*& attribute : attributes.list) {
if (attribute->Is<ast::LocationAttribute>()) {
// Replace this location attribute with the replacement.
// The old one doesn't leak because it's kept in the builder's AST node
@@ -1767,13 +1755,13 @@
}
}
// The list didn't have a location. Add it.
- attributes->Push(replacement);
+ attributes.Add(replacement);
return;
}
bool ParserImpl::ConvertPipelineDecorations(const Type* store_type,
const DecorationList& decorations,
- AttributeList* attributes) {
+ Attributes& attributes) {
// Vulkan defaults to perspective-correct interpolation.
builtin::InterpolationType type = builtin::InterpolationType::kPerspective;
builtin::InterpolationSampling sampling = builtin::InterpolationSampling::kUndefined;
@@ -1783,8 +1771,8 @@
switch (static_cast<spv::Decoration>(deco[0])) {
case spv::Decoration::Location:
if (deco.size() != 2) {
- return Fail() << "malformed Location decoration on ID requires one "
- "literal operand";
+ return Fail()
+ << "malformed Location decoration on ID requires one literal operand";
}
SetLocation(attributes, builder_.Location(AInt(deco[1])));
if (store_type->IsIntegerScalarOrVector()) {
@@ -1821,8 +1809,7 @@
}
}
- if (type == builtin::InterpolationType::kFlat &&
- !ast::HasAttribute<ast::LocationAttribute>(*attributes)) {
+ if (type == builtin::InterpolationType::kFlat && !attributes.Has<ast::LocationAttribute>()) {
// WGSL requires that '@interpolate(flat)' needs to be paired with '@location', however
// SPIR-V requires all fragment shader integer Inputs are 'flat'. If the decorations do not
// contain a spv::Decoration::Location, then make this perspective.
@@ -1834,7 +1821,7 @@
sampling == builtin::InterpolationSampling::kUndefined) {
// This is the default. Don't add a decoration.
} else {
- attributes->Push(create<ast::InterpolateAttribute>(type, sampling));
+ attributes.Add(create<ast::InterpolateAttribute>(type, sampling));
}
return success();
diff --git a/src/tint/reader/spirv/parser_impl.h b/src/tint/reader/spirv/parser_impl.h
index cd88b15..36c24de 100644
--- a/src/tint/reader/spirv/parser_impl.h
+++ b/src/tint/reader/spirv/parser_impl.h
@@ -37,6 +37,7 @@
#include "src/tint/program_builder.h"
#include "src/tint/reader/reader.h"
+#include "src/tint/reader/spirv/attributes.h"
#include "src/tint/reader/spirv/entry_point_info.h"
#include "src/tint/reader/spirv/enum_converter.h"
#include "src/tint/reader/spirv/namer.h"
@@ -122,7 +123,6 @@
/// Parser implementation for SPIR-V.
class ParserImpl : Reader {
- using AttributeList = utils::Vector<const ast::Attribute*, 8>;
using ExpressionList = utils::Vector<const ast::Expression*, 8>;
public:
@@ -261,7 +261,7 @@
/// @returns false when the variable should not be emitted as a variable
bool ConvertDecorationsForVariable(uint32_t id,
const Type** store_type,
- AttributeList* attributes,
+ Attributes& attributes,
bool transfer_pipeline_io);
/// Converts SPIR-V decorations for pipeline IO into AST decorations.
@@ -271,15 +271,15 @@
/// @returns false if conversion fails
bool ConvertPipelineDecorations(const Type* store_type,
const DecorationList& decorations,
- AttributeList* attributes);
+ Attributes& attributes);
/// Updates the attribute list, placing a non-null location decoration into
/// the list, replacing an existing one if it exists. Does nothing if the
/// replacement is nullptr.
/// Assumes the list contains at most one Location decoration.
- /// @param decos the attribute list to modify
+ /// @param attributes the attribute list to modify
/// @param replacement the location decoration to place into the list
- void SetLocation(AttributeList* decos, const ast::Attribute* replacement);
+ void SetLocation(Attributes& attributes, const ast::Attribute* replacement);
/// Converts a SPIR-V struct member decoration into a number of AST
/// decorations. If the decoration is recognized but deliberately dropped,
@@ -290,10 +290,10 @@
/// @param member_ty the type of the member
/// @param decoration an encoded SPIR-V Decoration
/// @returns the AST decorations
- AttributeList ConvertMemberDecoration(uint32_t struct_type_id,
- uint32_t member_index,
- const Type* member_ty,
- const Decoration& decoration);
+ Attributes ConvertMemberDecoration(uint32_t struct_type_id,
+ uint32_t member_index,
+ const Type* member_ty,
+ const Decoration& decoration);
/// Returns a string for the given type. If the type ID is invalid,
/// then the resulting string only names the type ID.
@@ -433,7 +433,7 @@
/// @param access the access
/// @param storage_type the storage type of the variable
/// @param initializer the variable initializer
- /// @param decorations the variable decorations
+ /// @param attributes the variable attributes
/// @returns a new Variable node, or null in the ignorable variable case and
/// in the error case
const ast::Var* MakeVar(uint32_t id,
@@ -441,7 +441,7 @@
builtin::Access access,
const Type* storage_type,
const ast::Expression* initializer,
- AttributeList decorations);
+ Attributes attributes);
/// Creates an AST 'let' node for a SPIR-V ID, including any attached decorations,.
/// @param id the SPIR-V result ID
@@ -454,20 +454,20 @@
/// @param id the SPIR-V result ID
/// @param type the type of the variable
/// @param initializer the variable initializer
- /// @param decorations the variable decorations
+ /// @param attributes the variable attributes
/// @returns the AST 'override' node
const ast::Override* MakeOverride(uint32_t id,
const Type* type,
const ast::Expression* initializer,
- AttributeList decorations);
+ Attributes attributes);
/// Creates an AST parameter node for a SPIR-V ID, including any attached decorations, unless
/// it's an ignorable builtin variable.
/// @param id the SPIR-V result ID
/// @param type the type of the parameter
- /// @param decorations the parameter decorations
+ /// @param attributes the parameter attributes
/// @returns the AST parameter node
- const ast::Parameter* MakeParameter(uint32_t id, const Type* type, AttributeList decorations);
+ const ast::Parameter* MakeParameter(uint32_t id, const Type* type, Attributes attributes);
/// Returns true if a constant expression can be generated.
/// @param id the SPIR-V ID of the value
diff --git a/src/tint/reader/spirv/parser_impl_convert_member_decoration_test.cc b/src/tint/reader/spirv/parser_impl_convert_member_decoration_test.cc
index 402cc41..d67ccf0 100644
--- a/src/tint/reader/spirv/parser_impl_convert_member_decoration_test.cc
+++ b/src/tint/reader/spirv/parser_impl_convert_member_decoration_test.cc
@@ -24,7 +24,7 @@
auto p = parser(std::vector<uint32_t>{});
auto result = p->ConvertMemberDecoration(1, 1, nullptr, {});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_THAT(p->error(), Eq("malformed SPIR-V decoration: it's empty"));
}
@@ -32,7 +32,7 @@
auto p = parser(std::vector<uint32_t>{});
auto result = p->ConvertMemberDecoration(12, 13, nullptr, {uint32_t(spv::Decoration::Offset)});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_THAT(p->error(), Eq("malformed Offset decoration: expected 1 literal "
"operand, has 0: member 13 of SPIR-V type 12"));
}
@@ -42,7 +42,7 @@
auto result =
p->ConvertMemberDecoration(12, 13, nullptr, {uint32_t(spv::Decoration::Offset), 3, 4});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_THAT(p->error(), Eq("malformed Offset decoration: expected 1 literal "
"operand, has 2: member 13 of SPIR-V type 12"));
}
@@ -51,9 +51,9 @@
auto p = parser(std::vector<uint32_t>{});
auto result = p->ConvertMemberDecoration(1, 1, nullptr, {uint32_t(spv::Decoration::Offset), 8});
- ASSERT_FALSE(result.IsEmpty());
- EXPECT_TRUE(result[0]->Is<ast::StructMemberOffsetAttribute>());
- auto* offset_deco = result[0]->As<ast::StructMemberOffsetAttribute>();
+ ASSERT_FALSE(result.list.IsEmpty());
+ EXPECT_TRUE(result.list[0]->Is<ast::StructMemberOffsetAttribute>());
+ auto* offset_deco = result.list[0]->As<ast::StructMemberOffsetAttribute>();
ASSERT_NE(offset_deco, nullptr);
ASSERT_TRUE(offset_deco->expr->Is<ast::IntLiteralExpression>());
EXPECT_EQ(offset_deco->expr->As<ast::IntLiteralExpression>()->value, 8u);
@@ -67,7 +67,7 @@
spirv::Matrix matrix(&f32, 2, 2);
auto result =
p->ConvertMemberDecoration(1, 1, &matrix, {uint32_t(spv::Decoration::MatrixStride), 8});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_TRUE(p->error().empty());
}
@@ -78,9 +78,9 @@
spirv::Matrix matrix(&f32, 2, 2);
auto result =
p->ConvertMemberDecoration(1, 1, &matrix, {uint32_t(spv::Decoration::MatrixStride), 16});
- ASSERT_FALSE(result.IsEmpty());
- EXPECT_TRUE(result[0]->Is<ast::StrideAttribute>());
- auto* stride_deco = result[0]->As<ast::StrideAttribute>();
+ ASSERT_FALSE(result.list.IsEmpty());
+ EXPECT_TRUE(result.list[0]->Is<ast::StrideAttribute>());
+ auto* stride_deco = result.list[0]->As<ast::StrideAttribute>();
ASSERT_NE(stride_deco, nullptr);
EXPECT_EQ(stride_deco->stride, 16u);
EXPECT_TRUE(p->error().empty());
@@ -93,7 +93,7 @@
spirv::Matrix matrix(&f32, 2, 4);
auto result =
p->ConvertMemberDecoration(1, 1, &matrix, {uint32_t(spv::Decoration::MatrixStride), 16});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_TRUE(p->error().empty());
}
@@ -104,9 +104,9 @@
spirv::Matrix matrix(&f32, 2, 4);
auto result =
p->ConvertMemberDecoration(1, 1, &matrix, {uint32_t(spv::Decoration::MatrixStride), 64});
- ASSERT_FALSE(result.IsEmpty());
- EXPECT_TRUE(result[0]->Is<ast::StrideAttribute>());
- auto* stride_deco = result[0]->As<ast::StrideAttribute>();
+ ASSERT_FALSE(result.list.IsEmpty());
+ EXPECT_TRUE(result.list[0]->Is<ast::StrideAttribute>());
+ auto* stride_deco = result.list[0]->As<ast::StrideAttribute>();
ASSERT_NE(stride_deco, nullptr);
EXPECT_EQ(stride_deco->stride, 64u);
EXPECT_TRUE(p->error().empty());
@@ -119,9 +119,9 @@
spirv::Matrix matrix(&f32, 2, 3);
auto result =
p->ConvertMemberDecoration(1, 1, &matrix, {uint32_t(spv::Decoration::MatrixStride), 32});
- ASSERT_FALSE(result.IsEmpty());
- EXPECT_TRUE(result[0]->Is<ast::StrideAttribute>());
- auto* stride_deco = result[0]->As<ast::StrideAttribute>();
+ ASSERT_FALSE(result.list.IsEmpty());
+ EXPECT_TRUE(result.list[0]->Is<ast::StrideAttribute>());
+ auto* stride_deco = result.list[0]->As<ast::StrideAttribute>();
ASSERT_NE(stride_deco, nullptr);
EXPECT_EQ(stride_deco->stride, 32u);
EXPECT_TRUE(p->error().empty());
@@ -135,7 +135,7 @@
auto result =
p->ConvertMemberDecoration(1, 1, nullptr, {uint32_t(spv::Decoration::RelaxedPrecision)});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_TRUE(p->error().empty());
}
@@ -143,7 +143,7 @@
auto p = parser(std::vector<uint32_t>{});
auto result = p->ConvertMemberDecoration(12, 13, nullptr, {12345678});
- EXPECT_TRUE(result.IsEmpty());
+ EXPECT_TRUE(result.list.IsEmpty());
EXPECT_THAT(p->error(), Eq("unhandled member decoration: 12345678 on member "
"13 of SPIR-V type 12"));
}
diff --git a/src/tint/reader/spirv/parser_impl_module_var_test.cc b/src/tint/reader/spirv/parser_impl_module_var_test.cc
index 5077a51..c731fbf 100644
--- a/src/tint/reader/spirv/parser_impl_module_var_test.cc
+++ b/src/tint/reader/spirv/parser_impl_module_var_test.cc
@@ -2861,7 +2861,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : i32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_2 : i32 = x_1;
@@ -2870,14 +2870,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = bitcast<i32>(x_1_param);
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected) << module_str;
@@ -2898,7 +2898,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : i32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_14 : ptr<private, i32> = &(x_1);
@@ -2908,14 +2908,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = bitcast<i32>(x_1_param);
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected) << module_str;
@@ -2936,7 +2936,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : i32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_2 : i32 = x_1;
@@ -2945,14 +2945,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = bitcast<i32>(x_1_param);
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected) << module_str;
@@ -2995,7 +2995,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : u32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_2 : u32 = x_1;
@@ -3004,14 +3004,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = x_1_param;
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected);
@@ -3032,7 +3032,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : u32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_14 : ptr<private, u32> = &(x_1);
@@ -3042,14 +3042,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = x_1_param;
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected);
@@ -3070,7 +3070,7 @@
const auto module_str = test::ToString(p->program());
const std::string expected = R"(var<private> x_1 : u32;
-var<private> position : vec4<f32>;
+var<private> position_1 : vec4<f32>;
fn main_1() {
let x_2 : u32 = x_1;
@@ -3079,14 +3079,14 @@
struct main_out {
@builtin(position)
- position_1 : vec4<f32>,
+ position_1_1 : vec4<f32>,
}
@vertex
fn main(@builtin(instance_index) x_1_param : u32) -> main_out {
x_1 = x_1_param;
main_1();
- return main_out(position);
+ return main_out(position_1);
}
)";
EXPECT_EQ(module_str, expected);
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index c4ae32e..c4c90ca 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -1125,23 +1125,6 @@
builtin::kInterpolationTypeStrings);
}
-// builtin_value_name
-// : frag_depth
-// | front_facing
-// | global_invocation_id
-// | instance_index
-// | local_invocation_id
-// | local_invocation_index
-// | num_workgroups
-// | position
-// | sample_index
-// | sample_mask
-// | vertex_index
-// | workgroup_id
-Expect<builtin::BuiltinValue> ParserImpl::expect_builtin() {
- return expect_enum("builtin", builtin::ParseBuiltinValue, builtin::kBuiltinValueStrings);
-}
-
// compound_statement
// : attribute* BRACE_LEFT statement* BRACE_RIGHT
Expect<ast::BlockStatement*> ParserImpl::expect_compound_statement(std::string_view use) {
@@ -3020,7 +3003,7 @@
if (t == "builtin") {
return expect_paren_block("builtin attribute", [&]() -> Result {
- auto builtin = expect_builtin();
+ auto builtin = expect_expression("builtin name");
if (builtin.errored) {
return Failure::kErrored;
}
diff --git a/src/tint/reader/wgsl/parser_impl.h b/src/tint/reader/wgsl/parser_impl.h
index 759e88d..19502c4 100644
--- a/src/tint/reader/wgsl/parser_impl.h
+++ b/src/tint/reader/wgsl/parser_impl.h
@@ -462,10 +462,6 @@
/// value type name.
/// @returns the parsed type name
Expect<builtin::InterpolationType> expect_interpolation_type_name();
- /// Parses a builtin identifier, erroring if the next token does not match a
- /// valid builtin name.
- /// @returns the parsed builtin.
- Expect<builtin::BuiltinValue> expect_builtin();
/// Parses a `compound_statement` grammar element, erroring on parse failure.
/// @param use a description of what was being parsed if an error was raised
/// @returns the parsed statements
diff --git a/src/tint/reader/wgsl/parser_impl_error_msg_test.cc b/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
index 6b92c3c..4727635 100644
--- a/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_error_msg_test.cc
@@ -969,25 +969,6 @@
)");
}
-TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBuiltinInvalidIdentifer) {
- EXPECT("@builtin(1) var i : i32;",
- R"(test.wgsl:1:10 error: expected builtin
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id'
-@builtin(1) var i : i32;
- ^
-)");
-}
-
-TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBuiltinInvalidValue) {
- EXPECT("@builtin(frag_d3pth) var i : i32;",
- R"(test.wgsl:1:10 error: expected builtin
-Did you mean 'frag_depth'?
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id'
-@builtin(frag_d3pth) var i : i32;
- ^^^^^^^^^^
-)");
-}
-
TEST_F(ParserImplErrorTest, GlobalDeclVarAttrBindingMissingLParen) {
EXPECT("@binding 1) var i : i32;",
R"(test.wgsl:1:10 error: expected '(' for binding attribute
diff --git a/src/tint/reader/wgsl/parser_impl_param_list_test.cc b/src/tint/reader/wgsl/parser_impl_param_list_test.cc
index 696d791..eb4db45 100644
--- a/src/tint/reader/wgsl/parser_impl_param_list_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_param_list_test.cc
@@ -102,7 +102,8 @@
auto attrs_0 = e.value[0]->attributes;
ASSERT_EQ(attrs_0.Length(), 1u);
EXPECT_TRUE(attrs_0[0]->Is<ast::BuiltinAttribute>());
- EXPECT_EQ(attrs_0[0]->As<ast::BuiltinAttribute>()->builtin, builtin::BuiltinValue::kPosition);
+ ast::CheckIdentifier(p->builder().Symbols(), attrs_0[0]->As<ast::BuiltinAttribute>()->builtin,
+ "position");
ASSERT_EQ(e.value[0]->source.range.begin.line, 1u);
ASSERT_EQ(e.value[0]->source.range.begin.column, 20u);
diff --git a/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc b/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
index 163396e..24ad020 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "src/tint/ast/test_helper.h"
#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
namespace tint::reader::wgsl {
@@ -38,7 +39,8 @@
EXPECT_EQ(exp->value, 4u);
ASSERT_TRUE(attr_1->Is<ast::BuiltinAttribute>());
- EXPECT_EQ(attr_1->As<ast::BuiltinAttribute>()->builtin, builtin::BuiltinValue::kPosition);
+ ast::CheckIdentifier(p->builder().Symbols(), attr_1->As<ast::BuiltinAttribute>()->builtin,
+ "position");
}
TEST_F(ParserImplTest, AttributeList_Invalid) {
@@ -51,27 +53,5 @@
EXPECT_EQ(p->error(), R"(1:2: expected attribute)");
}
-TEST_F(ParserImplTest, AttributeList_InvalidValue) {
- auto p = parser("@builtin(invalid)");
- auto attrs = p->attribute_list();
- EXPECT_TRUE(p->has_error());
- EXPECT_TRUE(attrs.errored);
- EXPECT_FALSE(attrs.matched);
- EXPECT_TRUE(attrs.value.IsEmpty());
- EXPECT_EQ(p->error(), R"(1:10: expected builtin
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
-}
-
-TEST_F(ParserImplTest, AttributeList_InvalidValueSuggest) {
- auto p = parser("@builtin(instanceindex)");
- auto attrs = p->attribute_list();
- EXPECT_TRUE(p->has_error());
- EXPECT_TRUE(attrs.errored);
- EXPECT_FALSE(attrs.matched);
- EXPECT_TRUE(attrs.value.IsEmpty());
- EXPECT_EQ(p->error(), R"(1:10: expected builtin
-Did you mean 'instance_index'?
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
-}
} // namespace
} // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc b/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
index 9468d1c..67df3b5 100644
--- a/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
@@ -12,6 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "src/tint/ast/test_helper.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/reader/wgsl/parser_impl_test_helper.h"
namespace tint::reader::wgsl {
@@ -215,20 +217,11 @@
EXPECT_EQ(p->error(), "1:10: expected location expression");
}
-struct BuiltinData {
- const char* input;
- builtin::BuiltinValue result;
-};
-inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
- out << std::string(data.input);
- return out;
-}
-
-class BuiltinTest : public ParserImplTestWithParam<BuiltinData> {};
+class BuiltinTest : public ParserImplTestWithParam<builtin::BuiltinValue> {};
TEST_P(BuiltinTest, Attribute_Builtin) {
- auto params = GetParam();
- auto p = parser(std::string("builtin(") + params.input + ")");
+ auto str = utils::ToString(GetParam());
+ auto p = parser("builtin(" + str + ")");
auto attr = p->attribute();
EXPECT_TRUE(attr.matched);
@@ -240,11 +233,11 @@
ASSERT_TRUE(var_attr->Is<ast::BuiltinAttribute>());
auto* builtin = var_attr->As<ast::BuiltinAttribute>();
- EXPECT_EQ(builtin->builtin, params.result);
+ ast::CheckIdentifier(p->builder().Symbols(), builtin->builtin, str);
}
TEST_P(BuiltinTest, Attribute_Builtin_TrailingComma) {
- auto params = GetParam();
- auto p = parser(std::string("builtin(") + params.input + ",)");
+ auto str = utils::ToString(GetParam());
+ auto p = parser("builtin(" + str + ",)");
auto attr = p->attribute();
EXPECT_TRUE(attr.matched);
@@ -256,24 +249,22 @@
ASSERT_TRUE(var_attr->Is<ast::BuiltinAttribute>());
auto* builtin = var_attr->As<ast::BuiltinAttribute>();
- EXPECT_EQ(builtin->builtin, params.result);
+ ast::CheckIdentifier(p->builder().Symbols(), builtin->builtin, str);
}
-INSTANTIATE_TEST_SUITE_P(
- ParserImplTest,
- BuiltinTest,
- testing::Values(BuiltinData{"position", builtin::BuiltinValue::kPosition},
- BuiltinData{"vertex_index", builtin::BuiltinValue::kVertexIndex},
- BuiltinData{"instance_index", builtin::BuiltinValue::kInstanceIndex},
- BuiltinData{"front_facing", builtin::BuiltinValue::kFrontFacing},
- BuiltinData{"frag_depth", builtin::BuiltinValue::kFragDepth},
- BuiltinData{"local_invocation_id", builtin::BuiltinValue::kLocalInvocationId},
- BuiltinData{"local_invocation_index",
- builtin::BuiltinValue::kLocalInvocationIndex},
- BuiltinData{"global_invocation_id", builtin::BuiltinValue::kGlobalInvocationId},
- BuiltinData{"workgroup_id", builtin::BuiltinValue::kWorkgroupId},
- BuiltinData{"num_workgroups", builtin::BuiltinValue::kNumWorkgroups},
- BuiltinData{"sample_index", builtin::BuiltinValue::kSampleIndex},
- BuiltinData{"sample_mask", builtin::BuiltinValue::kSampleMask}));
+INSTANTIATE_TEST_SUITE_P(ParserImplTest,
+ BuiltinTest,
+ testing::Values(builtin::BuiltinValue::kPosition,
+ builtin::BuiltinValue::kVertexIndex,
+ builtin::BuiltinValue::kInstanceIndex,
+ builtin::BuiltinValue::kFrontFacing,
+ builtin::BuiltinValue::kFragDepth,
+ builtin::BuiltinValue::kLocalInvocationId,
+ builtin::BuiltinValue::kLocalInvocationIndex,
+ builtin::BuiltinValue::kGlobalInvocationId,
+ builtin::BuiltinValue::kWorkgroupId,
+ builtin::BuiltinValue::kNumWorkgroups,
+ builtin::BuiltinValue::kSampleIndex,
+ builtin::BuiltinValue::kSampleMask));
TEST_F(ParserImplTest, Attribute_Builtin_MissingLeftParen) {
auto p = parser("builtin position)");
@@ -302,42 +293,7 @@
EXPECT_TRUE(attr.errored);
EXPECT_EQ(attr.value, nullptr);
EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), R"(1:9: expected builtin
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
-}
-
-TEST_F(ParserImplTest, Attribute_Builtin_InvalidValue) {
- auto p = parser("builtin(other_thingy)");
- auto attr = p->attribute();
- EXPECT_FALSE(attr.matched);
- EXPECT_TRUE(attr.errored);
- EXPECT_EQ(attr.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), R"(1:9: expected builtin
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
-}
-
-TEST_F(ParserImplTest, Attribute_Builtin_InvalidValueSuggest) {
- auto p = parser("builtin(front_face)");
- auto attr = p->attribute();
- EXPECT_FALSE(attr.matched);
- EXPECT_TRUE(attr.errored);
- EXPECT_EQ(attr.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), R"(1:9: expected builtin
-Did you mean 'front_facing'?
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
-}
-
-TEST_F(ParserImplTest, Attribute_Builtin_MissingInvalid) {
- auto p = parser("builtin(3)");
- auto attr = p->attribute();
- EXPECT_FALSE(attr.matched);
- EXPECT_TRUE(attr.errored);
- EXPECT_EQ(attr.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), R"(1:9: expected builtin
-Possible values: 'frag_depth', 'front_facing', 'global_invocation_id', 'instance_index', 'local_invocation_id', 'local_invocation_index', 'num_workgroups', 'position', 'sample_index', 'sample_mask', 'vertex_index', 'workgroup_id')");
+ EXPECT_EQ(p->error(), R"(1:9: expected expression for builtin name)");
}
TEST_F(ParserImplTest, Attribute_Interpolate_Flat) {
diff --git a/src/tint/resolver/attribute_validation_test.cc b/src/tint/resolver/attribute_validation_test.cc
index 3255c49..100c239 100644
--- a/src/tint/resolver/attribute_validation_test.cc
+++ b/src/tint/resolver/attribute_validation_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "src/tint/ast/disable_validation_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/transform/add_block_attribute.h"
@@ -221,9 +222,9 @@
} else {
EXPECT_FALSE(r()->Resolve());
if (params.kind == AttributeKind::kBuiltin) {
- EXPECT_EQ(r()->error(),
- "12:34 error: builtin(position) cannot be used in input of "
- "compute pipeline stage");
+ EXPECT_EQ(
+ r()->error(),
+ R"(12:34 error: @builtin(position) cannot be used in input of compute pipeline stage)");
} else if (params.kind == AttributeKind::kInterpolate ||
params.kind == AttributeKind::kLocation ||
params.kind == AttributeKind::kInvariant) {
@@ -314,9 +315,9 @@
} else {
EXPECT_FALSE(r()->Resolve());
if (params.kind == AttributeKind::kBuiltin) {
- EXPECT_EQ(r()->error(),
- "12:34 error: builtin(position) cannot be used in input of "
- "vertex pipeline stage");
+ EXPECT_EQ(
+ r()->error(),
+ R"(12:34 error: @builtin(position) cannot be used in input of vertex pipeline stage)");
} else if (params.kind == AttributeKind::kInvariant) {
EXPECT_EQ(r()->error(),
"12:34 error: invariant attribute must only be applied to a "
@@ -362,9 +363,9 @@
} else {
EXPECT_FALSE(r()->Resolve());
if (params.kind == AttributeKind::kBuiltin) {
- EXPECT_EQ(r()->error(),
- "12:34 error: builtin(position) cannot be used in output of "
- "compute pipeline stage");
+ EXPECT_EQ(
+ r()->error(),
+ R"(12:34 error: @builtin(position) cannot be used in output of compute pipeline stage)");
} else if (params.kind == AttributeKind::kInterpolate ||
params.kind == AttributeKind::kLocation ||
params.kind == AttributeKind::kInvariant) {
@@ -411,21 +412,20 @@
} else {
EXPECT_FALSE(r()->Resolve());
if (params.kind == AttributeKind::kBuiltin) {
- EXPECT_EQ(r()->error(),
- "12:34 error: builtin(position) cannot be used in output of "
- "fragment pipeline stage");
+ EXPECT_EQ(
+ r()->error(),
+ R"(12:34 error: @builtin(position) cannot be used in output of fragment pipeline stage)");
} else if (params.kind == AttributeKind::kInvariant) {
- EXPECT_EQ(r()->error(),
- "12:34 error: invariant attribute must only be applied to a "
- "position builtin");
+ EXPECT_EQ(
+ r()->error(),
+ R"(12:34 error: invariant attribute must only be applied to a position builtin)");
} else if (params.kind == AttributeKind::kLocation) {
EXPECT_EQ(r()->error(),
- "34:56 error: duplicate location attribute\n"
- "12:34 note: first attribute declared here");
+ R"(34:56 error: duplicate location attribute
+12:34 note: first attribute declared here)");
} else {
EXPECT_EQ(r()->error(),
- "12:34 error: attribute is not valid for entry point return "
- "types");
+ R"(12:34 error: attribute is not valid for entry point return types)");
}
}
}
@@ -470,12 +470,11 @@
EXPECT_FALSE(r()->Resolve());
if (params.kind == AttributeKind::kLocation) {
EXPECT_EQ(r()->error(),
- "34:56 error: multiple entry point IO attributes\n"
- "12:34 note: previously consumed location(1)");
+ R"(34:56 error: multiple entry point IO attributes
+12:34 note: previously consumed @location)");
} else {
EXPECT_EQ(r()->error(),
- "12:34 error: attribute is not valid for entry point return "
- "types");
+ R"(12:34 error: attribute is not valid for entry point return types)");
}
}
}
diff --git a/src/tint/resolver/builtins_validation_test.cc b/src/tint/resolver/builtins_validation_test.cc
index a6f5889..321c0b0 100644
--- a/src/tint/resolver/builtins_validation_test.cc
+++ b/src/tint/resolver/builtins_validation_test.cc
@@ -13,6 +13,7 @@
// limitations under the License.
#include "src/tint/ast/call_statement.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver_test_helper.h"
using namespace tint::number_suffixes; // NOLINT
@@ -145,7 +146,7 @@
EXPECT_TRUE(r()->Resolve()) << r()->error();
} else {
std::stringstream err;
- err << "12:34 error: builtin(" << params.builtin << ")";
+ err << "12:34 error: @builtin(" << params.builtin << ")";
err << " cannot be used in input of " << params.stage << " pipeline stage";
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), err.str());
@@ -178,9 +179,9 @@
Location(0_a),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "12:34 error: builtin(frag_depth) cannot be used in input of "
- "fragment pipeline stage");
+ EXPECT_EQ(
+ r()->error(),
+ "12:34 error: @builtin(frag_depth) cannot be used in input of fragment pipeline stage");
}
TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInputStruct_Fail) {
@@ -214,7 +215,7 @@
});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: builtin(frag_depth) cannot be used in input of "
+ "12:34 error: @builtin(frag_depth) cannot be used in input of "
"fragment pipeline stage\n"
"note: while analyzing entry point 'fragShader'");
}
@@ -272,7 +273,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(position) must be 'vec4<f32>'");
}
TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_ReturnType_Fail) {
@@ -288,7 +289,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(position) must be 'vec4<f32>'");
}
TEST_F(ResolverBuiltinsValidationTest, FragDepthNotF32_Struct_Fail) {
@@ -317,7 +318,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(frag_depth) must be 'f32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(frag_depth) must be 'f32'");
}
TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_Struct_Fail) {
@@ -346,7 +347,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_mask) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(sample_mask) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_ReturnType_Fail) {
@@ -361,7 +362,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_mask) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(sample_mask) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, SampleMaskIsNotU32_Fail) {
@@ -387,7 +388,7 @@
Location(0_a),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_mask) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(sample_mask) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Struct_Fail) {
@@ -416,7 +417,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_index) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(sample_index) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Fail) {
@@ -442,7 +443,7 @@
Location(0_a),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(sample_index) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(sample_index) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, PositionIsNotF32_Fail) {
@@ -468,7 +469,7 @@
Location(0_a),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(position) must be 'vec4<f32>'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(position) must be 'vec4<f32>'");
}
TEST_F(ResolverBuiltinsValidationTest, FragDepthIsNotF32_Fail) {
@@ -487,7 +488,7 @@
Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFragDepth),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(frag_depth) must be 'f32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(frag_depth) must be 'f32'");
}
TEST_F(ResolverBuiltinsValidationTest, VertexIndexIsNotU32_Fail) {
@@ -512,7 +513,7 @@
Builtin(builtin::BuiltinValue::kPosition),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(vertex_index) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(vertex_index) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, InstanceIndexIsNotU32) {
@@ -537,7 +538,7 @@
Builtin(builtin::BuiltinValue::kPosition),
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(instance_index) must be 'u32'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(instance_index) must be 'u32'");
}
TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) {
@@ -657,7 +658,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: store type of builtin(workgroup_id) must be "
+ "12:34 error: store type of @builtin(workgroup_id) must be "
"'vec3<u32>'");
}
@@ -672,7 +673,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: store type of builtin(num_workgroups) must be "
+ "12:34 error: store type of @builtin(num_workgroups) must be "
"'vec3<u32>'");
}
@@ -687,7 +688,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: store type of builtin(global_invocation_id) must be "
+ "12:34 error: store type of @builtin(global_invocation_id) must be "
"'vec3<u32>'");
}
@@ -703,7 +704,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: store type of builtin(local_invocation_index) must be "
+ "12:34 error: store type of @builtin(local_invocation_index) must be "
"'u32'");
}
@@ -718,7 +719,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: store type of builtin(local_invocation_id) must be "
+ "12:34 error: store type of @builtin(local_invocation_id) must be "
"'vec3<u32>'");
}
@@ -785,7 +786,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(front_facing) must be 'bool'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(front_facing) must be 'bool'");
}
TEST_F(ResolverBuiltinsValidationTest, FrontFacingMemberIsNotBool_Fail) {
@@ -814,7 +815,50 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: store type of builtin(front_facing) must be 'bool'");
+ EXPECT_EQ(r()->error(), "12:34 error: store type of @builtin(front_facing) must be 'bool'");
+}
+
+// TODO(crbug.com/tint/1846): This isn't a validation test, but this sits next to other @builtin
+// tests. Clean this up.
+TEST_F(ResolverBuiltinsValidationTest, StructMemberAttributeMapsToSemBuiltinEnum) {
+ // struct S {
+ // @builtin(front_facing) b : bool;
+ // };
+ // @fragment
+ // fn f(s : S) {}
+
+ auto* builtin = Builtin(builtin::BuiltinValue::kFrontFacing);
+ auto* s = Structure("S", utils::Vector{
+ Member("f", ty.bool_(), utils::Vector{builtin}),
+ });
+ Func("f", utils::Vector{Param("b", ty.Of(s))}, ty.void_(), utils::Empty,
+ utils::Vector{
+ Stage(ast::PipelineStage::kFragment),
+ });
+
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
+ auto* builtin_expr = Sem().Get(builtin);
+ ASSERT_NE(builtin_expr, nullptr);
+ EXPECT_EQ(builtin_expr->Value(), builtin::BuiltinValue::kFrontFacing);
+}
+
+// TODO(crbug.com/tint/1846): This isn't a validation test, but this sits next to other @builtin
+// tests. Clean this up.
+TEST_F(ResolverBuiltinsValidationTest, ParamAttributeMapsToSemBuiltinEnum) {
+ // @fragment
+ // fn f(@builtin(front_facing) b : bool) {}
+
+ auto* builtin = Builtin(builtin::BuiltinValue::kFrontFacing);
+ Func("f", utils::Vector{Param("b", ty.bool_(), utils::Vector{builtin})}, ty.void_(),
+ utils::Empty,
+ utils::Vector{
+ Stage(ast::PipelineStage::kFragment),
+ });
+
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
+ auto* builtin_expr = Sem().Get(builtin);
+ ASSERT_NE(builtin_expr, nullptr);
+ EXPECT_EQ(builtin_expr->Value(), builtin::BuiltinValue::kFrontFacing);
}
TEST_F(ResolverBuiltinsValidationTest, Length_Float_Scalar) {
diff --git a/src/tint/resolver/dependency_graph.cc b/src/tint/resolver/dependency_graph.cc
index fbf2b46..2100f6b 100644
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -55,6 +55,7 @@
#include "src/tint/ast/while_statement.h"
#include "src/tint/ast/workgroup_attribute.h"
#include "src/tint/builtin/builtin.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/scope_stack.h"
#include "src/tint/sem/builtin.h"
#include "src/tint/symbol_table.h"
@@ -424,6 +425,10 @@
TraverseValueExpression(binding->expr);
return true;
},
+ [&](const ast::BuiltinAttribute* builtin) {
+ TraverseExpression(builtin->builtin, "builtin", "references");
+ return true;
+ },
[&](const ast::GroupAttribute* group) {
TraverseValueExpression(group->expr);
return true;
@@ -480,6 +485,11 @@
graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_ty));
return;
}
+ if (auto builtin_val = builtin::ParseBuiltinValue(s);
+ builtin_val != builtin::BuiltinValue::kUndefined) {
+ graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_val));
+ return;
+ }
if (auto addr = builtin::ParseAddressSpace(s);
addr != builtin::AddressSpace::kUndefined) {
graph_.resolved_identifiers.Add(from, ResolvedIdentifier(addr));
@@ -863,6 +873,9 @@
if (auto builtin_ty = BuiltinType(); builtin_ty != builtin::Builtin::kUndefined) {
return "builtin type '" + utils::ToString(builtin_ty) + "'";
}
+ if (auto builtin_val = BuiltinValue(); builtin_val != builtin::BuiltinValue::kUndefined) {
+ return "builtin value '" + utils::ToString(builtin_val) + "'";
+ }
if (auto access = Access(); access != builtin::Access::kUndefined) {
return "access '" + utils::ToString(access) + "'";
}
diff --git a/src/tint/resolver/dependency_graph.h b/src/tint/resolver/dependency_graph.h
index 8db2ab4..382514f 100644
--- a/src/tint/resolver/dependency_graph.h
+++ b/src/tint/resolver/dependency_graph.h
@@ -21,6 +21,7 @@
#include "src/tint/ast/module.h"
#include "src/tint/builtin/access.h"
#include "src/tint/builtin/builtin.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/builtin/texel_format.h"
#include "src/tint/diagnostic/diagnostic.h"
#include "src/tint/sem/builtin_type.h"
@@ -38,6 +39,7 @@
/// - builtin::Access
/// - builtin::AddressSpace
/// - builtin::Builtin
+/// - builtin::BuiltinValue
/// - builtin::TexelFormat
class ResolvedIdentifier {
public:
@@ -95,8 +97,17 @@
return builtin::Builtin::kUndefined;
}
- /// @return the texel format if the ResolvedIdentifier holds builtin::TexelFormat, otherwise
- /// builtin::TexelFormat::kUndefined
+ /// @return the builtin value if the ResolvedIdentifier holds builtin::BuiltinValue, otherwise
+ /// builtin::BuiltinValue::kUndefined
+ builtin::BuiltinValue BuiltinValue() const {
+ if (auto n = std::get_if<builtin::BuiltinValue>(&value_)) {
+ return *n;
+ }
+ return builtin::BuiltinValue::kUndefined;
+ }
+
+ /// @return the texel format if the ResolvedIdentifier holds type::TexelFormat, otherwise
+ /// type::TexelFormat::kUndefined
builtin::TexelFormat TexelFormat() const {
if (auto n = std::get_if<builtin::TexelFormat>(&value_)) {
return *n;
@@ -133,6 +144,7 @@
builtin::Access,
builtin::AddressSpace,
builtin::Builtin,
+ builtin::BuiltinValue,
builtin::TexelFormat>
value_;
};
diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc
index 8f15ad9..d8ec08b 100644
--- a/src/tint/resolver/dependency_graph_test.cc
+++ b/src/tint/resolver/dependency_graph_test.cc
@@ -1501,6 +1501,91 @@
} // namespace resolve_to_address_space
////////////////////////////////////////////////////////////////////////////////
+// Resolve to builtin::BuiltinValue tests
+////////////////////////////////////////////////////////////////////////////////
+namespace resolve_to_builtin_value {
+
+using ResolverDependencyGraphResolveToBuiltinValue =
+ ResolverDependencyGraphTestWithParam<std::tuple<SymbolUseKind, const char*>>;
+
+TEST_P(ResolverDependencyGraphResolveToBuiltinValue, Resolve) {
+ const auto use = std::get<0>(GetParam());
+ const auto name = std::get<1>(GetParam());
+ const auto symbol = Symbols().New(name);
+
+ SymbolTestHelper helper(this);
+ auto* ident = helper.Add(use, symbol);
+ helper.Build();
+
+ auto resolved = Build().resolved_identifiers.Get(ident);
+ ASSERT_TRUE(resolved);
+ EXPECT_EQ(resolved->BuiltinValue(), builtin::ParseBuiltinValue(name))
+ << resolved->String(Symbols(), Diagnostics());
+}
+
+TEST_P(ResolverDependencyGraphResolveToBuiltinValue, ShadowedByGlobalConst) {
+ const auto use = std::get<0>(GetParam());
+ const auto builtin = std::get<1>(GetParam());
+ const auto symbol = Symbols().New(utils::ToString(builtin));
+
+ SymbolTestHelper helper(this);
+ auto* decl = helper.Add(SymbolDeclKind::GlobalConst, symbol);
+ auto* ident = helper.Add(use, symbol);
+ helper.Build();
+
+ auto resolved = Build().resolved_identifiers.Get(ident);
+ ASSERT_TRUE(resolved);
+ EXPECT_EQ(resolved->Node(), decl) << resolved->String(Symbols(), Diagnostics());
+}
+
+TEST_P(ResolverDependencyGraphResolveToBuiltinValue, ShadowedByStruct) {
+ const auto use = std::get<0>(GetParam());
+ const auto builtin = std::get<1>(GetParam());
+ const auto symbol = Symbols().New(utils::ToString(builtin));
+
+ SymbolTestHelper helper(this);
+ auto* decl = helper.Add(SymbolDeclKind::Struct, symbol);
+ auto* ident = helper.Add(use, symbol);
+ helper.Build();
+
+ auto resolved = Build().resolved_identifiers.Get(ident);
+ ASSERT_TRUE(resolved);
+ EXPECT_EQ(resolved->Node(), decl) << resolved->String(Symbols(), Diagnostics());
+}
+
+TEST_P(ResolverDependencyGraphResolveToBuiltinValue, ShadowedByFunc) {
+ const auto use = std::get<0>(GetParam());
+ const auto builtin = std::get<1>(GetParam());
+ const auto symbol = Symbols().New(utils::ToString(builtin));
+
+ SymbolTestHelper helper(this);
+ auto* decl = helper.Add(SymbolDeclKind::Function, symbol);
+ auto* ident = helper.Add(use, symbol);
+ helper.Build();
+
+ auto resolved = Build().resolved_identifiers.Get(ident);
+ ASSERT_TRUE(resolved);
+ EXPECT_EQ(resolved->Node(), decl) << resolved->String(Symbols(), Diagnostics());
+}
+
+INSTANTIATE_TEST_SUITE_P(Types,
+ ResolverDependencyGraphResolveToBuiltinValue,
+ testing::Combine(testing::ValuesIn(kTypeUseKinds),
+ testing::ValuesIn(builtin::kBuiltinValueStrings)));
+
+INSTANTIATE_TEST_SUITE_P(Values,
+ ResolverDependencyGraphResolveToBuiltinValue,
+ testing::Combine(testing::ValuesIn(kValueUseKinds),
+ testing::ValuesIn(builtin::kBuiltinValueStrings)));
+
+INSTANTIATE_TEST_SUITE_P(Functions,
+ ResolverDependencyGraphResolveToBuiltinValue,
+ testing::Combine(testing::ValuesIn(kFuncUseKinds),
+ testing::ValuesIn(builtin::kBuiltinValueStrings)));
+
+} // namespace resolve_to_builtin_value
+
+////////////////////////////////////////////////////////////////////////////////
// Resolve to builtin::TexelFormat tests
////////////////////////////////////////////////////////////////////////////////
namespace resolve_to_texel_format {
@@ -1686,6 +1771,7 @@
Param(Sym(), T,
utils::Vector{
Location(V), // Parameter attributes
+ Builtin(V),
}),
},
T, // Return type
diff --git a/src/tint/resolver/entry_point_validation_test.cc b/src/tint/resolver/entry_point_validation_test.cc
index be027d8..dac6cd2 100644
--- a/src/tint/resolver/entry_point_validation_test.cc
+++ b/src/tint/resolver/entry_point_validation_test.cc
@@ -16,6 +16,7 @@
#include "src/tint/ast/location_attribute.h"
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/stage_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver.h"
#include "src/tint/resolver/resolver_test_helper.h"
@@ -94,7 +95,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: missing entry point IO attribute on return type");
+ EXPECT_EQ(r()->error(), R"(12:34 error: missing entry point IO attribute on return type)");
}
TEST_F(ResolverEntryPointValidationTest, ReturnTypeAttribute_Multiple) {
@@ -116,7 +117,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(14:52 error: multiple entry point IO attributes
-13:43 note: previously consumed location(0))");
+13:43 note: previously consumed @location)");
}
TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_Valid) {
@@ -170,7 +171,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(14:52 error: multiple entry point IO attributes
-13:43 note: previously consumed location(0)
+13:43 note: previously consumed @location
12:34 note: while analyzing entry point 'main')");
}
@@ -226,9 +227,8 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(
- r()->error(),
- R"(12:34 error: builtin(frag_depth) attribute appears multiple times as pipeline output
+ EXPECT_EQ(r()->error(),
+ R"(12:34 error: @builtin(frag_depth) appears multiple times as pipeline output
12:34 note: while analyzing entry point 'main')");
}
@@ -265,7 +265,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "13:43 error: missing entry point IO attribute on parameter");
+ EXPECT_EQ(r()->error(), R"(13:43 error: missing entry point IO attribute on parameter)");
}
TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Multiple) {
@@ -287,7 +287,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(14:52 error: multiple entry point IO attributes
-13:43 note: previously consumed location(0))");
+13:43 note: previously consumed @location)");
}
TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_Valid) {
@@ -341,7 +341,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), R"(14:52 error: multiple entry point IO attributes
-13:43 note: previously consumed location(0)
+13:43 note: previously consumed @location
12:34 note: while analyzing entry point 'main')");
}
@@ -396,8 +396,7 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: builtin(sample_index) attribute appears multiple times as "
- "pipeline input");
+ "12:34 error: @builtin(sample_index) appears multiple times as pipeline input");
}
TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_DuplicateBuiltins) {
@@ -432,9 +431,8 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(
- r()->error(),
- R"(12:34 error: builtin(sample_index) attribute appears multiple times as pipeline input
+ EXPECT_EQ(r()->error(),
+ R"(12:34 error: @builtin(sample_index) appears multiple times as pipeline input
12:34 note: while analyzing entry point 'main')");
}
@@ -785,10 +783,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: cannot apply 'location' attribute to declaration of "
- "type 'bool'\n"
- "34:56 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(12:34 error: cannot apply @location to declaration of type 'bool'
+34:56 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadType_Output_Array) {
@@ -808,10 +804,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: cannot apply 'location' attribute to declaration of "
- "type 'array<f32, 2>'\n"
- "34:56 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(12:34 error: cannot apply @location to declaration of type 'array<f32, 2>'
+34:56 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadType_Input_Struct) {
@@ -838,10 +832,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "12:34 error: cannot apply 'location' attribute to declaration of "
- "type 'Input'\n"
- "13:43 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(12:34 error: cannot apply @location to declaration of type 'Input'
+13:43 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadType_Input_Struct_NestedStruct) {
@@ -872,8 +864,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "14:52 error: nested structures cannot be used for entry point IO\n"
- "12:34 note: while analyzing entry point 'main'");
+ R"(14:52 error: nested structures cannot be used for entry point IO
+12:34 note: while analyzing entry point 'main')");
}
TEST_F(LocationAttributeTests, BadType_Input_Struct_RuntimeArray) {
@@ -898,10 +890,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "13:43 error: cannot apply 'location' attribute to declaration of "
- "type 'array<f32>'\n"
- "note: 'location' attribute must only be applied to declarations "
- "of numeric scalar or numeric vector type");
+ R"(13:43 error: cannot apply @location to declaration of type 'array<f32>'
+note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadMemberType_Input) {
@@ -927,10 +917,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "34:56 error: cannot apply 'location' attribute to declaration of "
- "type 'array<i32>'\n"
- "12:34 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(34:56 error: cannot apply @location to declaration of type 'array<i32>'
+12:34 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadMemberType_Output) {
@@ -954,10 +942,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "34:56 error: cannot apply 'location' attribute to declaration of "
- "type 'atomic<i32>'\n"
- "12:34 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(34:56 error: cannot apply @location to declaration of type 'atomic<i32>'
+12:34 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, BadMemberType_Unused) {
@@ -971,10 +957,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "34:56 error: cannot apply 'location' attribute to declaration of "
- "type 'mat3x2<f32>'\n"
- "12:34 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(34:56 error: cannot apply @location to declaration of type 'mat3x2<f32>'
+12:34 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, ReturnType_Struct_Valid) {
@@ -1026,11 +1010,8 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "12:34 error: cannot apply 'location' attribute to declaration of "
- "type 'Output'\n"
- "13:43 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ EXPECT_EQ(r()->error(), R"(12:34 error: cannot apply @location to declaration of type 'Output'
+13:43 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, ReturnType_Struct_NestedStruct) {
@@ -1059,8 +1040,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "14:52 error: nested structures cannot be used for entry point IO\n"
- "12:34 note: while analyzing entry point 'main'");
+ R"(14:52 error: nested structures cannot be used for entry point IO
+12:34 note: while analyzing entry point 'main')");
}
TEST_F(LocationAttributeTests, ReturnType_Struct_RuntimeArray) {
@@ -1085,10 +1066,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "13:43 error: cannot apply 'location' attribute to declaration of "
- "type 'array<f32>'\n"
- "12:34 note: 'location' attribute must only be applied to "
- "declarations of numeric scalar or numeric vector type");
+ R"(13:43 error: cannot apply @location to declaration of type 'array<f32>'
+12:34 note: @location must only be applied to declarations of numeric scalar or numeric vector type)");
}
TEST_F(LocationAttributeTests, ComputeShaderLocation_Input) {
@@ -1105,7 +1084,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for compute shader output");
+ EXPECT_EQ(r()->error(), R"(12:34 error: attribute is not valid for compute shader output)");
}
TEST_F(LocationAttributeTests, ComputeShaderLocation_Output) {
@@ -1120,7 +1099,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: attribute is not valid for compute shader inputs");
+ EXPECT_EQ(r()->error(), R"(12:34 error: attribute is not valid for compute shader inputs)");
}
TEST_F(LocationAttributeTests, ComputeShaderLocationStructMember_Output) {
@@ -1186,7 +1165,7 @@
});
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(), "12:34 error: location(1) attribute appears multiple times");
+ EXPECT_EQ(r()->error(), R"(12:34 error: @location(1) appears multiple times)");
}
TEST_F(LocationAttributeTests, Duplicate_struct) {
@@ -1219,8 +1198,8 @@
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
- "34:56 error: location(1) attribute appears multiple times\n"
- "12:34 note: while analyzing entry point 'main'");
+ R"(34:56 error: @location(1) appears multiple times
+12:34 note: while analyzing entry point 'main')");
}
} // namespace
diff --git a/src/tint/resolver/expression_kind_test.cc b/src/tint/resolver/expression_kind_test.cc
index 681b5c3..8761055 100644
--- a/src/tint/resolver/expression_kind_test.cc
+++ b/src/tint/resolver/expression_kind_test.cc
@@ -27,6 +27,7 @@
kAddressSpace,
kBuiltinFunction,
kBuiltinType,
+ kBuiltinValue,
kFunction,
kStruct,
kTexelFormat,
@@ -44,6 +45,8 @@
return out << "Def::kBuiltinFunction";
case Def::kBuiltinType:
return out << "Def::kBuiltinType";
+ case Def::kBuiltinValue:
+ return out << "Def::kBuiltinValue";
case Def::kFunction:
return out << "Def::kFunction";
case Def::kStruct:
@@ -62,6 +65,7 @@
kAccess,
kAddressSpace,
kBinaryOp,
+ kBuiltinValue,
kCallExpr,
kCallStmt,
kFunctionReturnType,
@@ -80,6 +84,8 @@
return out << "Use::kAddressSpace";
case Use::kBinaryOp:
return out << "Use::kBinaryOp";
+ case Use::kBuiltinValue:
+ return out << "Use::kBuiltinValue";
case Use::kCallExpr:
return out << "Use::kCallExpr";
case Use::kCallStmt:
@@ -156,6 +162,16 @@
};
break;
}
+ case Def::kBuiltinValue: {
+ sym = Sym("position");
+ check_expr = [](const sem::Expression* expr) {
+ ASSERT_NE(expr, nullptr);
+ auto* enum_expr = expr->As<sem::BuiltinEnumExpression<builtin::BuiltinValue>>();
+ ASSERT_NE(enum_expr, nullptr);
+ EXPECT_EQ(enum_expr->Value(), builtin::BuiltinValue::kPosition);
+ };
+ break;
+ }
case Def::kFunction: {
auto* fn = Func(kDefSource, "FUNCTION", utils::Empty, ty.i32(), Return(1_i));
sym = Sym("FUNCTION");
@@ -233,6 +249,10 @@
case Use::kBinaryOp:
GlobalVar("v", builtin::AddressSpace::kPrivate, Mul(1_a, expr));
break;
+ case Use::kBuiltinValue:
+ Func("f", utils::Vector{Param("p", ty.vec4<f32>(), utils::Vector{Builtin(expr)})},
+ ty.void_(), utils::Empty, utils::Vector{Stage(ast::PipelineStage::kFragment)});
+ break;
case Use::kFunctionReturnType:
Func("f", utils::Empty, ty(expr), Return(Call(sym)));
break;
@@ -271,6 +291,8 @@
{Def::kAccess, Use::kAddressSpace,
R"(5:6 error: cannot use access 'write' as address space)"},
{Def::kAccess, Use::kBinaryOp, R"(5:6 error: cannot use access 'write' as value)"},
+ {Def::kAccess, Use::kBuiltinValue,
+ R"(5:6 error: cannot use access 'write' as builtin value)"},
{Def::kAccess, Use::kCallExpr, R"(5:6 error: cannot use access 'write' as call target)"},
{Def::kAccess, Use::kCallStmt, R"(5:6 error: cannot use access 'write' as call target)"},
{Def::kAccess, Use::kFunctionReturnType, R"(5:6 error: cannot use access 'write' as type)"},
@@ -286,6 +308,8 @@
{Def::kAddressSpace, Use::kAddressSpace, kPass},
{Def::kAddressSpace, Use::kBinaryOp,
R"(5:6 error: cannot use address space 'workgroup' as value)"},
+ {Def::kAddressSpace, Use::kBuiltinValue,
+ R"(5:6 error: cannot use address space 'workgroup' as builtin value)"},
{Def::kAddressSpace, Use::kCallExpr,
R"(5:6 error: cannot use address space 'workgroup' as call target)"},
{Def::kAddressSpace, Use::kCallStmt,
@@ -309,6 +333,8 @@
R"(7:8 error: missing '(' for builtin function call)"},
{Def::kBuiltinFunction, Use::kBinaryOp,
R"(7:8 error: missing '(' for builtin function call)"},
+ {Def::kBuiltinFunction, Use::kBuiltinValue,
+ R"(7:8 error: missing '(' for builtin function call)"},
{Def::kBuiltinFunction, Use::kCallStmt, kPass},
{Def::kBuiltinFunction, Use::kFunctionReturnType,
R"(7:8 error: missing '(' for builtin function call)"},
@@ -329,6 +355,8 @@
{Def::kBuiltinType, Use::kBinaryOp,
R"(5:6 error: cannot use type 'vec4<f32>' as value
7:8 note: are you missing '()' for type initializer?)"},
+ {Def::kBuiltinType, Use::kBuiltinValue,
+ R"(5:6 error: cannot use type 'vec4<f32>' as builtin value)"},
{Def::kBuiltinType, Use::kCallExpr, kPass},
{Def::kBuiltinType, Use::kFunctionReturnType, kPass},
{Def::kBuiltinType, Use::kMemberType, kPass},
@@ -342,6 +370,30 @@
R"(5:6 error: cannot use type 'vec4<f32>' as value
7:8 note: are you missing '()' for type initializer?)"},
+ {Def::kBuiltinValue, Use::kAccess,
+ R"(5:6 error: cannot use builtin value 'position' as access)"},
+ {Def::kBuiltinValue, Use::kAddressSpace,
+ R"(5:6 error: cannot use builtin value 'position' as address space)"},
+ {Def::kBuiltinValue, Use::kBinaryOp,
+ R"(5:6 error: cannot use builtin value 'position' as value)"},
+ {Def::kBuiltinValue, Use::kBuiltinValue, kPass},
+ {Def::kBuiltinValue, Use::kCallStmt,
+ R"(5:6 error: cannot use builtin value 'position' as call target)"},
+ {Def::kBuiltinValue, Use::kCallExpr,
+ R"(5:6 error: cannot use builtin value 'position' as call target)"},
+ {Def::kBuiltinValue, Use::kFunctionReturnType,
+ R"(5:6 error: cannot use builtin value 'position' as type)"},
+ {Def::kBuiltinValue, Use::kMemberType,
+ R"(5:6 error: cannot use builtin value 'position' as type)"},
+ {Def::kBuiltinValue, Use::kTexelFormat,
+ R"(5:6 error: cannot use builtin value 'position' as texel format)"},
+ {Def::kBuiltinValue, Use::kValueExpression,
+ R"(5:6 error: cannot use builtin value 'position' as value)"},
+ {Def::kBuiltinValue, Use::kVariableType,
+ R"(5:6 error: cannot use builtin value 'position' as type)"},
+ {Def::kBuiltinValue, Use::kUnaryOp,
+ R"(5:6 error: cannot use builtin value 'position' as value)"},
+
{Def::kFunction, Use::kAccess, R"(5:6 error: cannot use function 'FUNCTION' as access
1:2 note: function 'FUNCTION' declared here)"},
{Def::kFunction, Use::kAddressSpace,
@@ -349,6 +401,9 @@
1:2 note: function 'FUNCTION' declared here)"},
{Def::kFunction, Use::kBinaryOp, R"(5:6 error: cannot use function 'FUNCTION' as value
1:2 note: function 'FUNCTION' declared here)"},
+ {Def::kFunction, Use::kBuiltinValue,
+ R"(5:6 error: cannot use function 'FUNCTION' as builtin value
+1:2 note: function 'FUNCTION' declared here)"},
{Def::kFunction, Use::kCallExpr, kPass},
{Def::kFunction, Use::kCallStmt, kPass},
{Def::kFunction, Use::kFunctionReturnType,
@@ -375,6 +430,8 @@
{Def::kStruct, Use::kBinaryOp, R"(5:6 error: cannot use type 'STRUCT' as value
7:8 note: are you missing '()' for type initializer?
1:2 note: struct 'STRUCT' declared here)"},
+ {Def::kStruct, Use::kBuiltinValue,
+ R"(5:6 error: cannot use type 'STRUCT' as builtin value)"},
{Def::kStruct, Use::kFunctionReturnType, kPass},
{Def::kStruct, Use::kMemberType, kPass},
{Def::kStruct, Use::kTexelFormat, R"(5:6 error: cannot use type 'STRUCT' as texel format)"},
@@ -394,6 +451,8 @@
R"(5:6 error: cannot use texel format 'rgba8unorm' as address space)"},
{Def::kTexelFormat, Use::kBinaryOp,
R"(5:6 error: cannot use texel format 'rgba8unorm' as value)"},
+ {Def::kTexelFormat, Use::kBuiltinValue,
+ R"(5:6 error: cannot use texel format 'rgba8unorm' as builtin value)"},
{Def::kTexelFormat, Use::kCallExpr,
R"(5:6 error: cannot use texel format 'rgba8unorm' as call target)"},
{Def::kTexelFormat, Use::kCallStmt,
@@ -416,6 +475,8 @@
{Def::kTypeAlias, Use::kBinaryOp,
R"(5:6 error: cannot use type 'i32' as value
7:8 note: are you missing '()' for type initializer?)"},
+ {Def::kTypeAlias, Use::kBuiltinValue,
+ R"(5:6 error: cannot use type 'i32' as builtin value)"},
{Def::kTypeAlias, Use::kCallExpr, kPass},
{Def::kTypeAlias, Use::kFunctionReturnType, kPass},
{Def::kTypeAlias, Use::kMemberType, kPass},
@@ -434,6 +495,9 @@
R"(5:6 error: cannot use const 'VARIABLE' as address space
1:2 note: const 'VARIABLE' declared here)"},
{Def::kVariable, Use::kBinaryOp, kPass},
+ {Def::kVariable, Use::kBuiltinValue,
+ R"(5:6 error: cannot use const 'VARIABLE' as builtin value
+1:2 note: const 'VARIABLE' declared here)"},
{Def::kVariable, Use::kCallStmt,
R"(5:6 error: cannot use const 'VARIABLE' as call target
1:2 note: const 'VARIABLE' declared here)"},
diff --git a/src/tint/resolver/function_validation_test.cc b/src/tint/resolver/function_validation_test.cc
index b6b5ed6..b7af242 100644
--- a/src/tint/resolver/function_validation_test.cc
+++ b/src/tint/resolver/function_validation_test.cc
@@ -15,6 +15,7 @@
#include "src/tint/ast/discard_statement.h"
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/stage_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver.h"
#include "src/tint/resolver/resolver_test_helper.h"
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 2bbf15d..3d0b539 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -89,6 +89,7 @@
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::Access>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::AddressSpace>);
+TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::BuiltinValue>);
TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression<tint::builtin::TexelFormat>);
namespace tint::resolver {
@@ -611,7 +612,9 @@
};
for (auto* attr : param->attributes) {
- Mark(attr);
+ if (!Attribute(attr)) {
+ return nullptr;
+ }
}
if (!validator_.NoDuplicateAttributes(param->attributes)) {
return nullptr;
@@ -792,7 +795,9 @@
}
for (auto* attr : v->attributes) {
- Mark(attr);
+ if (!Attribute(attr)) {
+ return nullptr;
+ }
}
if (!validator_.NoDuplicateAttributes(v->attributes)) {
@@ -854,11 +859,8 @@
validator_.DiagnosticFilters().Push();
TINT_DEFER(validator_.DiagnosticFilters().Pop());
for (auto* attr : decl->attributes) {
- Mark(attr);
- if (auto* dc = attr->As<ast::DiagnosticAttribute>()) {
- if (!DiagnosticControl(dc->control)) {
- return nullptr;
- }
+ if (!Attribute(attr)) {
+ return nullptr;
}
}
if (!validator_.NoDuplicateAttributes(decl->attributes)) {
@@ -921,7 +923,9 @@
// Determine if the return type has a location
std::optional<uint32_t> return_location;
for (auto* attr : decl->return_type_attributes) {
- Mark(attr);
+ if (!Attribute(attr)) {
+ return nullptr;
+ }
if (auto* loc_attr = attr->As<ast::LocationAttribute>()) {
auto value = LocationAttribute(loc_attr);
@@ -1502,6 +1506,11 @@
return sem_.AsAddressSpace(Expression(expr));
}
+sem::BuiltinEnumExpression<builtin::BuiltinValue>* Resolver::BuiltinValueExpression(
+ const ast::Expression* expr) {
+ return sem_.AsBuiltinValue(Expression(expr));
+}
+
sem::BuiltinEnumExpression<builtin::TexelFormat>* Resolver::TexelFormatExpression(
const ast::Expression* expr) {
return sem_.AsTexelFormat(Expression(expr));
@@ -2987,6 +2996,11 @@
expr, current_statement_, addr);
}
+ if (auto builtin = resolved->BuiltinValue(); builtin != builtin::BuiltinValue::kUndefined) {
+ return builder_->create<sem::BuiltinEnumExpression<builtin::BuiltinValue>>(
+ expr, current_statement_, builtin);
+ }
+
if (auto fmt = resolved->TexelFormat(); fmt != builtin::TexelFormat::kUndefined) {
return builder_->create<sem::BuiltinEnumExpression<builtin::TexelFormat>>(
expr, current_statement_, fmt);
@@ -3307,6 +3321,26 @@
return sem;
}
+bool Resolver::Attribute(const ast::Attribute* attr) {
+ Mark(attr);
+ return Switch(
+ attr, //
+ [&](const ast::BuiltinAttribute* b) { return BuiltinAttribute(b); },
+ [&](const ast::DiagnosticAttribute* dc) { return DiagnosticControl(dc->control); },
+ [&](Default) { return true; });
+}
+
+bool Resolver::BuiltinAttribute(const ast::BuiltinAttribute* attr) {
+ auto* builtin_expr = BuiltinValueExpression(attr->builtin);
+ if (!builtin_expr) {
+ return false;
+ }
+ // Apply the resolved tint::sem::BuiltinEnumExpression<tint::builtin::BuiltinValue> to the
+ // attribute.
+ builder_->Sem().Add(attr, builtin_expr);
+ return true;
+}
+
bool Resolver::DiagnosticControl(const ast::DiagnosticControl& control) {
Mark(control.rule_name);
@@ -3522,7 +3556,9 @@
bool has_size_attr = false;
std::optional<uint32_t> location;
for (auto* attr : member->attributes) {
- Mark(attr);
+ if (!Attribute(attr)) {
+ return nullptr;
+ }
bool ok = Switch(
attr, //
[&](const ast::StructMemberOffsetAttribute* o) {
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 6829bac..2a04a2a 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -146,9 +146,15 @@
const ast::Expression* expr);
/// @returns the call of Expression() cast to a
- /// sem::BuiltinEnumExpression<builtin::TexelFormat>. If the sem::Expression is not a
- /// sem::BuiltinEnumExpression<builtin::TexelFormat>, then an error diagnostic is raised and
+ /// sem::BuiltinEnumExpression<builtin::BuiltinValue>. If the sem::Expression is not a
+ /// sem::BuiltinEnumExpression<builtin::BuiltinValue>, then an error diagnostic is raised and
/// nullptr is returned.
+ sem::BuiltinEnumExpression<builtin::BuiltinValue>* BuiltinValueExpression(
+ const ast::Expression* expr);
+
+ /// @returns the call of Expression() cast to a sem::BuiltinEnumExpression<type::TexelFormat>.
+ /// If the sem::Expression is not a sem::BuiltinEnumExpression<type::TexelFormat>, then an error
+ /// diagnostic is raised and nullptr is returned.
sem::BuiltinEnumExpression<builtin::TexelFormat>* TexelFormatExpression(
const ast::Expression* expr);
@@ -290,6 +296,14 @@
/// current_function_
bool WorkgroupSize(const ast::Function*);
+ /// Resolves the attribute @p attr
+ /// @returns true on success, false on failure
+ bool Attribute(const ast::Attribute* attr);
+
+ /// Resolves the `@builtin` attribute @p attr
+ /// @returns true on success, false on failure
+ bool BuiltinAttribute(const ast::BuiltinAttribute* attr);
+
/// @param control the diagnostic control
/// @returns true on success, false on failure
bool DiagnosticControl(const ast::DiagnosticControl& control);
diff --git a/src/tint/resolver/resolver_test.cc b/src/tint/resolver/resolver_test.cc
index 87bb8d0..0915866 100644
--- a/src/tint/resolver/resolver_test.cc
+++ b/src/tint/resolver/resolver_test.cc
@@ -34,6 +34,7 @@
#include "src/tint/ast/unary_op_expression.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/ast/workgroup_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/function.h"
diff --git a/src/tint/resolver/sem_helper.cc b/src/tint/resolver/sem_helper.cc
index 3379ad2..b8c328c 100644
--- a/src/tint/resolver/sem_helper.cc
+++ b/src/tint/resolver/sem_helper.cc
@@ -84,6 +84,11 @@
std::string(wanted),
addr->Declaration()->source);
},
+ [&](const sem::BuiltinEnumExpression<builtin::BuiltinValue>* builtin) {
+ AddError("cannot use builtin value '" + utils::ToString(builtin->Value()) + "' as " +
+ std::string(wanted),
+ builtin->Declaration()->source);
+ },
[&](const sem::BuiltinEnumExpression<builtin::TexelFormat>* fmt) {
AddError("cannot use texel format '" + utils::ToString(fmt->Value()) + "' as " +
std::string(wanted),
diff --git a/src/tint/resolver/sem_helper.h b/src/tint/resolver/sem_helper.h
index e8940d1..a7c37b1 100644
--- a/src/tint/resolver/sem_helper.h
+++ b/src/tint/resolver/sem_helper.h
@@ -17,6 +17,7 @@
#include <string>
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/diagnostic/diagnostic.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/dependency_graph.h"
@@ -120,8 +121,23 @@
/// @param expr the semantic node
/// @returns nullptr if @p expr is nullptr, or @p expr cast to
- /// sem::BuiltinEnumExpression<builtin::TexelFormat> if the cast is successful, otherwise an
+ /// sem::BuiltinEnumExpression<builtin::BuiltinValue> if the cast is successful, otherwise an
/// error diagnostic is raised.
+ sem::BuiltinEnumExpression<builtin::BuiltinValue>* AsBuiltinValue(sem::Expression* expr) const {
+ if (TINT_LIKELY(expr)) {
+ auto* enum_expr = expr->As<sem::BuiltinEnumExpression<builtin::BuiltinValue>>();
+ if (TINT_LIKELY(enum_expr)) {
+ return enum_expr;
+ }
+ ErrorUnexpectedExprKind(expr, "builtin value");
+ }
+ return nullptr;
+ }
+
+ /// @param expr the semantic node
+ /// @returns nullptr if @p expr is nullptr, or @p expr cast to
+ /// sem::BuiltinEnumExpression<type::TexelFormat> if the cast is successful, otherwise an error
+ /// diagnostic is raised.
sem::BuiltinEnumExpression<builtin::TexelFormat>* AsTexelFormat(sem::Expression* expr) const {
if (TINT_LIKELY(expr)) {
auto* enum_expr = expr->As<sem::BuiltinEnumExpression<builtin::TexelFormat>>();
diff --git a/src/tint/resolver/struct_pipeline_stage_use_test.cc b/src/tint/resolver/struct_pipeline_stage_use_test.cc
index 90e9505..4707650 100644
--- a/src/tint/resolver/struct_pipeline_stage_use_test.cc
+++ b/src/tint/resolver/struct_pipeline_stage_use_test.cc
@@ -16,6 +16,7 @@
#include "gmock/gmock.h"
#include "src/tint/ast/stage_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/struct.h"
diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc
index 549c0cc..d02be8d 100644
--- a/src/tint/resolver/uniformity.cc
+++ b/src/tint/resolver/uniformity.cc
@@ -20,6 +20,7 @@
#include <utility>
#include <vector>
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/dependency_graph.h"
#include "src/tint/scope_stack.h"
@@ -1145,11 +1146,12 @@
const ast::IdentifierExpression* ident,
bool load_rule = false) {
// Helper to check if the entry point attribute of `obj` indicates non-uniformity.
- auto has_nonuniform_entry_point_attribute = [](auto* obj) {
+ auto has_nonuniform_entry_point_attribute = [&](auto* obj) {
// Only the num_workgroups and workgroup_id builtins are uniform.
- if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(obj->attributes)) {
- if (builtin->builtin == builtin::BuiltinValue::kNumWorkgroups ||
- builtin->builtin == builtin::BuiltinValue::kWorkgroupId) {
+ if (auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(obj->attributes)) {
+ auto builtin = builder_->Sem().Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kNumWorkgroups ||
+ builtin == builtin::BuiltinValue::kWorkgroupId) {
return false;
}
}
diff --git a/src/tint/resolver/validation_test.cc b/src/tint/resolver/validation_test.cc
index 0e239dd..1e806d3 100644
--- a/src/tint/resolver/validation_test.cc
+++ b/src/tint/resolver/validation_test.cc
@@ -30,6 +30,7 @@
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h"
#include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/resolver/resolver_test_helper.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/function.h"
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index ebb8284..5e64d98 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -114,15 +114,11 @@
}
// Helper to stringify a pipeline IO attribute.
-std::string attr_to_str(const ast::Attribute* attr,
- std::optional<uint32_t> location = std::nullopt) {
- std::stringstream str;
- if (auto* builtin = attr->As<ast::BuiltinAttribute>()) {
- str << "builtin(" << builtin->builtin << ")";
- } else if (attr->Is<ast::LocationAttribute>()) {
- str << "location(" << location.value() << ")";
- }
- return str.str();
+std::string AttrToStr(const ast::Attribute* attr) {
+ return Switch(
+ attr, //
+ [&](const ast::BuiltinAttribute*) { return "@builtin"; },
+ [&](const ast::LocationAttribute*) { return "@location"; });
}
template <typename CALLBACK>
@@ -868,7 +864,8 @@
stage_name << stage;
bool is_stage_mismatch = false;
bool is_output = !is_input;
- switch (attr->builtin) {
+ auto builtin = sem_.Get(attr)->Value();
+ switch (builtin) {
case builtin::BuiltinValue::kPosition:
if (stage != ast::PipelineStage::kNone &&
!((is_input && stage == ast::PipelineStage::kFragment) ||
@@ -876,8 +873,9 @@
is_stage_mismatch = true;
}
if (!(type->is_float_vector() && type->As<type::Vector>()->Width() == 4)) {
- AddError("store type of " + attr_to_str(attr) + " must be 'vec4<f32>'",
- attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'vec4<f32>'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -890,8 +888,9 @@
is_stage_mismatch = true;
}
if (!(type->is_unsigned_integer_vector() && type->As<type::Vector>()->Width() == 3)) {
- AddError("store type of " + attr_to_str(attr) + " must be 'vec3<u32>'",
- attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'vec3<u32>'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -901,7 +900,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::F32>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'f32'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'f32'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -911,7 +912,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::Bool>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'bool'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'bool'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -921,7 +924,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::U32>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'u32'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'u32'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -932,7 +937,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::U32>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'u32'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'u32'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -941,7 +948,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::U32>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'u32'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'u32'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -951,7 +960,9 @@
is_stage_mismatch = true;
}
if (!type->Is<type::U32>()) {
- AddError("store type of " + attr_to_str(attr) + " must be 'u32'", attr->source);
+ std::stringstream err;
+ err << "store type of @builtin(" << builtin << ") must be 'u32'";
+ AddError(err.str(), attr->source);
return false;
}
break;
@@ -960,9 +971,10 @@
}
if (is_stage_mismatch) {
- AddError(attr_to_str(attr) + " cannot be used in " +
- (is_input ? "input of " : "output of ") + stage_name.str() + " pipeline stage",
- attr->source);
+ std::stringstream err;
+ err << "@builtin(" << builtin << ") cannot be used in "
+ << (is_input ? "input of " : "output of ") << stage_name.str() << " pipeline stage";
+ AddError(err.str(), attr->source);
return false;
}
@@ -1098,32 +1110,34 @@
for (auto* attr : attrs) {
auto is_invalid_compute_shader_attribute = false;
- if (auto* builtin = attr->As<ast::BuiltinAttribute>()) {
+ if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
+ auto builtin = sem_.Get(builtin_attr)->Value();
+
if (pipeline_io_attribute) {
AddError("multiple entry point IO attributes", attr->source);
- AddNote("previously consumed " + attr_to_str(pipeline_io_attribute, location),
+ AddNote("previously consumed " + AttrToStr(pipeline_io_attribute),
pipeline_io_attribute->source);
return false;
}
pipeline_io_attribute = attr;
- if (builtins.Contains(builtin->builtin)) {
- AddError(attr_to_str(builtin) +
- " attribute appears multiple times as pipeline " +
- (param_or_ret == ParamOrRetType::kParameter ? "input" : "output"),
- decl->source);
+ if (builtins.Contains(builtin)) {
+ std::stringstream err;
+ err << "@builtin(" << builtin << ") appears multiple times as pipeline "
+ << (param_or_ret == ParamOrRetType::kParameter ? "input" : "output");
+ AddError(err.str(), decl->source);
return false;
}
- if (!BuiltinAttribute(builtin, ty, stage,
+ if (!BuiltinAttribute(builtin_attr, ty, stage,
/* is_input */ param_or_ret == ParamOrRetType::kParameter)) {
return false;
}
- builtins.Add(builtin->builtin);
+ builtins.Add(builtin);
} else if (auto* loc_attr = attr->As<ast::LocationAttribute>()) {
if (pipeline_io_attribute) {
AddError("multiple entry point IO attributes", attr->source);
- AddNote("previously consumed " + attr_to_str(pipeline_io_attribute),
+ AddNote("previously consumed " + AttrToStr(pipeline_io_attribute),
pipeline_io_attribute->source);
return false;
}
@@ -1183,16 +1197,16 @@
if (decl->PipelineStage() == ast::PipelineStage::kVertex &&
param_or_ret == ParamOrRetType::kReturnType) {
AddError(
- "integral user-defined vertex outputs must have a flat "
- "interpolation attribute",
+ "integral user-defined vertex outputs must have a flat interpolation "
+ "attribute",
source);
return false;
}
if (decl->PipelineStage() == ast::PipelineStage::kFragment &&
param_or_ret == ParamOrRetType::kParameter) {
AddError(
- "integral user-defined fragment inputs must have a flat "
- "interpolation attribute",
+ "integral user-defined fragment inputs must have a flat interpolation "
+ "attribute",
source);
return false;
}
@@ -1211,15 +1225,14 @@
if (invariant_attribute) {
bool has_position = false;
if (pipeline_io_attribute) {
- if (auto* builtin = pipeline_io_attribute->As<ast::BuiltinAttribute>()) {
- has_position = (builtin->builtin == builtin::BuiltinValue::kPosition);
+ if (auto* builtin_attr = pipeline_io_attribute->As<ast::BuiltinAttribute>()) {
+ auto builtin = sem_.Get(builtin_attr)->Value();
+ has_position = (builtin == builtin::BuiltinValue::kPosition);
}
}
if (!has_position) {
- AddError(
- "invariant attribute must only be applied to a position "
- "builtin",
- invariant_attribute->source);
+ AddError("invariant attribute must only be applied to a position builtin",
+ invariant_attribute->source);
return false;
}
}
@@ -1280,9 +1293,10 @@
// Check module-scope variables, as the SPIR-V sanitizer generates these.
bool found = false;
for (auto* global : func->TransitivelyReferencedGlobals()) {
- if (auto* builtin =
+ if (auto* builtin_attr =
ast::GetAttribute<ast::BuiltinAttribute>(global->Declaration()->attributes)) {
- if (builtin->builtin == builtin::BuiltinValue::kPosition) {
+ auto builtin = sem_.Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kPosition) {
found = true;
break;
}
@@ -2120,12 +2134,13 @@
}
return true;
},
- [&](const ast::BuiltinAttribute* builtin) {
- if (!BuiltinAttribute(builtin, member->Type(), stage,
+ [&](const ast::BuiltinAttribute* builtin_attr) {
+ if (!BuiltinAttribute(builtin_attr, member->Type(), stage,
/* is_input */ false)) {
return false;
}
- if (builtin->builtin == builtin::BuiltinValue::kPosition) {
+ auto builtin = sem_.Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kPosition) {
has_position = true;
}
return true;
@@ -2208,18 +2223,18 @@
if (!type->is_numeric_scalar_or_vector()) {
std::string invalid_type = sem_.TypeNameOf(type);
- AddError("cannot apply 'location' attribute to declaration of type '" + invalid_type + "'",
- source);
+ AddError("cannot apply @location to declaration of type '" + invalid_type + "'", source);
AddNote(
- "'location' attribute must only be applied to declarations of numeric scalar or "
- "numeric vector type",
+ "@location must only be applied to declarations of numeric scalar or numeric vector "
+ "type",
loc_attr->source);
return false;
}
if (!locations.Add(location)) {
- AddError(attr_to_str(loc_attr, location) + " attribute appears multiple times",
- loc_attr->source);
+ std::stringstream err;
+ err << "@location(" << location << ") appears multiple times";
+ AddError(err.str(), loc_attr->source);
return false;
}
diff --git a/src/tint/sem/type_mappings.h b/src/tint/sem/type_mappings.h
index fa7d8c6..efcd3a6 100644
--- a/src/tint/sem/type_mappings.h
+++ b/src/tint/sem/type_mappings.h
@@ -17,6 +17,8 @@
#include <type_traits>
+#include "src/tint/sem/builtin_enum_expression.h"
+
// Forward declarations
namespace tint {
class CastableBase;
@@ -25,6 +27,7 @@
class AccessorExpression;
class BinaryExpression;
class BitcastExpression;
+class BuiltinAttribute;
class CallExpression;
class Expression;
class ForLoopStatement;
@@ -43,6 +46,9 @@
class WhileStatement;
class UnaryOpExpression;
} // namespace tint::ast
+namespace tint::builtin {
+enum class BuiltinValue;
+}
namespace tint::sem {
class Expression;
class ForLoopStatement;
@@ -71,21 +77,22 @@
/// rules will be used to infer the return type based on the argument type.
struct TypeMappings {
//! @cond Doxygen_Suppress
+ BuiltinEnumExpression<builtin::BuiltinValue>* operator()(ast::BuiltinAttribute*);
+ CastableBase* operator()(ast::Node*);
+ Expression* operator()(ast::Expression*);
ForLoopStatement* operator()(ast::ForLoopStatement*);
Function* operator()(ast::Function*);
- IfStatement* operator()(ast::IfStatement*);
- CastableBase* operator()(ast::Node*);
GlobalVariable* operator()(ast::Override*);
+ IfStatement* operator()(ast::IfStatement*);
Statement* operator()(ast::Statement*);
Struct* operator()(ast::Struct*);
StructMember* operator()(ast::StructMember*);
SwitchStatement* operator()(ast::SwitchStatement*);
type::Type* operator()(ast::TypeDecl*);
- Expression* operator()(ast::Expression*);
ValueExpression* operator()(ast::AccessorExpression*);
- ValueExpression* operator()(ast::CallExpression*);
ValueExpression* operator()(ast::BinaryExpression*);
ValueExpression* operator()(ast::BitcastExpression*);
+ ValueExpression* operator()(ast::CallExpression*);
ValueExpression* operator()(ast::LiteralExpression*);
ValueExpression* operator()(ast::PhonyExpression*);
ValueExpression* operator()(ast::UnaryOpExpression*);
diff --git a/src/tint/transform/canonicalize_entry_point_io.cc b/src/tint/transform/canonicalize_entry_point_io.cc
index 80b51dc..3c9c6d0 100644
--- a/src/tint/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/transform/canonicalize_entry_point_io.cc
@@ -21,6 +21,7 @@
#include <vector>
#include "src/tint/ast/disable_validation_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/function.h"
#include "src/tint/transform/unshadow.h"
@@ -81,46 +82,12 @@
return 0;
}
-/// Comparison function used to reorder struct members such that all members with
-/// location attributes appear first (ordered by location slot), followed by
-/// those with builtin attributes.
-/// @param a a struct member
-/// @param b another struct member
-/// @returns true if a comes before b
-bool StructMemberComparator(const MemberInfo& a, const MemberInfo& b) {
- auto* a_loc = ast::GetAttribute<ast::LocationAttribute>(a.member->attributes);
- auto* b_loc = ast::GetAttribute<ast::LocationAttribute>(b.member->attributes);
- auto* a_blt = ast::GetAttribute<ast::BuiltinAttribute>(a.member->attributes);
- auto* b_blt = ast::GetAttribute<ast::BuiltinAttribute>(b.member->attributes);
- if (a_loc) {
- if (!b_loc) {
- // `a` has location attribute and `b` does not: `a` goes first.
- return true;
- }
- // Both have location attributes: smallest goes first.
- return a.location < b.location;
- } else {
- if (b_loc) {
- // `b` has location attribute and `a` does not: `b` goes first.
- return false;
- }
- // Both are builtins: order matters for FXC.
- return BuiltinOrder(a_blt->builtin) < BuiltinOrder(b_blt->builtin);
- }
-}
-
// Returns true if `attr` is a shader IO attribute.
bool IsShaderIOAttribute(const ast::Attribute* attr) {
return attr->IsAnyOf<ast::BuiltinAttribute, ast::InterpolateAttribute, ast::InvariantAttribute,
ast::LocationAttribute>();
}
-// Returns true if `attrs` contains a `sample_mask` builtin.
-bool HasSampleMask(utils::VectorRef<const ast::Attribute*> attrs) {
- auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attrs);
- return builtin && builtin->builtin == builtin::BuiltinValue::kSampleMask;
-}
-
} // namespace
/// PIMPL state for the transform
@@ -132,7 +99,7 @@
/// The type of the output value.
ast::Type type;
/// The shader IO attributes.
- utils::Vector<const ast::Attribute*, 2> attributes;
+ utils::Vector<const ast::Attribute*, 8> attributes;
/// The value itself.
const ast::Expression* value;
/// The output location.
@@ -165,6 +132,8 @@
utils::Vector<const ast::Statement*, 8> wrapper_body;
/// Input names used by the entrypoint
std::unordered_set<std::string> input_names;
+ /// A map of cloned attribute to builtin value
+ utils::Hashmap<const ast::BuiltinAttribute*, builtin::BuiltinValue, 16> builtin_attrs;
/// Constructor
/// @param context the clone context
@@ -175,20 +144,64 @@
const ast::Function* function)
: ctx(context), cfg(config), func_ast(function), func_sem(ctx.src->Sem().Get(function)) {}
- /// Clones the shader IO attributes from `src`.
- /// @param src the attributes to clone
+ /// Clones the attributes from @p in and adds it to @p out. If @p in is a builtin attribute,
+ /// then builtin_attrs is updated with the builtin information.
+ /// @param in the attribute to clone
+ /// @param out the output Attributes
+ template <size_t N>
+ void CloneAttribute(const ast::Attribute* in, utils::Vector<const ast::Attribute*, N>& out) {
+ auto* cloned = ctx.Clone(in);
+ out.Push(cloned);
+ if (auto* builtin = in->As<ast::BuiltinAttribute>()) {
+ builtin_attrs.Add(cloned->As<ast::BuiltinAttribute>(),
+ ctx.src->Sem().Get(builtin)->Value());
+ }
+ }
+
+ /// Clones the shader IO attributes from @p in.
+ /// @param in the attributes to clone
/// @param do_interpolate whether to clone InterpolateAttribute
/// @return the cloned attributes
template <size_t N>
- auto CloneShaderIOAttributes(utils::Vector<const ast::Attribute*, N> src, bool do_interpolate) {
- utils::Vector<const ast::Attribute*, N> new_attributes;
- for (auto* attr : src) {
+ auto CloneShaderIOAttributes(const utils::Vector<const ast::Attribute*, N> in,
+ bool do_interpolate) {
+ utils::Vector<const ast::Attribute*, N> out;
+ for (auto* attr : in) {
if (IsShaderIOAttribute(attr) &&
(do_interpolate || !attr->template Is<ast::InterpolateAttribute>())) {
- new_attributes.Push(ctx.Clone(attr));
+ CloneAttribute(attr, out);
}
}
- return new_attributes;
+ return out;
+ }
+
+ /// @param attr the input attribute
+ /// @returns the builtin value of the attribute
+ builtin::BuiltinValue BuiltinOf(const ast::BuiltinAttribute* attr) {
+ if (attr->program_id == ctx.dst->ID()) {
+ // attr belongs to the target program.
+ // Obtain the builtin value from #builtin_attrs.
+ if (auto b = builtin_attrs.Get(attr)) {
+ return *b;
+ }
+ } else {
+ // attr belongs to the source program.
+ // Obtain the builtin value from the semantic info.
+ return ctx.src->Sem().Get(attr)->Value();
+ }
+ TINT_ICE(Resolver, ctx.dst->Diagnostics())
+ << "could not obtain builtin value from attribute";
+ return builtin::BuiltinValue::kUndefined;
+ }
+
+ /// @param attrs the input attribute list
+ /// @returns the builtin value if any of the attributes in @p attrs is a builtin attribute,
+ /// otherwise builtin::BuiltinValue::kUndefined
+ builtin::BuiltinValue BuiltinOf(utils::VectorRef<const ast::Attribute*> attrs) {
+ if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attrs)) {
+ return BuiltinOf(builtin);
+ }
+ return builtin::BuiltinValue::kUndefined;
}
/// Create or return a symbol for the wrapper function's struct parameter.
@@ -204,13 +217,16 @@
/// @param name the name of the shader input
/// @param type the type of the shader input
/// @param location the location if provided
- /// @param attributes the attributes to apply to the shader input
+ /// @param attrs the attributes to apply to the shader input
/// @returns an expression which evaluates to the value of the shader input
const ast::Expression* AddInput(std::string name,
const type::Type* type,
std::optional<uint32_t> location,
- utils::Vector<const ast::Attribute*, 8> attributes) {
+ utils::Vector<const ast::Attribute*, 8> attrs) {
auto ast_type = CreateASTTypeFor(ctx, type);
+
+ auto builtin_attr = BuiltinOf(attrs);
+
if (cfg.shader_style == ShaderStyle::kSpirv || cfg.shader_style == ShaderStyle::kGlsl) {
// Vulkan requires that integer user-defined fragment inputs are always decorated with
// `Flat`. See:
@@ -219,21 +235,21 @@
// required for integers.
if (func_ast->PipelineStage() == ast::PipelineStage::kFragment &&
type->is_integer_scalar_or_vector() &&
- !ast::HasAttribute<ast::InterpolateAttribute>(attributes) &&
- (ast::HasAttribute<ast::LocationAttribute>(attributes) ||
+ !ast::HasAttribute<ast::InterpolateAttribute>(attrs) &&
+ (ast::HasAttribute<ast::LocationAttribute>(attrs) ||
cfg.shader_style == ShaderStyle::kSpirv)) {
- attributes.Push(ctx.dst->Interpolate(builtin::InterpolationType::kFlat,
- builtin::InterpolationSampling::kUndefined));
+ attrs.Push(ctx.dst->Interpolate(builtin::InterpolationType::kFlat,
+ builtin::InterpolationSampling::kUndefined));
}
// Disable validation for use of the `input` address space.
- attributes.Push(ctx.dst->Disable(ast::DisabledValidation::kIgnoreAddressSpace));
+ attrs.Push(ctx.dst->Disable(ast::DisabledValidation::kIgnoreAddressSpace));
// In GLSL, if it's a builtin, override the name with the
// corresponding gl_ builtin name
- auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attributes);
- if (cfg.shader_style == ShaderStyle::kGlsl && builtin) {
- name = GLSLBuiltinToString(builtin->builtin, func_ast->PipelineStage(),
+ if (cfg.shader_style == ShaderStyle::kGlsl &&
+ builtin_attr != builtin::BuiltinValue::kUndefined) {
+ name = GLSLBuiltinToString(builtin_attr, func_ast->PipelineStage(),
builtin::AddressSpace::kIn);
}
auto symbol = ctx.dst->Symbols().New(name);
@@ -241,32 +257,32 @@
// Create the global variable and use its value for the shader input.
const ast::Expression* value = ctx.dst->Expr(symbol);
- if (builtin) {
+ if (builtin_attr != builtin::BuiltinValue::kUndefined) {
if (cfg.shader_style == ShaderStyle::kGlsl) {
- value = FromGLSLBuiltin(builtin->builtin, value, ast_type);
- } else if (builtin->builtin == builtin::BuiltinValue::kSampleMask) {
+ value = FromGLSLBuiltin(builtin_attr, value, ast_type);
+ } else if (builtin_attr == builtin::BuiltinValue::kSampleMask) {
// Vulkan requires the type of a SampleMask builtin to be an array.
// Declare it as array<u32, 1> and then load the first element.
ast_type = ctx.dst->ty.array(ast_type, 1_u);
value = ctx.dst->IndexAccessor(value, 0_i);
}
}
- ctx.dst->GlobalVar(symbol, ast_type, builtin::AddressSpace::kIn, std::move(attributes));
+ ctx.dst->GlobalVar(symbol, ast_type, builtin::AddressSpace::kIn, std::move(attrs));
return value;
} else if (cfg.shader_style == ShaderStyle::kMsl &&
- ast::HasAttribute<ast::BuiltinAttribute>(attributes)) {
+ builtin_attr != builtin::BuiltinValue::kUndefined) {
// If this input is a builtin and we are targeting MSL, then add it to the
// parameter list and pass it directly to the inner function.
Symbol symbol = input_names.emplace(name).second ? ctx.dst->Symbols().Register(name)
: ctx.dst->Symbols().New(name);
- wrapper_ep_parameters.Push(ctx.dst->Param(symbol, ast_type, std::move(attributes)));
+ wrapper_ep_parameters.Push(ctx.dst->Param(symbol, ast_type, std::move(attrs)));
return ctx.dst->Expr(symbol);
} else {
// Otherwise, move it to the new structure member list.
Symbol symbol = input_names.emplace(name).second ? ctx.dst->Symbols().Register(name)
: ctx.dst->Symbols().New(name);
wrapper_struct_param_members.Push(
- {ctx.dst->Member(symbol, ast_type, std::move(attributes)), location});
+ {ctx.dst->Member(symbol, ast_type, std::move(attrs)), location});
return ctx.dst->MemberAccessor(InputStructSymbol(), symbol);
}
}
@@ -275,13 +291,14 @@
/// @param name the name of the shader output
/// @param type the type of the shader output
/// @param location the location if provided
- /// @param attributes the attributes to apply to the shader output
+ /// @param attrs the attributes to apply to the shader output
/// @param value the value of the shader output
void AddOutput(std::string name,
const type::Type* type,
std::optional<uint32_t> location,
- utils::Vector<const ast::Attribute*, 8> attributes,
+ utils::Vector<const ast::Attribute*, 8> attrs,
const ast::Expression* value) {
+ auto builtin_attr = BuiltinOf(attrs);
// Vulkan requires that integer user-defined vertex outputs are always decorated with
// `Flat`.
// TODO(crbug.com/tint/1224): Remove this once a flat interpolation attribute is required
@@ -289,26 +306,26 @@
if (cfg.shader_style == ShaderStyle::kSpirv &&
func_ast->PipelineStage() == ast::PipelineStage::kVertex &&
type->is_integer_scalar_or_vector() &&
- ast::HasAttribute<ast::LocationAttribute>(attributes) &&
- !ast::HasAttribute<ast::InterpolateAttribute>(attributes)) {
- attributes.Push(ctx.dst->Interpolate(builtin::InterpolationType::kFlat,
- builtin::InterpolationSampling::kUndefined));
+ ast::HasAttribute<ast::LocationAttribute>(attrs) &&
+ !ast::HasAttribute<ast::InterpolateAttribute>(attrs)) {
+ attrs.Push(ctx.dst->Interpolate(builtin::InterpolationType::kFlat,
+ builtin::InterpolationSampling::kUndefined));
}
// In GLSL, if it's a builtin, override the name with the
// corresponding gl_ builtin name
if (cfg.shader_style == ShaderStyle::kGlsl) {
- if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(attributes)) {
- name = GLSLBuiltinToString(b->builtin, func_ast->PipelineStage(),
+ if (builtin_attr != builtin::BuiltinValue::kUndefined) {
+ name = GLSLBuiltinToString(builtin_attr, func_ast->PipelineStage(),
builtin::AddressSpace::kOut);
- value = ToGLSLBuiltin(b->builtin, value, type);
+ value = ToGLSLBuiltin(builtin_attr, value, type);
}
}
OutputValue output;
output.name = name;
output.type = CreateASTTypeFor(ctx, type);
- output.attributes = std::move(attributes);
+ output.attributes = std::move(attrs);
output.value = value;
output.location = location;
wrapper_output_values.Push(output);
@@ -322,14 +339,14 @@
void ProcessNonStructParameter(const sem::Parameter* param) {
// Do not add interpolation attributes on vertex input
bool do_interpolate = func_ast->PipelineStage() != ast::PipelineStage::kVertex;
- // Remove the shader IO attributes from the inner function parameter, and
- // attach them to the new object instead.
+ // Remove the shader IO attributes from the inner function parameter, and attach them to the
+ // new object instead.
utils::Vector<const ast::Attribute*, 8> attributes;
for (auto* attr : param->Declaration()->attributes) {
if (IsShaderIOAttribute(attr)) {
ctx.Remove(param->Declaration()->attributes, attr);
if ((do_interpolate || !attr->Is<ast::InterpolateAttribute>())) {
- attributes.Push(ctx.Clone(attr));
+ CloneAttribute(attr, attributes);
}
}
}
@@ -412,25 +429,28 @@
void AddFixedSampleMask() {
// Check the existing output values for a sample mask builtin.
for (auto& outval : wrapper_output_values) {
- if (HasSampleMask(outval.attributes)) {
+ if (BuiltinOf(outval.attributes) == builtin::BuiltinValue::kSampleMask) {
// Combine the authored sample mask with the fixed mask.
outval.value = ctx.dst->And(outval.value, u32(cfg.fixed_sample_mask));
return;
}
}
- // No existing sample mask builtin was found, so create a new output value
- // using the fixed sample mask.
- AddOutput("fixed_sample_mask", ctx.dst->create<type::U32>(), std::nullopt,
- {ctx.dst->Builtin(builtin::BuiltinValue::kSampleMask)},
+ // No existing sample mask builtin was found, so create a new output value using the fixed
+ // sample mask.
+ auto* builtin = ctx.dst->Builtin(builtin::BuiltinValue::kSampleMask);
+ builtin_attrs.Add(builtin, builtin::BuiltinValue::kSampleMask);
+ AddOutput("fixed_sample_mask", ctx.dst->create<type::U32>(), std::nullopt, {builtin},
ctx.dst->Expr(u32(cfg.fixed_sample_mask)));
}
/// Add a point size builtin to the wrapper function output.
void AddVertexPointSize() {
// Create a new output value and assign it a literal 1.0 value.
- AddOutput("vertex_point_size", ctx.dst->create<type::F32>(), std::nullopt,
- {ctx.dst->Builtin(builtin::BuiltinValue::kPointSize)}, ctx.dst->Expr(1_f));
+ auto* builtin = ctx.dst->Builtin(builtin::BuiltinValue::kPointSize);
+ builtin_attrs.Add(builtin, builtin::BuiltinValue::kPointSize);
+ AddOutput("vertex_point_size", ctx.dst->create<type::F32>(), std::nullopt, {builtin},
+ ctx.dst->Expr(1_f));
}
/// Create an expression for gl_Position.[component]
@@ -442,11 +462,40 @@
return ctx.dst->MemberAccessor(ctx.dst->Expr(pos), c);
}
+ /// Comparison function used to reorder struct members such that all members with
+ /// location attributes appear first (ordered by location slot), followed by
+ /// those with builtin attributes.
+ /// @param a a struct member
+ /// @param b another struct member
+ /// @returns true if a comes before b
+ bool StructMemberComparator(const MemberInfo& a, const MemberInfo& b) {
+ auto* a_loc = ast::GetAttribute<ast::LocationAttribute>(a.member->attributes);
+ auto* b_loc = ast::GetAttribute<ast::LocationAttribute>(b.member->attributes);
+ auto* a_blt = ast::GetAttribute<ast::BuiltinAttribute>(a.member->attributes);
+ auto* b_blt = ast::GetAttribute<ast::BuiltinAttribute>(b.member->attributes);
+ if (a_loc) {
+ if (!b_loc) {
+ // `a` has location attribute and `b` does not: `a` goes first.
+ return true;
+ }
+ // Both have location attributes: smallest goes first.
+ return a.location < b.location;
+ } else {
+ if (b_loc) {
+ // `b` has location attribute and `a` does not: `b` goes first.
+ return false;
+ }
+ // Both are builtins: order matters for FXC.
+ auto builtin_a = BuiltinOf(a_blt);
+ auto builtin_b = BuiltinOf(b_blt);
+ return BuiltinOrder(builtin_a) < BuiltinOrder(builtin_b);
+ }
+ }
/// Create the wrapper function's struct parameter and type objects.
void CreateInputStruct() {
// Sort the struct members to satisfy HLSL interfacing matching rules.
std::sort(wrapper_struct_param_members.begin(), wrapper_struct_param_members.end(),
- StructMemberComparator);
+ [&](auto& a, auto& b) { return StructMemberComparator(a, b); });
utils::Vector<const ast::StructMember*, 8> members;
for (auto& mem : wrapper_struct_param_members) {
@@ -483,16 +532,17 @@
}
member_names.insert(ctx.dst->Symbols().NameFor(name));
- wrapper_struct_output_members.Push(
- {ctx.dst->Member(name, outval.type, std::move(outval.attributes)),
- outval.location});
+ wrapper_struct_output_members.Push({
+ ctx.dst->Member(name, outval.type, std::move(outval.attributes)),
+ outval.location,
+ });
assignments.Push(
ctx.dst->Assign(ctx.dst->MemberAccessor(wrapper_result, name), outval.value));
}
// Sort the struct members to satisfy HLSL interfacing matching rules.
std::sort(wrapper_struct_output_members.begin(), wrapper_struct_output_members.end(),
- StructMemberComparator);
+ [&](auto& a, auto& b) { return StructMemberComparator(a, b); });
utils::Vector<const ast::StructMember*, 8> members;
for (auto& mem : wrapper_struct_output_members) {
@@ -519,14 +569,14 @@
void CreateGlobalOutputVariables() {
for (auto& outval : wrapper_output_values) {
// Disable validation for use of the `output` address space.
- utils::Vector<const ast::Attribute*, 8> attributes = std::move(outval.attributes);
+ auto attributes = std::move(outval.attributes);
attributes.Push(ctx.dst->Disable(ast::DisabledValidation::kIgnoreAddressSpace));
// Create the global variable and assign it the output value.
auto name = ctx.dst->Symbols().New(outval.name);
ast::Type type = outval.type;
const ast::Expression* lhs = ctx.dst->Expr(name);
- if (HasSampleMask(attributes)) {
+ if (BuiltinOf(attributes) == builtin::BuiltinValue::kSampleMask) {
// Vulkan requires the type of a SampleMask builtin to be an array.
// Declare it as array<u32, 1> and then store to the first element.
type = ctx.dst->ty.array(type, 1_u);
diff --git a/src/tint/transform/canonicalize_entry_point_io_test.cc b/src/tint/transform/canonicalize_entry_point_io_test.cc
index db6385e..08b8430 100644
--- a/src/tint/transform/canonicalize_entry_point_io_test.cc
+++ b/src/tint/transform/canonicalize_entry_point_io_test.cc
@@ -3163,7 +3163,7 @@
auto* expect = R"(
@builtin(position) @internal(disable_validation__ignore_address_space) var<__out> value : vec4<f32>;
-@builtin(point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
+@builtin(__point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
fn vert_main_inner() -> vec4<f32> {
return vec4<f32>();
@@ -3197,7 +3197,7 @@
struct tint_symbol {
@builtin(position)
value : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size : f32,
}
@@ -3238,7 +3238,7 @@
auto* expect = R"(
@builtin(position) @internal(disable_validation__ignore_address_space) var<__out> pos_1 : vec4<f32>;
-@builtin(point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
+@builtin(__point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
struct VertOut {
pos : vec4<f32>,
@@ -3279,7 +3279,7 @@
auto* expect = R"(
@builtin(position) @internal(disable_validation__ignore_address_space) var<__out> pos_1 : vec4<f32>;
-@builtin(point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
+@builtin(__point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size : f32;
fn vert_main_inner() -> VertOut {
return VertOut();
@@ -3325,7 +3325,7 @@
struct tint_symbol {
@builtin(position)
pos : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size : f32,
}
@@ -3367,7 +3367,7 @@
struct tint_symbol {
@builtin(position)
pos : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size : f32,
}
@@ -3432,7 +3432,7 @@
@builtin(position) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_1_1 : vec4<f32>;
-@builtin(point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_4 : f32;
+@builtin(__point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_4 : f32;
var<private> vertex_point_size : f32;
@@ -3510,7 +3510,7 @@
@builtin(position) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_1_1 : vec4<f32>;
-@builtin(point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_4 : f32;
+@builtin(__point_size) @internal(disable_validation__ignore_address_space) var<__out> vertex_point_size_4 : f32;
fn vert_main_inner(collide : VertIn1, collide_1 : VertIn2) -> VertOut {
let x = (collide.collide + collide_1.collide);
@@ -3601,7 +3601,7 @@
vertex_point_size : vec4<f32>,
@builtin(position)
vertex_point_size_1 : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size_2 : f32,
}
@@ -3664,7 +3664,7 @@
vertex_point_size : vec4<f32>,
@builtin(position)
vertex_point_size_1 : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size_2 : f32,
}
@@ -3753,7 +3753,7 @@
vertex_point_size : vec4<f32>,
@builtin(position)
vertex_point_size_1 : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size_2 : f32,
}
@@ -3816,7 +3816,7 @@
vertex_point_size : vec4<f32>,
@builtin(position)
vertex_point_size_1 : vec4<f32>,
- @builtin(point_size)
+ @builtin(__point_size)
vertex_point_size_2 : f32,
}
diff --git a/src/tint/transform/clamp_frag_depth.cc b/src/tint/transform/clamp_frag_depth.cc
index 951dc30..77d897d 100644
--- a/src/tint/transform/clamp_frag_depth.cc
+++ b/src/tint/transform/clamp_frag_depth.cc
@@ -33,178 +33,196 @@
namespace tint::transform {
-namespace {
+/// PIMPL state for the transform
+struct ClampFragDepth::State {
+ /// The source program
+ const Program* const src;
+ /// The target program builder
+ ProgramBuilder b{};
+ /// The clone context
+ CloneContext ctx = {&b, src, /* auto_clone_symbols */ true};
+ /// The sem::Info of the program
+ const sem::Info& sem = src->Sem();
+ /// The symbols of the program
+ const SymbolTable& sym = src->Symbols();
-bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attributes) {
- for (auto* attribute : attributes) {
- if (auto* builtin_attribute = attribute->As<ast::BuiltinAttribute>()) {
- if (builtin_attribute->builtin == builtin::BuiltinValue::kFragDepth) {
+ /// Runs the transform
+ /// @returns the new program or SkipTransform if the transform is not required
+ Transform::ApplyResult Run() {
+ // Abort on any use of push constants in the module.
+ for (auto* global : src->AST().GlobalVariables()) {
+ if (auto* var = global->As<ast::Var>()) {
+ auto* v = src->Sem().Get(var);
+ if (TINT_UNLIKELY(v->AddressSpace() == builtin::AddressSpace::kPushConstant)) {
+ TINT_ICE(Transform, b.Diagnostics())
+ << "ClampFragDepth doesn't know how to handle module that already use push "
+ "constants";
+ return Program(std::move(b));
+ }
+ }
+ }
+
+ if (!ShouldRun()) {
+ return SkipTransform;
+ }
+
+ // At least one entry-point needs clamping. Add the following to the module:
+ //
+ // enable chromium_experimental_push_constant;
+ //
+ // struct FragDepthClampArgs {
+ // min : f32,
+ // max : f32,
+ // }
+ // var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
+ //
+ // fn clamp_frag_depth(v : f32) -> f32 {
+ // return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
+ // }
+ b.Enable(builtin::Extension::kChromiumExperimentalPushConstant);
+
+ b.Structure(b.Symbols().New("FragDepthClampArgs"),
+ utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
+
+ auto args_sym = b.Symbols().New("frag_depth_clamp_args");
+ b.GlobalVar(args_sym, b.ty("FragDepthClampArgs"), builtin::AddressSpace::kPushConstant);
+
+ auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
+ b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),
+ utils::Vector{b.Return(b.Call("clamp", "v", b.MemberAccessor(args_sym, "min"),
+ b.MemberAccessor(args_sym, "max")))});
+
+ // If true, the currently cloned function returns frag depth directly as a scalar
+ bool returns_frag_depth_as_value = false;
+
+ // If valid, the currently cloned function returns frag depth in a struct
+ // The symbol is the name of the helper function to apply the depth clamping.
+ Symbol returns_frag_depth_as_struct_helper;
+
+ // Map of io struct to helper function to return the structure with the depth clamping
+ // applied.
+ utils::Hashmap<const ast::Struct*, Symbol, 4u> io_structs_clamp_helpers;
+
+ // Register a callback that will be called for each visted AST function.
+ // This call wraps the cloning of the function's statements, and will assign to
+ // `returns_frag_depth_as_value` or `returns_frag_depth_as_struct_helper` if the function's
+ // return value requires depth clamping.
+ ctx.ReplaceAll([&](const ast::Function* fn) {
+ if (fn->PipelineStage() != ast::PipelineStage::kFragment) {
+ return ctx.CloneWithoutTransform(fn);
+ }
+
+ if (ReturnsFragDepthAsValue(fn)) {
+ TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_value, true);
+ return ctx.CloneWithoutTransform(fn);
+ }
+
+ if (ReturnsFragDepthInStruct(fn)) {
+ // At most once per I/O struct, add the conversion function:
+ //
+ // fn clamp_frag_depth_S(s : S) -> S {
+ // return S(s.first, s.second, clamp_frag_depth(s.frag_depth), s.last);
+ // }
+ auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()->Declaration();
+ auto helper = io_structs_clamp_helpers.GetOrCreate(struct_ty, [&] {
+ auto return_ty = fn->return_type;
+ auto fn_sym =
+ b.Symbols().New("clamp_frag_depth_" + sym.NameFor(struct_ty->name->symbol));
+
+ utils::Vector<const ast::Expression*, 8u> initializer_args;
+ for (auto* member : struct_ty->members) {
+ const ast::Expression* arg =
+ b.MemberAccessor("s", ctx.Clone(member->name->symbol));
+ if (ContainsFragDepth(member->attributes)) {
+ arg = b.Call(base_fn_sym, arg);
+ }
+ initializer_args.Push(arg);
+ }
+ utils::Vector params{b.Param("s", ctx.Clone(return_ty))};
+ utils::Vector body{
+ b.Return(b.Call(ctx.Clone(return_ty), std::move(initializer_args))),
+ };
+ b.Func(fn_sym, params, ctx.Clone(return_ty), body);
+ return fn_sym;
+ });
+
+ TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_struct_helper, helper);
+ return ctx.CloneWithoutTransform(fn);
+ }
+
+ return ctx.CloneWithoutTransform(fn);
+ });
+
+ // Replace the return statements `return expr` with `return clamp_frag_depth(expr)`.
+ ctx.ReplaceAll([&](const ast::ReturnStatement* stmt) -> const ast::ReturnStatement* {
+ if (returns_frag_depth_as_value) {
+ return b.Return(stmt->source, b.Call(base_fn_sym, ctx.Clone(stmt->value)));
+ }
+ if (returns_frag_depth_as_struct_helper.IsValid()) {
+ return b.Return(stmt->source, b.Call(returns_frag_depth_as_struct_helper,
+ ctx.Clone(stmt->value)));
+ }
+ return nullptr;
+ });
+
+ ctx.Clone();
+ return Program(std::move(b));
+ }
+
+ private:
+ /// @returns true if the transform should run
+ bool ShouldRun() {
+ for (auto* fn : src->AST().Functions()) {
+ if (fn->PipelineStage() == ast::PipelineStage::kFragment &&
+ (ReturnsFragDepthAsValue(fn) || ReturnsFragDepthInStruct(fn))) {
return true;
}
}
+
+ return false;
}
-
- return false;
-}
-
-bool ReturnsFragDepthAsValue(const ast::Function* fn) {
- return ContainsFragDepth(fn->return_type_attributes);
-}
-
-bool ReturnsFragDepthInStruct(const sem::Info& sem, const ast::Function* fn) {
- if (auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()) {
- for (auto* member : struct_ty->Members()) {
- if (ContainsFragDepth(member->Declaration()->attributes)) {
- return true;
+ /// @param attrs the attributes to examine
+ /// @returns true if @p attrs contains a `@builtin(frag_depth)` attribute
+ bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attrs) {
+ for (auto* attribute : attrs) {
+ if (auto* builtin_attr = attribute->As<ast::BuiltinAttribute>()) {
+ auto builtin = sem.Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kFragDepth) {
+ return true;
+ }
}
}
+
+ return false;
}
- return false;
-}
+ /// @param fn the function to examine
+ /// @returns true if @p fn has a return type with a `@builtin(frag_depth)` attribute
+ bool ReturnsFragDepthAsValue(const ast::Function* fn) {
+ return ContainsFragDepth(fn->return_type_attributes);
+ }
-bool ShouldRun(const Program* program) {
- auto& sem = program->Sem();
-
- for (auto* fn : program->AST().Functions()) {
- if (fn->PipelineStage() == ast::PipelineStage::kFragment &&
- (ReturnsFragDepthAsValue(fn) || ReturnsFragDepthInStruct(sem, fn))) {
- return true;
+ /// @param fn the function to examine
+ /// @returns true if @p fn has a return structure with a `@builtin(frag_depth)` attribute on one
+ /// of the members
+ bool ReturnsFragDepthInStruct(const ast::Function* fn) {
+ if (auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()) {
+ for (auto* member : struct_ty->Members()) {
+ if (ContainsFragDepth(member->Declaration()->attributes)) {
+ return true;
+ }
+ }
}
+
+ return false;
}
-
- return false;
-}
-
-} // anonymous namespace
+};
ClampFragDepth::ClampFragDepth() = default;
ClampFragDepth::~ClampFragDepth() = default;
Transform::ApplyResult ClampFragDepth::Apply(const Program* src, const DataMap&, DataMap&) const {
- ProgramBuilder b;
- CloneContext ctx{&b, src, /* auto_clone_symbols */ true};
-
- // Abort on any use of push constants in the module.
- for (auto* global : src->AST().GlobalVariables()) {
- if (auto* var = global->As<ast::Var>()) {
- auto* v = src->Sem().Get(var);
- if (TINT_UNLIKELY(v->AddressSpace() == builtin::AddressSpace::kPushConstant)) {
- TINT_ICE(Transform, b.Diagnostics())
- << "ClampFragDepth doesn't know how to handle module that already use push "
- "constants";
- return Program(std::move(b));
- }
- }
- }
-
- if (!ShouldRun(src)) {
- return SkipTransform;
- }
-
- auto& sem = src->Sem();
- auto& sym = src->Symbols();
-
- // At least one entry-point needs clamping. Add the following to the module:
- //
- // enable chromium_experimental_push_constant;
- //
- // struct FragDepthClampArgs {
- // min : f32,
- // max : f32,
- // }
- // var<push_constant> frag_depth_clamp_args : FragDepthClampArgs;
- //
- // fn clamp_frag_depth(v : f32) -> f32 {
- // return clamp(v, frag_depth_clamp_args.min, frag_depth_clamp_args.max);
- // }
- b.Enable(builtin::Extension::kChromiumExperimentalPushConstant);
-
- b.Structure(b.Symbols().New("FragDepthClampArgs"),
- utils::Vector{b.Member("min", b.ty.f32()), b.Member("max", b.ty.f32())});
-
- auto args_sym = b.Symbols().New("frag_depth_clamp_args");
- b.GlobalVar(args_sym, b.ty("FragDepthClampArgs"), builtin::AddressSpace::kPushConstant);
-
- auto base_fn_sym = b.Symbols().New("clamp_frag_depth");
- b.Func(base_fn_sym, utils::Vector{b.Param("v", b.ty.f32())}, b.ty.f32(),
- utils::Vector{b.Return(b.Call("clamp", "v", b.MemberAccessor(args_sym, "min"),
- b.MemberAccessor(args_sym, "max")))});
-
- // If true, the currently cloned function returns frag depth directly as a scalar
- bool returns_frag_depth_as_value = false;
-
- // If valid, the currently cloned function returns frag depth in a struct
- // The symbol is the name of the helper function to apply the depth clamping.
- Symbol returns_frag_depth_as_struct_helper;
-
- // Map of io struct to helper function to return the structure with the depth clamping applied.
- utils::Hashmap<const ast::Struct*, Symbol, 4u> io_structs_clamp_helpers;
-
- // Register a callback that will be called for each visted AST function.
- // This call wraps the cloning of the function's statements, and will assign to
- // `returns_frag_depth_as_value` or `returns_frag_depth_as_struct_helper` if the function's
- // return value requires depth clamping.
- ctx.ReplaceAll([&](const ast::Function* fn) {
- if (fn->PipelineStage() != ast::PipelineStage::kFragment) {
- return ctx.CloneWithoutTransform(fn);
- }
-
- if (ReturnsFragDepthAsValue(fn)) {
- TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_value, true);
- return ctx.CloneWithoutTransform(fn);
- }
-
- if (ReturnsFragDepthInStruct(sem, fn)) {
- // At most once per I/O struct, add the conversion function:
- //
- // fn clamp_frag_depth_S(s : S) -> S {
- // return S(s.first, s.second, clamp_frag_depth(s.frag_depth), s.last);
- // }
- auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()->Declaration();
- auto helper = io_structs_clamp_helpers.GetOrCreate(struct_ty, [&] {
- auto return_ty = fn->return_type;
- auto fn_sym =
- b.Symbols().New("clamp_frag_depth_" + sym.NameFor(struct_ty->name->symbol));
-
- utils::Vector<const ast::Expression*, 8u> initializer_args;
- for (auto* member : struct_ty->members) {
- const ast::Expression* arg =
- b.MemberAccessor("s", ctx.Clone(member->name->symbol));
- if (ContainsFragDepth(member->attributes)) {
- arg = b.Call(base_fn_sym, arg);
- }
- initializer_args.Push(arg);
- }
- utils::Vector params{b.Param("s", ctx.Clone(return_ty))};
- utils::Vector body{
- b.Return(b.Call(ctx.Clone(return_ty), std::move(initializer_args))),
- };
- b.Func(fn_sym, params, ctx.Clone(return_ty), body);
- return fn_sym;
- });
-
- TINT_SCOPED_ASSIGNMENT(returns_frag_depth_as_struct_helper, helper);
- return ctx.CloneWithoutTransform(fn);
- }
-
- return ctx.CloneWithoutTransform(fn);
- });
-
- // Replace the return statements `return expr` with `return clamp_frag_depth(expr)`.
- ctx.ReplaceAll([&](const ast::ReturnStatement* stmt) -> const ast::ReturnStatement* {
- if (returns_frag_depth_as_value) {
- return b.Return(stmt->source, b.Call(base_fn_sym, ctx.Clone(stmt->value)));
- }
- if (returns_frag_depth_as_struct_helper.IsValid()) {
- return b.Return(stmt->source,
- b.Call(returns_frag_depth_as_struct_helper, ctx.Clone(stmt->value)));
- }
- return nullptr;
- });
-
- ctx.Clone();
- return Program(std::move(b));
+ return State{src}.Run();
}
} // namespace tint::transform
diff --git a/src/tint/transform/clamp_frag_depth.h b/src/tint/transform/clamp_frag_depth.h
index 1e9d0d6..3e3f168 100644
--- a/src/tint/transform/clamp_frag_depth.h
+++ b/src/tint/transform/clamp_frag_depth.h
@@ -65,6 +65,9 @@
ApplyResult Apply(const Program* program,
const DataMap& inputs,
DataMap& outputs) const override;
+
+ private:
+ struct State;
};
} // namespace tint::transform
diff --git a/src/tint/transform/first_index_offset.cc b/src/tint/transform/first_index_offset.cc
index cac1299..59588e2 100644
--- a/src/tint/transform/first_index_offset.cc
+++ b/src/tint/transform/first_index_offset.cc
@@ -18,6 +18,7 @@
#include <unordered_map>
#include <utility>
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/member_accessor_expression.h"
@@ -88,7 +89,7 @@
if (auto* var = node->As<ast::Variable>()) {
for (auto* attr : var->attributes) {
if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
- builtin::BuiltinValue builtin = builtin_attr->builtin;
+ builtin::BuiltinValue builtin = src->Sem().Get(builtin_attr)->Value();
if (builtin == builtin::BuiltinValue::kVertexIndex) {
auto* sem_var = ctx.src->Sem().Get(var);
builtin_vars.emplace(sem_var, kFirstVertexName);
@@ -105,7 +106,7 @@
if (auto* member = node->As<ast::StructMember>()) {
for (auto* attr : member->attributes) {
if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
- builtin::BuiltinValue builtin = builtin_attr->builtin;
+ builtin::BuiltinValue builtin = src->Sem().Get(builtin_attr)->Value();
if (builtin == builtin::BuiltinValue::kVertexIndex) {
auto* sem_mem = ctx.src->Sem().Get(member);
builtin_members.emplace(sem_mem, kFirstVertexName);
diff --git a/src/tint/transform/num_workgroups_from_uniform.cc b/src/tint/transform/num_workgroups_from_uniform.cc
index a62cf42..e4bb05e 100644
--- a/src/tint/transform/num_workgroups_from_uniform.cc
+++ b/src/tint/transform/num_workgroups_from_uniform.cc
@@ -19,6 +19,7 @@
#include <unordered_set>
#include <utility>
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/function.h"
#include "src/tint/transform/canonicalize_entry_point_io.h"
@@ -33,7 +34,7 @@
bool ShouldRun(const Program* program) {
for (auto* node : program->ASTNodes().Objects()) {
if (auto* attr = node->As<ast::BuiltinAttribute>()) {
- if (attr->builtin == builtin::BuiltinValue::kNumWorkgroups) {
+ if (program->Sem().Get(attr)->Value() == builtin::BuiltinValue::kNumWorkgroups) {
return true;
}
}
@@ -100,7 +101,8 @@
for (auto* member : str->Members()) {
auto* builtin =
ast::GetAttribute<ast::BuiltinAttribute>(member->Declaration()->attributes);
- if (!builtin || builtin->builtin != builtin::BuiltinValue::kNumWorkgroups) {
+ if (!builtin ||
+ src->Sem().Get(builtin)->Value() != builtin::BuiltinValue::kNumWorkgroups) {
continue;
}
diff --git a/src/tint/transform/vertex_pulling.cc b/src/tint/transform/vertex_pulling.cc
index 9faddb7..ecc7576 100644
--- a/src/tint/transform/vertex_pulling.cc
+++ b/src/tint/transform/vertex_pulling.cc
@@ -20,6 +20,7 @@
#include "src/tint/ast/assignment_statement.h"
#include "src/tint/ast/bitcast_expression.h"
#include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/variable.h"
#include "src/tint/utils/compiler_macros.h"
@@ -773,17 +774,18 @@
}
location_info[sem->Location().value()] = info;
} else {
- auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes);
- if (TINT_UNLIKELY(!builtin)) {
+ auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes);
+ if (TINT_UNLIKELY(!builtin_attr)) {
TINT_ICE(Transform, b.Diagnostics()) << "Invalid entry point parameter";
return;
}
+ auto builtin = src->Sem().Get(builtin_attr)->Value();
// Check for existing vertex_index and instance_index builtins.
- if (builtin->builtin == builtin::BuiltinValue::kVertexIndex) {
+ if (builtin == builtin::BuiltinValue::kVertexIndex) {
vertex_index_expr = [this, param]() {
return b.Expr(ctx.Clone(param->name->symbol));
};
- } else if (builtin->builtin == builtin::BuiltinValue::kInstanceIndex) {
+ } else if (builtin == builtin::BuiltinValue::kInstanceIndex) {
instance_index_expr = [this, param]() {
return b.Expr(ctx.Clone(param->name->symbol));
};
@@ -826,15 +828,16 @@
location_info[sem->Location().value()] = info;
has_locations = true;
} else {
- auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(member->attributes);
- if (TINT_UNLIKELY(!builtin)) {
+ auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(member->attributes);
+ if (TINT_UNLIKELY(!builtin_attr)) {
TINT_ICE(Transform, b.Diagnostics()) << "Invalid entry point parameter";
return;
}
+ auto builtin = src->Sem().Get(builtin_attr)->Value();
// Check for existing vertex_index and instance_index builtins.
- if (builtin->builtin == builtin::BuiltinValue::kVertexIndex) {
+ if (builtin == builtin::BuiltinValue::kVertexIndex) {
vertex_index_expr = member_expr;
- } else if (builtin->builtin == builtin::BuiltinValue::kInstanceIndex) {
+ } else if (builtin == builtin::BuiltinValue::kInstanceIndex) {
instance_index_expr = member_expr;
}
members_to_clone.Push(member);
diff --git a/src/tint/transform/zero_init_workgroup_memory.cc b/src/tint/transform/zero_init_workgroup_memory.cc
index 2071abc..7dafc06 100644
--- a/src/tint/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/transform/zero_init_workgroup_memory.cc
@@ -21,6 +21,7 @@
#include <vector>
#include "src/tint/ast/workgroup_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/variable.h"
@@ -159,8 +160,9 @@
// parameter
std::function<const ast::Expression*()> local_index;
for (auto* param : fn->params) {
- if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes)) {
- if (builtin->builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
+ if (auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes)) {
+ auto builtin = sem.Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
local_index = [=] { return b.Expr(ctx.Clone(param->name->symbol)); };
break;
}
@@ -168,9 +170,10 @@
if (auto* str = sem.Get(param)->Type()->As<sem::Struct>()) {
for (auto* member : str->Members()) {
- if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(
+ if (auto* builtin_attr = ast::GetAttribute<ast::BuiltinAttribute>(
member->Declaration()->attributes)) {
- if (builtin->builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
+ auto builtin = sem.Get(builtin_attr)->Value();
+ if (builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
local_index = [=] {
auto* param_expr = b.Expr(ctx.Clone(param->name->symbol));
auto* member_name = ctx.Clone(member->Declaration()->name);
@@ -184,10 +187,9 @@
}
if (!local_index) {
// No existing local index parameter. Append one to the entry point.
- auto* param = b.Param(b.Symbols().New("local_invocation_index"), b.ty.u32(),
- utils::Vector{
- b.Builtin(builtin::BuiltinValue::kLocalInvocationIndex),
- });
+ auto param_name = b.Symbols().New("local_invocation_index");
+ auto* local_invocation_index = b.Builtin(builtin::BuiltinValue::kLocalInvocationIndex);
+ auto* param = b.Param(param_name, b.ty.u32(), utils::Vector{local_invocation_index});
ctx.InsertBack(fn->params, param);
local_index = [=] { return b.Expr(param->name->symbol); };
}
diff --git a/src/tint/utils/enum_set.h b/src/tint/utils/enum_set.h
index 19d1a82..9b75ba0 100644
--- a/src/tint/utils/enum_set.h
+++ b/src/tint/utils/enum_set.h
@@ -192,14 +192,14 @@
};
/// @returns an read-only iterator to the beginning of the set
- Iterator begin() {
+ Iterator begin() const {
auto it = Iterator{set, -1};
++it; // Move to first set bit
return it;
}
/// @returns an iterator to the beginning of the set
- Iterator end() { return Iterator{set, Iterator::kEnd}; }
+ Iterator end() const { return Iterator{set, Iterator::kEnd}; }
private:
static constexpr uint64_t Bit(Enum value) {
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index d89aaaf..773bcaf 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -2155,9 +2155,10 @@
bool GeneratorImpl::EmitIOVariable(const sem::GlobalVariable* var) {
auto* decl = var->Declaration();
- if (auto* b = ast::GetAttribute<ast::BuiltinAttribute>(decl->attributes)) {
+ if (auto* attr = ast::GetAttribute<ast::BuiltinAttribute>(decl->attributes)) {
+ auto builtin = program_->Sem().Get(attr)->Value();
// Use of gl_SampleID requires the GL_OES_sample_variables extension
- if (RequiresOESSampleVariables(b->builtin)) {
+ if (RequiresOESSampleVariables(builtin)) {
requires_oes_sample_variables_ = true;
}
// Do not emit builtin (gl_) variables.
diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h
index 629566d..260852e 100644
--- a/src/tint/writer/glsl/generator_impl.h
+++ b/src/tint/writer/glsl/generator_impl.h
@@ -32,6 +32,7 @@
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/scope_stack.h"
#include "src/tint/transform/decompose_memory_access.h"
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 2659a52..4c7c9ee 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -4210,8 +4210,9 @@
} else {
TINT_ICE(Writer, diagnostics_) << "invalid use of location attribute";
}
- } else if (auto* builtin = attr->As<ast::BuiltinAttribute>()) {
- auto name = builtin_to_attribute(builtin->builtin);
+ } else if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
+ auto builtin = program_->Sem().Get(builtin_attr)->Value();
+ auto name = builtin_to_attribute(builtin);
if (name.empty()) {
diagnostics_.add_error(diag::System::Writer, "unsupported builtin");
return false;
diff --git a/src/tint/writer/hlsl/generator_impl.h b/src/tint/writer/hlsl/generator_impl.h
index 1f272ef..abf1fcb 100644
--- a/src/tint/writer/hlsl/generator_impl.h
+++ b/src/tint/writer/hlsl/generator_impl.h
@@ -31,6 +31,7 @@
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/scope_stack.h"
#include "src/tint/sem/binding_point.h"
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 0f6b390..8723222 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -2077,14 +2077,15 @@
auto& attrs = param->attributes;
bool builtin_found = false;
for (auto* attr : attrs) {
- auto* builtin = attr->As<ast::BuiltinAttribute>();
- if (!builtin) {
+ auto* builtin_attr = attr->As<ast::BuiltinAttribute>();
+ if (!builtin_attr) {
continue;
}
+ auto builtin = program_->Sem().Get(builtin_attr)->Value();
builtin_found = true;
- auto name = builtin_to_attribute(builtin->builtin);
+ auto name = builtin_to_attribute(builtin);
if (name.empty()) {
diagnostics_.add_error(diag::System::Writer, "unknown builtin");
return false;
@@ -2854,8 +2855,9 @@
for (auto* attr : decl->attributes) {
bool ok = Switch(
attr,
- [&](const ast::BuiltinAttribute* builtin) {
- auto name = builtin_to_attribute(builtin->builtin);
+ [&](const ast::BuiltinAttribute* builtin_attr) {
+ auto builtin = program_->Sem().Get(builtin_attr)->Value();
+ auto name = builtin_to_attribute(builtin);
if (name.empty()) {
diagnostics_.add_error(diag::System::Writer, "unknown builtin");
return false;
diff --git a/src/tint/writer/msl/generator_impl.h b/src/tint/writer/msl/generator_impl.h
index 3e84546..57c129b 100644
--- a/src/tint/writer/msl/generator_impl.h
+++ b/src/tint/writer/msl/generator_impl.h
@@ -36,6 +36,7 @@
#include "src/tint/ast/return_statement.h"
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program.h"
#include "src/tint/scope_stack.h"
#include "src/tint/sem/struct.h"
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 0a3c5ba..eeaa1e1 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -548,8 +548,9 @@
Operand(wgsize[0].value()), Operand(wgsize[1].value()), Operand(wgsize[2].value())});
}
- for (auto builtin : func_sem->TransitivelyReferencedBuiltinVariables()) {
- if (builtin.second->builtin == builtin::BuiltinValue::kFragDepth) {
+ for (auto it : func_sem->TransitivelyReferencedBuiltinVariables()) {
+ auto builtin = builder_.Sem().Get(it.second)->Value();
+ if (builtin == builtin::BuiltinValue::kFragDepth) {
push_execution_mode(spv::Op::OpExecutionMode,
{Operand(id), U32Operand(SpvExecutionModeDepthReplacing)});
}
@@ -837,10 +838,11 @@
for (auto* attr : v->attributes) {
bool ok = Switch(
attr,
- [&](const ast::BuiltinAttribute* builtin) {
+ [&](const ast::BuiltinAttribute* builtin_attr) {
+ auto builtin = builder_.Sem().Get(builtin_attr)->Value();
push_annot(spv::Op::OpDecorate,
{Operand(var_id), U32Operand(SpvDecorationBuiltIn),
- U32Operand(ConvertBuiltin(builtin->builtin, sem->AddressSpace()))});
+ U32Operand(ConvertBuiltin(builtin, sem->AddressSpace()))});
return true;
},
[&](const ast::LocationAttribute*) {
diff --git a/src/tint/writer/spirv/builder.h b/src/tint/writer/spirv/builder.h
index d4aa11b..adfe659 100644
--- a/src/tint/writer/spirv/builder.h
+++ b/src/tint/writer/spirv/builder.h
@@ -33,6 +33,7 @@
#include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h"
#include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h"
#include "src/tint/scope_stack.h"
#include "src/tint/sem/builtin.h"
diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc
index 0902d2c..1fa03ff 100644
--- a/src/tint/writer/wgsl/generator_impl.cc
+++ b/src/tint/writer/wgsl/generator_impl.cc
@@ -564,7 +564,11 @@
return true;
},
[&](const ast::BuiltinAttribute* builtin) {
- out << "builtin(" << builtin->builtin << ")";
+ out << "builtin(";
+ if (!EmitExpression(out, builtin->builtin)) {
+ return false;
+ }
+ out << ")";
return true;
},
[&](const ast::DiagnosticAttribute* diagnostic) {
diff --git a/src/tint/writer/wgsl/generator_impl_function_test.cc b/src/tint/writer/wgsl/generator_impl_function_test.cc
index 53131cd..04103ff 100644
--- a/src/tint/writer/wgsl/generator_impl_function_test.cc
+++ b/src/tint/writer/wgsl/generator_impl_function_test.cc
@@ -15,6 +15,7 @@
#include "src/tint/ast/stage_attribute.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/ast/workgroup_attribute.h"
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/writer/wgsl/test_helper.h"
using namespace tint::number_suffixes; // NOLINT
diff --git a/src/tint/writer/wgsl/generator_impl_type_test.cc b/src/tint/writer/wgsl/generator_impl_type_test.cc
index baa6d5b..422b711 100644
--- a/src/tint/writer/wgsl/generator_impl_type_test.cc
+++ b/src/tint/writer/wgsl/generator_impl_type_test.cc
@@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "src/tint/builtin/builtin_value.h"
#include "src/tint/type/depth_texture.h"
#include "src/tint/type/multisampled_texture.h"
#include "src/tint/type/sampled_texture.h"
diff --git a/test/tint/bug/tint/1088.spvasm.expected.dxc.hlsl b/test/tint/bug/tint/1088.spvasm.expected.dxc.hlsl
index dce65eb..1588b26 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.dxc.hlsl
+++ b/test/tint/bug/tint/1088.spvasm.expected.dxc.hlsl
@@ -1,4 +1,4 @@
-static float3 position = float3(0.0f, 0.0f, 0.0f);
+static float3 position_1 = float3(0.0f, 0.0f, 0.0f);
cbuffer cbuffer_x_14 : register(b2, space2) {
uint4 x_14[17];
};
@@ -18,13 +18,13 @@
void main_1() {
float4 q = float4(0.0f, 0.0f, 0.0f, 0.0f);
float3 p = float3(0.0f, 0.0f, 0.0f);
- const float3 x_13 = position;
+ const float3 x_13 = position_1;
q = float4(x_13.x, x_13.y, x_13.z, 1.0f);
const float4 x_21 = q;
p = float3(x_21.x, x_21.y, x_21.z);
const float x_27 = p.x;
const float x_41 = asfloat(x_14[13].x);
- const float x_45 = position.y;
+ const float x_45 = position_1.y;
const float x_49 = asfloat(x_14[4].x);
p.x = (x_27 + sin(((x_41 * x_45) + x_49)));
const float x_55 = p.y;
@@ -45,7 +45,7 @@
float2 vUV_1;
};
struct tint_symbol_1 {
- float3 position_param : TEXCOORD0;
+ float3 position_1_param : TEXCOORD0;
float3 normal_param : TEXCOORD1;
float2 uv_param : TEXCOORD2;
};
@@ -54,8 +54,8 @@
float4 gl_Position : SV_Position;
};
-main_out main_inner(float3 position_param, float2 uv_param, float3 normal_param) {
- position = position_param;
+main_out main_inner(float3 position_1_param, float2 uv_param, float3 normal_param) {
+ position_1 = position_1_param;
uv = uv_param;
normal = normal_param;
main_1();
@@ -64,7 +64,7 @@
}
tint_symbol_2 main(tint_symbol_1 tint_symbol) {
- const main_out inner_result = main_inner(tint_symbol.position_param, tint_symbol.uv_param, tint_symbol.normal_param);
+ const main_out inner_result = main_inner(tint_symbol.position_1_param, tint_symbol.uv_param, tint_symbol.normal_param);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.gl_Position = inner_result.gl_Position;
wrapper_result.vUV_1 = inner_result.vUV_1;
diff --git a/test/tint/bug/tint/1088.spvasm.expected.fxc.hlsl b/test/tint/bug/tint/1088.spvasm.expected.fxc.hlsl
index dce65eb..1588b26 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.fxc.hlsl
+++ b/test/tint/bug/tint/1088.spvasm.expected.fxc.hlsl
@@ -1,4 +1,4 @@
-static float3 position = float3(0.0f, 0.0f, 0.0f);
+static float3 position_1 = float3(0.0f, 0.0f, 0.0f);
cbuffer cbuffer_x_14 : register(b2, space2) {
uint4 x_14[17];
};
@@ -18,13 +18,13 @@
void main_1() {
float4 q = float4(0.0f, 0.0f, 0.0f, 0.0f);
float3 p = float3(0.0f, 0.0f, 0.0f);
- const float3 x_13 = position;
+ const float3 x_13 = position_1;
q = float4(x_13.x, x_13.y, x_13.z, 1.0f);
const float4 x_21 = q;
p = float3(x_21.x, x_21.y, x_21.z);
const float x_27 = p.x;
const float x_41 = asfloat(x_14[13].x);
- const float x_45 = position.y;
+ const float x_45 = position_1.y;
const float x_49 = asfloat(x_14[4].x);
p.x = (x_27 + sin(((x_41 * x_45) + x_49)));
const float x_55 = p.y;
@@ -45,7 +45,7 @@
float2 vUV_1;
};
struct tint_symbol_1 {
- float3 position_param : TEXCOORD0;
+ float3 position_1_param : TEXCOORD0;
float3 normal_param : TEXCOORD1;
float2 uv_param : TEXCOORD2;
};
@@ -54,8 +54,8 @@
float4 gl_Position : SV_Position;
};
-main_out main_inner(float3 position_param, float2 uv_param, float3 normal_param) {
- position = position_param;
+main_out main_inner(float3 position_1_param, float2 uv_param, float3 normal_param) {
+ position_1 = position_1_param;
uv = uv_param;
normal = normal_param;
main_1();
@@ -64,7 +64,7 @@
}
tint_symbol_2 main(tint_symbol_1 tint_symbol) {
- const main_out inner_result = main_inner(tint_symbol.position_param, tint_symbol.uv_param, tint_symbol.normal_param);
+ const main_out inner_result = main_inner(tint_symbol.position_1_param, tint_symbol.uv_param, tint_symbol.normal_param);
tint_symbol_2 wrapper_result = (tint_symbol_2)0;
wrapper_result.gl_Position = inner_result.gl_Position;
wrapper_result.vUV_1 = inner_result.vUV_1;
diff --git a/test/tint/bug/tint/1088.spvasm.expected.glsl b/test/tint/bug/tint/1088.spvasm.expected.glsl
index 88d88ec..678a63e 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.glsl
+++ b/test/tint/bug/tint/1088.spvasm.expected.glsl
@@ -1,6 +1,6 @@
#version 310 es
-layout(location = 0) in vec3 position_param_1;
+layout(location = 0) in vec3 position_1_param_1;
layout(location = 2) in vec2 uv_param_1;
layout(location = 1) in vec3 normal_param_1;
layout(location = 0) out vec2 vUV_1_1;
@@ -21,7 +21,7 @@
strided_arr test[4];
};
-vec3 position = vec3(0.0f, 0.0f, 0.0f);
+vec3 position_1 = vec3(0.0f, 0.0f, 0.0f);
layout(binding = 2, std140) uniform x_14_block_ubo {
LeftOver inner;
} x_14;
@@ -33,13 +33,13 @@
void main_1() {
vec4 q = vec4(0.0f, 0.0f, 0.0f, 0.0f);
vec3 p = vec3(0.0f, 0.0f, 0.0f);
- vec3 x_13 = position;
+ vec3 x_13 = position_1;
q = vec4(x_13.x, x_13.y, x_13.z, 1.0f);
vec4 x_21 = q;
p = vec3(x_21.x, x_21.y, x_21.z);
float x_27 = p.x;
float x_41 = x_14.inner.test[0].el;
- float x_45 = position.y;
+ float x_45 = position_1.y;
float x_49 = x_14.inner.time;
p.x = (x_27 + sin(((x_41 * x_45) + x_49)));
float x_55 = p.y;
@@ -60,8 +60,8 @@
vec2 vUV_1;
};
-main_out tint_symbol_1(vec3 position_param, vec2 uv_param, vec3 normal_param) {
- position = position_param;
+main_out tint_symbol_1(vec3 position_1_param, vec2 uv_param, vec3 normal_param) {
+ position_1 = position_1_param;
uv = uv_param;
normal = normal_param;
main_1();
@@ -71,7 +71,7 @@
void main() {
gl_PointSize = 1.0;
- main_out inner_result = tint_symbol_1(position_param_1, uv_param_1, normal_param_1);
+ main_out inner_result = tint_symbol_1(position_1_param_1, uv_param_1, normal_param_1);
gl_Position = inner_result.tint_symbol;
vUV_1_1 = inner_result.vUV_1;
gl_Position.y = -(gl_Position.y);
diff --git a/test/tint/bug/tint/1088.spvasm.expected.msl b/test/tint/bug/tint/1088.spvasm.expected.msl
index 5970249..2fc3f5f 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.msl
+++ b/test/tint/bug/tint/1088.spvasm.expected.msl
@@ -58,7 +58,7 @@
};
struct tint_symbol_2 {
- float3 position_param [[attribute(0)]];
+ float3 position_1_param [[attribute(0)]];
float3 normal_param [[attribute(1)]];
float2 uv_param [[attribute(2)]];
};
@@ -68,9 +68,9 @@
float4 gl_Position [[position]];
};
-main_out tint_symbol_inner(float3 position_param, float2 uv_param, float3 normal_param, thread float3* const tint_symbol_10, thread float2* const tint_symbol_11, const constant LeftOver* const tint_symbol_13, thread float4* const tint_symbol_14, thread float2* const tint_symbol_15) {
+main_out tint_symbol_inner(float3 position_1_param, float2 uv_param, float3 normal_param, thread float3* const tint_symbol_10, thread float2* const tint_symbol_11, const constant LeftOver* const tint_symbol_13, thread float4* const tint_symbol_14, thread float2* const tint_symbol_15) {
thread float3 tint_symbol_12 = 0.0f;
- *(tint_symbol_10) = position_param;
+ *(tint_symbol_10) = position_1_param;
*(tint_symbol_11) = uv_param;
tint_symbol_12 = normal_param;
main_1(tint_symbol_10, tint_symbol_13, tint_symbol_14, tint_symbol_11, tint_symbol_15);
@@ -83,7 +83,7 @@
thread float2 tint_symbol_17 = 0.0f;
thread float4 tint_symbol_19 = 0.0f;
thread float2 tint_symbol_20 = 0.0f;
- main_out const inner_result = tint_symbol_inner(tint_symbol_1.position_param, tint_symbol_1.uv_param, tint_symbol_1.normal_param, &(tint_symbol_16), &(tint_symbol_17), tint_symbol_18, &(tint_symbol_19), &(tint_symbol_20));
+ main_out const inner_result = tint_symbol_inner(tint_symbol_1.position_1_param, tint_symbol_1.uv_param, tint_symbol_1.normal_param, &(tint_symbol_16), &(tint_symbol_17), tint_symbol_18, &(tint_symbol_19), &(tint_symbol_20));
tint_symbol_3 wrapper_result = {};
wrapper_result.gl_Position = inner_result.gl_Position;
wrapper_result.vUV_1 = inner_result.vUV_1;
diff --git a/test/tint/bug/tint/1088.spvasm.expected.spvasm b/test/tint/bug/tint/1088.spvasm.expected.spvasm
index 3221d0a..10fa5cb 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.spvasm
+++ b/test/tint/bug/tint/1088.spvasm.expected.spvasm
@@ -6,14 +6,14 @@
OpCapability Shader
%76 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
- OpEntryPoint Vertex %main "main" %position_param_1 %uv_param_1 %normal_param_1 %gl_Position_1 %vUV_1_1 %vertex_point_size
- OpName %position_param_1 "position_param_1"
+ OpEntryPoint Vertex %main "main" %position_1_param_1 %uv_param_1 %normal_param_1 %gl_Position_1 %vUV_1_1 %vertex_point_size
+ OpName %position_1_param_1 "position_1_param_1"
OpName %uv_param_1 "uv_param_1"
OpName %normal_param_1 "normal_param_1"
OpName %gl_Position_1 "gl_Position_1"
OpName %vUV_1_1 "vUV_1_1"
OpName %vertex_point_size "vertex_point_size"
- OpName %position "position"
+ OpName %position_1 "position_1"
OpName %x_14_block "x_14_block"
OpMemberName %x_14_block 0 "inner"
OpName %LeftOver "LeftOver"
@@ -35,11 +35,11 @@
OpMemberName %main_out 0 "gl_Position"
OpMemberName %main_out 1 "vUV_1"
OpName %main_inner "main_inner"
- OpName %position_param "position_param"
+ OpName %position_1_param "position_1_param"
OpName %uv_param "uv_param"
OpName %normal_param "normal_param"
OpName %main "main"
- OpDecorate %position_param_1 Location 0
+ OpDecorate %position_1_param_1 Location 0
OpDecorate %uv_param_1 Location 2
OpDecorate %normal_param_1 Location 1
OpDecorate %gl_Position_1 BuiltIn Position
@@ -66,7 +66,7 @@
%float = OpTypeFloat 32
%v3float = OpTypeVector %float 3
%_ptr_Input_v3float = OpTypePointer Input %v3float
-%position_param_1 = OpVariable %_ptr_Input_v3float Input
+%position_1_param_1 = OpVariable %_ptr_Input_v3float Input
%v2float = OpTypeVector %float 2
%_ptr_Input_v2float = OpTypePointer Input %v2float
%uv_param_1 = OpVariable %_ptr_Input_v2float Input
@@ -83,7 +83,7 @@
%vertex_point_size = OpVariable %_ptr_Output_float Output %18
%_ptr_Private_v3float = OpTypePointer Private %v3float
%21 = OpConstantNull %v3float
- %position = OpVariable %_ptr_Private_v3float Private %21
+ %position_1 = OpVariable %_ptr_Private_v3float Private %21
%mat4v4float = OpTypeMatrix %v4float 4
%uint = OpTypeInt 32 0
%uint_2 = OpConstant %uint 2
@@ -123,7 +123,7 @@
%42 = OpLabel
%q = OpVariable %_ptr_Function_v4float Function %12
%p = OpVariable %_ptr_Function_v3float Function %21
- %47 = OpLoad %v3float %position
+ %47 = OpLoad %v3float %position_1
%48 = OpCompositeExtract %float %47 0
%49 = OpCompositeExtract %float %47 1
%50 = OpCompositeExtract %float %47 2
@@ -139,7 +139,7 @@
%61 = OpLoad %float %60
%66 = OpAccessChain %_ptr_Uniform_float %x_14 %uint_0 %uint_3 %64 %uint_0
%67 = OpLoad %float %66
- %70 = OpAccessChain %_ptr_Private_float %position %uint_1
+ %70 = OpAccessChain %_ptr_Private_float %position_1 %uint_1
%71 = OpLoad %float %70
%72 = OpAccessChain %_ptr_Uniform_float %x_14 %uint_0 %uint_1
%73 = OpLoad %float %72
@@ -177,11 +177,11 @@
OpReturn
OpFunctionEnd
%main_inner = OpFunction %main_out None %104
-%position_param = OpFunctionParameter %v3float
+%position_1_param = OpFunctionParameter %v3float
%uv_param = OpFunctionParameter %v2float
%normal_param = OpFunctionParameter %v3float
%110 = OpLabel
- OpStore %position %position_param
+ OpStore %position_1 %position_1_param
OpStore %uv %uv_param
OpStore %normal %normal_param
%111 = OpFunctionCall %void %main_1
@@ -192,7 +192,7 @@
OpFunctionEnd
%main = OpFunction %void None %39
%116 = OpLabel
- %118 = OpLoad %v3float %position_param_1
+ %118 = OpLoad %v3float %position_1_param_1
%119 = OpLoad %v2float %uv_param_1
%120 = OpLoad %v3float %normal_param_1
%117 = OpFunctionCall %main_out %main_inner %118 %119 %120
diff --git a/test/tint/bug/tint/1088.spvasm.expected.wgsl b/test/tint/bug/tint/1088.spvasm.expected.wgsl
index 8d40799..8ef9562 100644
--- a/test/tint/bug/tint/1088.spvasm.expected.wgsl
+++ b/test/tint/bug/tint/1088.spvasm.expected.wgsl
@@ -18,7 +18,7 @@
test : Arr_1,
}
-var<private> position : vec3<f32>;
+var<private> position_1 : vec3<f32>;
@group(2) @binding(2) var<uniform> x_14 : LeftOver;
@@ -33,13 +33,13 @@
fn main_1() {
var q : vec4<f32>;
var p : vec3<f32>;
- let x_13 : vec3<f32> = position;
+ let x_13 : vec3<f32> = position_1;
q = vec4<f32>(x_13.x, x_13.y, x_13.z, 1.0f);
let x_21 : vec4<f32> = q;
p = vec3<f32>(x_21.x, x_21.y, x_21.z);
let x_27 : f32 = p.x;
let x_41 : f32 = x_14.test[0i].el;
- let x_45 : f32 = position.y;
+ let x_45 : f32 = position_1.y;
let x_49 : f32 = x_14.time;
p.x = (x_27 + sin(((x_41 * x_45) + x_49)));
let x_55 : f32 = p.y;
@@ -63,8 +63,8 @@
}
@vertex
-fn main(@location(0) position_param : vec3<f32>, @location(2) uv_param : vec2<f32>, @location(1) normal_param : vec3<f32>) -> main_out {
- position = position_param;
+fn main(@location(0) position_1_param : vec3<f32>, @location(2) uv_param : vec2<f32>, @location(1) normal_param : vec3<f32>) -> main_out {
+ position_1 = position_1_param;
uv = uv_param;
normal = normal_param;
main_1();
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.dxc.hlsl
index f3fc898..0c3cc70 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.dxc.hlsl
@@ -9,9 +9,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.fxc.hlsl
index f3fc898..0c3cc70 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.fxc.hlsl
@@ -9,9 +9,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.glsl b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.glsl
index 0912c08..800af68 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.glsl
@@ -10,9 +10,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.msl b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.msl
index f1220af..d17c9b4 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.msl
@@ -22,9 +22,9 @@
return (lhs % select(rhs, 1u, (rhs == 0u)));
}
-void compute_main_inner(uint local_invocation_index, threadgroup tint_array<tint_array<tint_array<atomic_uint, 1>, 2>, 3>* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup tint_array<tint_array<tint_array<atomic_uint, 1>, 2>, 3>* const tint_symbol_3) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint const x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.spvasm
index fb00bc8..71bb07e 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.spvasm
@@ -17,7 +17,7 @@
OpName %lhs_0 "lhs"
OpName %rhs_0 "rhs"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %idx "idx"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
@@ -75,11 +75,11 @@
OpReturnValue %30
OpFunctionEnd
%compute_main_inner = OpFunction %void None %31
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%35 = OpLabel
%idx = OpVariable %_ptr_Function_uint Function %6
OpStore %idx %6
- OpStore %idx %local_invocation_index
+ OpStore %idx %local_invocation_index_2
OpBranch %38
%38 = OpLabel
OpLoopMerge %39 %40 None
diff --git a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.wgsl
index 4c957ce..cab0823 100644
--- a/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/array/aliased_arrays.spvasm.expected.wgsl
@@ -8,9 +8,9 @@
var<workgroup> wg : array<array<array<atomic<u32>, 1u>, 2u>, 3u>;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
var idx : u32 = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
loop {
let x_25 : u32 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/array/array.spvasm.expected.dxc.hlsl
index ea978df..0016dc8 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.dxc.hlsl
@@ -1,9 +1,9 @@
static uint local_invocation_index_1 = 0u;
groupshared uint wg[4];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_21 = idx;
if (!((x_21 < 4u))) {
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/array/array.spvasm.expected.fxc.hlsl
index ea978df..0016dc8 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.fxc.hlsl
@@ -1,9 +1,9 @@
static uint local_invocation_index_1 = 0u;
groupshared uint wg[4];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_21 = idx;
if (!((x_21 < 4u))) {
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.glsl b/test/tint/builtins/atomicStore/array/array.spvasm.expected.glsl
index bf89cae..3567dd6 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.glsl
@@ -2,9 +2,9 @@
uint local_invocation_index_1 = 0u;
shared uint wg[4];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint x_21 = idx;
if (!((x_21 < 4u))) {
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.msl b/test/tint/builtins/atomicStore/array/array.spvasm.expected.msl
index 8ef9d39..a4eb243 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.msl
@@ -14,9 +14,9 @@
T elements[N];
};
-void compute_main_inner(uint local_invocation_index, threadgroup tint_array<atomic_uint, 4>* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup tint_array<atomic_uint, 4>* const tint_symbol) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint const x_21 = idx;
if (!((x_21 < 4u))) {
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/array/array.spvasm.expected.spvasm
index e15c3db..be9caab 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.spvasm
@@ -11,7 +11,7 @@
OpName %local_invocation_index_1 "local_invocation_index_1"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %idx "idx"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
@@ -43,11 +43,11 @@
%int_1 = OpConstant %int 1
%45 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %11
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%15 = OpLabel
%idx = OpVariable %_ptr_Function_uint Function %6
OpStore %idx %6
- OpStore %idx %local_invocation_index
+ OpStore %idx %local_invocation_index_2
OpBranch %18
%18 = OpLabel
OpLoopMerge %19 %20 None
diff --git a/test/tint/builtins/atomicStore/array/array.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/array/array.spvasm.expected.wgsl
index f1ce6c7..6b51227 100644
--- a/test/tint/builtins/atomicStore/array/array.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/array/array.spvasm.expected.wgsl
@@ -4,9 +4,9 @@
var<workgroup> wg : array<atomic<u32>, 4u>;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
var idx : u32 = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
loop {
let x_21 : u32 = idx;
if (!((x_21 < 4u))) {
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.dxc.hlsl
index f3fc898..0c3cc70 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.dxc.hlsl
@@ -9,9 +9,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.fxc.hlsl
index f3fc898..0c3cc70 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.fxc.hlsl
@@ -9,9 +9,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.glsl b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.glsl
index 0912c08..800af68 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.glsl
@@ -10,9 +10,9 @@
return (lhs % ((rhs == 0u) ? 1u : rhs));
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.msl b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.msl
index f1220af..d17c9b4 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.msl
@@ -22,9 +22,9 @@
return (lhs % select(rhs, 1u, (rhs == 0u)));
}
-void compute_main_inner(uint local_invocation_index, threadgroup tint_array<tint_array<tint_array<atomic_uint, 1>, 2>, 3>* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup tint_array<tint_array<tint_array<atomic_uint, 1>, 2>, 3>* const tint_symbol_3) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint const x_25 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.spvasm
index fb00bc8..71bb07e 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.spvasm
@@ -17,7 +17,7 @@
OpName %lhs_0 "lhs"
OpName %rhs_0 "rhs"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %idx "idx"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
@@ -75,11 +75,11 @@
OpReturnValue %30
OpFunctionEnd
%compute_main_inner = OpFunction %void None %31
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%35 = OpLabel
%idx = OpVariable %_ptr_Function_uint Function %6
OpStore %idx %6
- OpStore %idx %local_invocation_index
+ OpStore %idx %local_invocation_index_2
OpBranch %38
%38 = OpLabel
OpLoopMerge %39 %40 None
diff --git a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.wgsl
index 4c957ce..cab0823 100644
--- a/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/array/arrays.spvasm.expected.wgsl
@@ -8,9 +8,9 @@
var<workgroup> wg : array<array<array<atomic<u32>, 1u>, 2u>, 3u>;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
var idx : u32 = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
loop {
let x_25 : u32 = idx;
if (!((x_25 < 6u))) {
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.dxc.hlsl
index 29a168e..965a8af 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.dxc.hlsl
@@ -7,9 +7,9 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg[10];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_23 = idx;
if (!((x_23 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.fxc.hlsl
index 29a168e..965a8af 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.fxc.hlsl
@@ -7,9 +7,9 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg[10];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_23 = idx;
if (!((x_23 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.glsl
index 6252580..a1fc729 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.glsl
@@ -14,9 +14,9 @@
uint local_invocation_index_1 = 0u;
shared S_atomic wg[10];
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint x_23 = idx;
if (!((x_23 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.msl
index f4fd526..f9bac41 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.msl
@@ -26,9 +26,9 @@
uint y;
};
-void compute_main_inner(uint local_invocation_index, threadgroup tint_array<S_atomic, 10>* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup tint_array<S_atomic, 10>* const tint_symbol) {
uint idx = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint const x_23 = idx;
if (!((x_23 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.spvasm
index b25f900..ee16a5c 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.spvasm
@@ -15,7 +15,7 @@
OpMemberName %S_atomic 2 "y"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %idx "idx"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
@@ -54,11 +54,11 @@
%int_4 = OpConstant %int 4
%51 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %13
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%17 = OpLabel
%idx = OpVariable %_ptr_Function_uint Function %6
OpStore %idx %6
- OpStore %idx %local_invocation_index
+ OpStore %idx %local_invocation_index_2
OpBranch %20
%20 = OpLabel
OpLoopMerge %21 %22 None
diff --git a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.wgsl
index b3a1105..81a23a5 100644
--- a/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/array_of_struct.spvasm.expected.wgsl
@@ -22,9 +22,9 @@
var<workgroup> wg : array<S_atomic, 10u>;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
var idx : u32 = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
loop {
let x_23 : u32 = idx;
if (!((x_23 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.dxc.hlsl
index aa81130..c56ccea 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.dxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.fxc.hlsl
index aa81130..c56ccea 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.fxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.glsl
index 0b67618..a183ccf 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.glsl
@@ -14,7 +14,7 @@
uint local_invocation_index_1 = 0u;
shared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
atomicExchange(wg.a, 0u);
atomicExchange(wg.b, 0u);
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.msl
index 4e1363d..9ff385d 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.msl
@@ -13,7 +13,7 @@
uint b;
};
-void compute_main_inner(uint local_invocation_index, threadgroup S_atomic* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup S_atomic* const tint_symbol) {
(*(tint_symbol)).x = 0;
atomic_store_explicit(&((*(tint_symbol)).a), 0u, memory_order_relaxed);
atomic_store_explicit(&((*(tint_symbol)).b), 0u, memory_order_relaxed);
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.spvasm
index 5ee475d..de9e2a6 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.spvasm
@@ -15,7 +15,7 @@
OpMemberName %S_atomic 2 "b"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -45,7 +45,7 @@
%uint_264 = OpConstant %uint 264
%37 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %11
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%15 = OpLabel
%18 = OpAccessChain %_ptr_Workgroup_int %wg %uint_0
OpStore %18 %19
diff --git a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.wgsl
index c9a899d..3f9e97b 100644
--- a/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/flat_multiple_atomics.spvasm.expected.wgsl
@@ -20,7 +20,7 @@
var<workgroup> wg : S_atomic;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
wg.x = 0i;
atomicStore(&(wg.a), 0u);
atomicStore(&(wg.b), 0u);
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.dxc.hlsl
index 2245126..d735498 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.dxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.fxc.hlsl
index 2245126..d735498 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.fxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.glsl
index 4116efd..a3dfff6 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.glsl
@@ -14,7 +14,7 @@
uint local_invocation_index_1 = 0u;
shared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
atomicExchange(wg.a, 0u);
wg.y = 0u;
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.msl
index 524820a..7e1b7dc 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.msl
@@ -13,7 +13,7 @@
uint y;
};
-void compute_main_inner(uint local_invocation_index, threadgroup S_atomic* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup S_atomic* const tint_symbol) {
(*(tint_symbol)).x = 0;
atomic_store_explicit(&((*(tint_symbol)).a), 0u, memory_order_relaxed);
(*(tint_symbol)).y = 0u;
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.spvasm
index 35d0d2b..0c6e7b9 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.spvasm
@@ -15,7 +15,7 @@
OpMemberName %S_atomic 2 "y"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
%uint_264 = OpConstant %uint 264
%33 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %11
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%15 = OpLabel
%18 = OpAccessChain %_ptr_Workgroup_int %wg %uint_0
OpStore %18 %19
diff --git a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.wgsl
index ff3d543..5180091 100644
--- a/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/flat_single_atomic.spvasm.expected.wgsl
@@ -20,7 +20,7 @@
var<workgroup> wg : S_atomic;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
wg.x = 0i;
atomicStore(&(wg.a), 0u);
wg.y = 0u;
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.dxc.hlsl
index 8a073d1..b564c9c 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.dxc.hlsl
@@ -20,7 +20,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S2_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
wg.y = 0;
wg.z = 0;
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.fxc.hlsl
index 8a073d1..b564c9c 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.fxc.hlsl
@@ -20,7 +20,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S2_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
wg.y = 0;
wg.z = 0;
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.glsl
index c0e09d0..ea69be3 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.glsl
@@ -44,7 +44,7 @@
uint local_invocation_index_1 = 0u;
shared S2_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
wg.y = 0;
wg.z = 0;
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.msl
index 1ed439c..0e4963c 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.msl
@@ -43,7 +43,7 @@
S1 a;
};
-void compute_main_inner(uint local_invocation_index, threadgroup S2_atomic* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup S2_atomic* const tint_symbol) {
(*(tint_symbol)).x = 0;
(*(tint_symbol)).y = 0;
(*(tint_symbol)).z = 0;
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.spvasm
index 9f756f3..ba5cca6 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.spvasm
@@ -26,7 +26,7 @@
OpMemberName %S1_atomic 3 "z"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -68,7 +68,7 @@
%uint_264 = OpConstant %uint 264
%42 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %13
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%17 = OpLabel
%20 = OpAccessChain %_ptr_Workgroup_int %wg %uint_0
OpStore %20 %21
diff --git a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.wgsl
index e448d74..268d74f 100644
--- a/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/nested.spvasm.expected.wgsl
@@ -68,7 +68,7 @@
var<workgroup> wg : S2_atomic;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
wg.x = 0i;
wg.y = 0i;
wg.z = 0i;
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.dxc.hlsl
index c685a44..69d98ab 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.dxc.hlsl
@@ -7,11 +7,11 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
wg.x = 0;
wg.y = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_30 = idx;
if (!((x_30 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.fxc.hlsl
index c685a44..69d98ab 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.fxc.hlsl
@@ -7,11 +7,11 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
wg.x = 0;
wg.y = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
const uint x_30 = idx;
if (!((x_30 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.glsl
index b6add35..06b3b6e 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.glsl
@@ -14,11 +14,11 @@
uint local_invocation_index_1 = 0u;
shared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint idx = 0u;
wg.x = 0;
wg.y = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint x_30 = idx;
if (!((x_30 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.msl
index 69d565e..fc28533 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.msl
@@ -26,11 +26,11 @@
uint y;
};
-void compute_main_inner(uint local_invocation_index, threadgroup S_atomic* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup S_atomic* const tint_symbol) {
uint idx = 0u;
(*(tint_symbol)).x = 0;
(*(tint_symbol)).y = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
while (true) {
uint const x_30 = idx;
if (!((x_30 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.spvasm
index d774374..b6bd6d7 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.spvasm
@@ -15,7 +15,7 @@
OpMemberName %S_atomic 2 "y"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %idx "idx"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
@@ -54,7 +54,7 @@
%int_4 = OpConstant %int 4
%51 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %13
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%17 = OpLabel
%idx = OpVariable %_ptr_Function_uint Function %6
OpStore %idx %6
@@ -62,7 +62,7 @@
OpStore %22 %23
%26 = OpAccessChain %_ptr_Workgroup_uint %wg %uint_2
OpStore %26 %6
- OpStore %idx %local_invocation_index
+ OpStore %idx %local_invocation_index_2
OpBranch %27
%27 = OpLabel
OpLoopMerge %28 %29 None
diff --git a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.wgsl
index b8953f1..d03070c 100644
--- a/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/struct_of_array.spvasm.expected.wgsl
@@ -22,11 +22,11 @@
var<workgroup> wg : S_atomic;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
var idx : u32 = 0u;
wg.x = 0i;
wg.y = 0u;
- idx = local_invocation_index;
+ idx = local_invocation_index_2;
loop {
let x_30 : u32 = idx;
if (!((x_30 < 10u))) {
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.dxc.hlsl
index 2245126..d735498 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.dxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.fxc.hlsl
index 2245126..d735498 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.fxc.hlsl
@@ -7,7 +7,7 @@
static uint local_invocation_index_1 = 0u;
groupshared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
uint atomic_result = 0u;
InterlockedExchange(wg.a, 0u, atomic_result);
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.glsl b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.glsl
index 4116efd..a3dfff6 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.glsl
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.glsl
@@ -14,7 +14,7 @@
uint local_invocation_index_1 = 0u;
shared S_atomic wg;
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
wg.x = 0;
atomicExchange(wg.a, 0u);
wg.y = 0u;
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.msl b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.msl
index 524820a..7e1b7dc 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.msl
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.msl
@@ -13,7 +13,7 @@
uint y;
};
-void compute_main_inner(uint local_invocation_index, threadgroup S_atomic* const tint_symbol) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup S_atomic* const tint_symbol) {
(*(tint_symbol)).x = 0;
atomic_store_explicit(&((*(tint_symbol)).a), 0u, memory_order_relaxed);
(*(tint_symbol)).y = 0u;
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.spvasm b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.spvasm
index 35d0d2b..0c6e7b9 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.spvasm
@@ -15,7 +15,7 @@
OpMemberName %S_atomic 2 "y"
OpName %wg "wg"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
%uint_264 = OpConstant %uint 264
%33 = OpTypeFunction %void
%compute_main_inner = OpFunction %void None %11
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%15 = OpLabel
%18 = OpAccessChain %_ptr_Workgroup_int %wg %uint_0
OpStore %18 %19
diff --git a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.wgsl b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.wgsl
index ff3d543..5180091 100644
--- a/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomicStore/struct/via_ptr_let.spvasm.expected.wgsl
@@ -20,7 +20,7 @@
var<workgroup> wg : S_atomic;
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
wg.x = 0i;
atomicStore(&(wg.a), 0u);
wg.y = 0u;
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
index 89a6a35..0c494d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
index 89a6a35..0c494d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.glsl
index c95c6a9..a9f59ed 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.msl
index 62639d7..5f8945f 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.spvasm
index 3dc0a5d..1f62e68 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_794055 "atomicAdd_794055"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.wgsl
index 723a113..d59a523 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
index d1179cc..99ac4aa 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
index d1179cc..99ac4aa 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.glsl
index 5a5b50b..e0f0981 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.msl
index 04a890a..6dab262 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.spvasm
index 5daee64..66a3661 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_d5db1d "atomicAdd_d5db1d"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.wgsl
index 61d34cc..5a1db0e 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAdd/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
index c3e91bf..bb3fe38 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
index c3e91bf..bb3fe38 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.glsl
index 601ae32..09f9466 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAnd_45a819();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.msl
index ee4b602..af7eadc 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAnd_45a819(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.spvasm
index b7e9939..350c984 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAnd_45a819 "atomicAnd_45a819"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.wgsl
index 9369271..7ac8d28 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAnd_45a819();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
index b215600..15512d3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
index b215600..15512d3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.glsl
index 9b6741b..8db98c5 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAnd_34edd3();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.msl
index ffc5ace..2da6bbd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAnd_34edd3(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.spvasm
index 02a5b89..43720d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAnd_34edd3 "atomicAnd_34edd3"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.wgsl
index ee27cf6..a077ce7 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicAnd/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAnd_34edd3();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
index 44cf740..fe0811a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -24,7 +24,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
index 44cf740..fe0811a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -24,7 +24,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
index a4305e7..11092c7 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
@@ -26,7 +26,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicCompareExchangeWeak_e88938();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
index a296185..25e9db3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
@@ -27,7 +27,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_3) {
atomic_store_explicit(tint_symbol_3, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicCompareExchangeWeak_e88938(tint_symbol_3);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
index f82b2cb..e4be06c 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
@@ -19,7 +19,7 @@
OpMemberName %__atomic_compare_exchange_resulti32 0 "old_value"
OpMemberName %__atomic_compare_exchange_resulti32 1 "exchanged"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -65,7 +65,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %30
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%33 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %36
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
index f85055d..4104721 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
@@ -17,7 +17,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicCompareExchangeWeak_e88938();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
index 1e87d0a..89f85cc 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -24,7 +24,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
index 1e87d0a..89f85cc 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -24,7 +24,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
index 680871b..59a68d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
@@ -26,7 +26,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicCompareExchangeWeak_83580d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
index c980f5d..287ea41 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
@@ -27,7 +27,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_3) {
atomic_store_explicit(tint_symbol_3, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicCompareExchangeWeak_83580d(tint_symbol_3);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
index 9c927f2..6200f89 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
@@ -19,7 +19,7 @@
OpMemberName %__atomic_compare_exchange_resultu32 0 "old_value"
OpMemberName %__atomic_compare_exchange_resultu32 1 "exchanged"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -63,7 +63,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %29
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%32 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
index 8855c3b..df66894 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
@@ -17,7 +17,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicCompareExchangeWeak_83580d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
index 92f0f6e..154f6cf 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
index 92f0f6e..154f6cf 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.glsl
index e836943..35e9a47 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicExchange_e114ba();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.msl
index 7126a8a..d0b8f90 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicExchange_e114ba(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.spvasm
index bb829c9..e553f3d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicExchange_e114ba "atomicExchange_e114ba"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.wgsl
index 4e35c0e..b8eb11a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicExchange_e114ba();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
index d04f2e8..b0f013f 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
index d04f2e8..b0f013f 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.glsl
index 49abca3..dbfb5ea 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicExchange_0a5dca();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.msl
index 4027c03..b562965 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicExchange_0a5dca(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.spvasm
index 0aca328..2a919c5 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicExchange_0a5dca "atomicExchange_0a5dca"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.wgsl
index fb71c6d..e52c9b7 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicExchange/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicExchange_0a5dca();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
index 3e2674e..14e42dd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
index 3e2674e..14e42dd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.glsl
index 351d2dc..6596bb1 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicLoad_afcc03();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.msl
index 8f6ee40..3f9bc5f 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicLoad_afcc03(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.spvasm
index 829b848..f4f86f8 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicLoad_afcc03 "atomicLoad_afcc03"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -45,7 +45,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %21
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%24 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.wgsl
index af0c057..ba60171 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicLoad_afcc03();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
index 3aa482d..2eb7c6c 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
index 3aa482d..2eb7c6c 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.glsl
index 2ad60db..b21c00a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicLoad_361bf1();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.msl
index d7fcb6e..c9f5cd3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicLoad_361bf1(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.spvasm
index 7a075ba..5a8a633 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicLoad_361bf1 "atomicLoad_361bf1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -43,7 +43,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %19
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%22 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.wgsl
index f132c6f..d9fd46d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicLoad/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicLoad_361bf1();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
index a508d4e..0288892 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
index a508d4e..0288892 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.glsl
index f76a297..a33bb75 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicMax_a89cc3();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.msl
index 9421382..c309d8b 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMax_a89cc3(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.spvasm
index 0360ae6..a9a61aa 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicMax_a89cc3 "atomicMax_a89cc3"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.wgsl
index 0c3e2a8..08ebe32 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicMax_a89cc3();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
index 3100cbf..b09ef95 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
index 3100cbf..b09ef95 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.glsl
index 3af9a65..c16c57c 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicMax_beccfc();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.msl
index 200a901..8519e90 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMax_beccfc(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.spvasm
index 7f01c87..edbea82 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicMax_beccfc "atomicMax_beccfc"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.wgsl
index 39ee5df..759d72d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMax/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicMax_beccfc();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
index 69c3b10..8ccadb6 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
index 69c3b10..8ccadb6 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.glsl
index ff9d11f..ea080f7 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicMin_278235();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.msl
index 3c4bd98..f82688a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMin_278235(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.spvasm
index cea2249..76eaac8 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicMin_278235 "atomicMin_278235"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.wgsl
index 5ddda3e..525b7f9 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicMin_278235();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
index 688677a..ad033d3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
index 688677a..ad033d3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.glsl
index 9360d13..08336ed 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicMin_69d383();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.msl
index 226629f..d03bb77 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMin_69d383(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.spvasm
index 475d1ce..044c634 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicMin_69d383 "atomicMin_69d383"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.wgsl
index 8f37c6b..6b2873d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicMin/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicMin_69d383();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
index 85146d8..7ad2a81 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
index 85146d8..7ad2a81 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.glsl
index db9f5ee..f87bf7e 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicOr_d09248();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.msl
index 74c1a58..980a7d6 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicOr_d09248(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.spvasm
index 9ef5893..d52afbd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicOr_d09248 "atomicOr_d09248"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.wgsl
index 5563b2b..92c3719 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicOr_d09248();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
index 178bc59..3ba0201 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
index 178bc59..3ba0201 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.glsl
index 371b0f9..13c90ba 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicOr_5e3d61();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.msl
index 2513fa7..1111dc3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicOr_5e3d61(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.spvasm
index ad9af50..ad9b3e3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicOr_5e3d61 "atomicOr_5e3d61"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.wgsl
index 2e9093e..773349a 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicOr/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicOr_5e3d61();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
index 8b0fd82..57d9ca3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
index 8b0fd82..57d9ca3 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.glsl
index 7804c73..0f4accd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.glsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicStore_8bea94();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.msl
index 78e73c5..fbccdc4 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.msl
@@ -6,7 +6,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicStore_8bea94(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.spvasm
index 319461d..b694a5d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.spvasm
@@ -12,7 +12,7 @@
OpName %arg_0 "arg_0"
OpName %atomicStore_8bea94 "atomicStore_8bea94"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -41,7 +41,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %19
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%22 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %25
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.wgsl
index 800c8fd..08fdac1 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_i32.spvasm.expected.wgsl
@@ -7,7 +7,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicStore_8bea94();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
index 55b8f78..5456c6d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
index 55b8f78..5456c6d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.glsl
index 825825c..065b613 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.glsl
@@ -7,7 +7,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicStore_726882();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.msl
index 1a458eb..33849ed 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.msl
@@ -6,7 +6,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicStore_726882(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.spvasm
index 6f8e362..6673a78 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.spvasm
@@ -12,7 +12,7 @@
OpName %arg_0 "arg_0"
OpName %atomicStore_726882 "atomicStore_726882"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -39,7 +39,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %18
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%21 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.wgsl
index b90d965..6644f12 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicStore/workgroup_u32.spvasm.expected.wgsl
@@ -7,7 +7,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicStore_726882();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
index 4d80582..f7c62c0 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
index 4d80582..f7c62c0 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.glsl
index f600cd5..d878b2d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicSub_77883a();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.msl
index 86f5de2..fcc7910 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicSub_77883a(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.spvasm
index 820d0ae..2b3b8ba 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicSub_77883a "atomicSub_77883a"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.wgsl
index 56079fe..78a3248 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicSub_77883a();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
index dba0df9..e50da1d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
index dba0df9..e50da1d 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.glsl
index cec1ba9..9bd1162 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicSub_0d26c2();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.msl
index 91e3b4b..a166d08 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicSub_0d26c2(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.spvasm
index c42f0b9..55dfb70 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicSub_0d26c2 "atomicSub_0d26c2"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.wgsl
index 2b69af6..cb4dbd1 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicSub/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicSub_0d26c2();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
index 3cec31a..c00f2dd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
index 3cec31a..c00f2dd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.glsl
index cfcab07..434af31 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicXor_75dc95();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.msl
index b5c2e2c..70c0e42 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicXor_75dc95(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.spvasm
index 542376d..d4d71ce 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicXor_75dc95 "atomicXor_75dc95"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.wgsl
index f14ac31..b28291e 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicXor_75dc95();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
index 2e953e9..9195263 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
index 2e953e9..9195263 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.glsl
index 639b4ce..59dd3a9 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicXor_c8e6be();
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.msl
index 6993e95..784f870 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicXor_c8e6be(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.spvasm
index 4f19634..e350d66 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicXor_c8e6be "atomicXor_c8e6be"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.wgsl
index 53f7436..f8d1b77 100644
--- a/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/atomicXor/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicXor_c8e6be();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
index 04ff6d8..423a564 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
index 04ff6d8..423a564 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
index c95c6a9..a9f59ed 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
index e7d19e9..6e646d5 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
index 32bc60e..51c50d1 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_794055 "atomicAdd_794055"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
index 6050ff2..ff925f6 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
index 88c04ad..eaef5c5 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
index 88c04ad..eaef5c5 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
index 5a5b50b..e0f0981 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
index bd63c56..39ec3fd 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
index c50dbae..ba821a0 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_d5db1d "atomicAdd_d5db1d"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
index f7f54474..0a37a15 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
index 89a6a35..0c494d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
index 89a6a35..0c494d2 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
index c95c6a9..a9f59ed 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
index 62639d7..5f8945f 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
index 3dc0a5d..1f62e68 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_794055 "atomicAdd_794055"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -46,7 +46,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
index 723a113..d59a523 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
index d1179cc..99ac4aa 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
index d1179cc..99ac4aa 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
index 5a5b50b..e0f0981 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
index 04a890a..6dab262 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
index 5daee64..66a3661 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicAdd_d5db1d "atomicAdd_d5db1d"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -44,7 +44,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %20
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%23 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
index 61d34cc..5a1db0e 100644
--- a/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/literal/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
index 35cf5f1..dc1a28c 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
index 35cf5f1..dc1a28c 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.glsl
index aa80ede..5f5f012 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.msl
index b30df09..19c4023 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.spvasm
index 3d67dcf..1d07743 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.wgsl
index 27e5276..e7a62ef 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
index 8aae75d..4056d79 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
index 8aae75d..4056d79 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.glsl
index dbfc37a..7254632 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.msl
index 29c6f4b..9664a87 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.spvasm
index 1cab36f..1007451 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.wgsl
index 1ef7a33..676530e 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAdd/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
index 39a733b..8d82cb1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
index 39a733b..8d82cb1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.glsl
index 564bc63..8ff3503 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAnd_45a819();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.msl
index 962a96c..a319bdb 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAnd_45a819(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.spvasm
index 598acf2..1619f70 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.wgsl
index d757c09..7e25958 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAnd_45a819();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
index 8134062..a5b66bc 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
index 8134062..a5b66bc 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.glsl
index 2c7ded0..f0a5768 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAnd_34edd3();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.msl
index d162405..e6c7e39 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAnd_34edd3(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.spvasm
index 0eeed44..8df43d3 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.wgsl
index dba5360..08b4866 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicAnd/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAnd_34edd3();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
index e9f292a..f969d03 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -30,7 +30,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
index e9f292a..f969d03 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -30,7 +30,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
index 14a7d5a..bfa3233 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.glsl
@@ -32,7 +32,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicCompareExchangeWeak_e88938();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
index dd319d0..ce8a6a0 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.msl
@@ -33,7 +33,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_3) {
atomic_store_explicit(tint_symbol_3, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicCompareExchangeWeak_e88938(tint_symbol_3);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
index 2c9ca9f..ab70193 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.spvasm
@@ -21,7 +21,7 @@
OpMemberName %__atomic_compare_exchange_resulti32 0 "old_value"
OpMemberName %__atomic_compare_exchange_resulti32 1 "exchanged"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -76,7 +76,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %36
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%39 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
index b091a13..797f95b 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_i32.spvasm.expected.wgsl
@@ -23,7 +23,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicCompareExchangeWeak_e88938();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
index 419b817..99e867f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -30,7 +30,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
index 419b817..99e867f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -30,7 +30,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
index 8dd64fc..aeaaf5f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.glsl
@@ -32,7 +32,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicCompareExchangeWeak_83580d();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
index 4a2cafc..4590197 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.msl
@@ -33,7 +33,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_3) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_3) {
atomic_store_explicit(tint_symbol_3, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicCompareExchangeWeak_83580d(tint_symbol_3);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
index 89af02b..aae3c6c 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.spvasm
@@ -21,7 +21,7 @@
OpMemberName %__atomic_compare_exchange_resultu32 0 "old_value"
OpMemberName %__atomic_compare_exchange_resultu32 1 "exchanged"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -74,7 +74,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %34
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%37 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
index be08380..e0782fc 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicCompareExchangeWeak/workgroup_u32.spvasm.expected.wgsl
@@ -23,7 +23,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicCompareExchangeWeak_83580d();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
index 18bc9ab..af14596 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
index 18bc9ab..af14596 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.glsl
index 32a7fcc..77e50ef 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicExchange_e114ba();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.msl
index 1886d0a..bfb645d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicExchange_e114ba(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.spvasm
index e72725b..f2ba713 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.wgsl
index 555469e..a28a090 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicExchange_e114ba();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
index cef446b..6c3f1b7 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
index cef446b..6c3f1b7 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.glsl
index e4d06e3..3321d92 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicExchange_0a5dca();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.msl
index c42c47d..d805421 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicExchange_0a5dca(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.spvasm
index 6970053..1130819 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.wgsl
index 89fff60..c13602a 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicExchange/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicExchange_0a5dca();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
index 3e2674e..14e42dd 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
index 3e2674e..14e42dd 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.glsl
index 351d2dc..6596bb1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicLoad_afcc03();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.msl
index 8f6ee40..3f9bc5f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicLoad_afcc03(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.spvasm
index 829b848..f4f86f8 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicLoad_afcc03 "atomicLoad_afcc03"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -45,7 +45,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %21
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%24 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.wgsl
index af0c057..ba60171 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_i32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicLoad_afcc03();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
index 3aa482d..2eb7c6c 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
index 3aa482d..2eb7c6c 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.glsl
index 2ad60db..b21c00a 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.glsl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicLoad_361bf1();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.msl
index d7fcb6e..c9f5cd3 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.msl
@@ -8,7 +8,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicLoad_361bf1(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.spvasm
index 7a075ba..5a8a633 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicLoad_361bf1 "atomicLoad_361bf1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -43,7 +43,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %19
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%22 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.wgsl
index f132c6f..d9fd46d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicLoad/workgroup_u32.spvasm.expected.wgsl
@@ -9,7 +9,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicLoad_361bf1();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
index 3c35b63d..14fdeb1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
index 3c35b63d..14fdeb1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.glsl
index 9d9a766..28a4f50 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicMax_a89cc3();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.msl
index 7a3987d..b026733 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMax_a89cc3(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.spvasm
index 696868b..6c89567 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.wgsl
index 9086b74..85bdef4 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicMax_a89cc3();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
index d2eef23..ede6d36 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
index d2eef23..ede6d36 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.glsl
index c060e4f..1cce715 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicMax_beccfc();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.msl
index edd3102..e8951d4 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMax_beccfc(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.spvasm
index ad735e1..86df69b 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.wgsl
index e740599..fb24f1f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMax/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicMax_beccfc();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
index 686e2bb..1daa664 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
index 686e2bb..1daa664 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.glsl
index 9f7f342..91065e1 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicMin_278235();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.msl
index 8b6eeeb..ca77a67 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMin_278235(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.spvasm
index 564e8b7..edea523 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.wgsl
index e55849b..336f3d6 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicMin_278235();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
index dab7853..109dcd3 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
index dab7853..109dcd3 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.glsl
index 5dbe9c9..793a7ec 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicMin_69d383();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.msl
index 6336751..4731075 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicMin_69d383(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.spvasm
index 8c0bfde..45fb1c6 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.wgsl
index 9a15df0..ed65056 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicMin/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicMin_69d383();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
index 2c6edf2..d35a39f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
index 2c6edf2..d35a39f 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.glsl
index b9e8b77..07f565a 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicOr_d09248();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.msl
index e262929..1f405c7 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicOr_d09248(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.spvasm
index f2cdcca..b7c2f0b 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.wgsl
index f0329eb..a3edfe0 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicOr_d09248();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
index 962ffd8..530ca71 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
index 962ffd8..530ca71 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.glsl
index 42de63e..a8a6893 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicOr_5e3d61();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.msl
index 4078be6..5079e80 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicOr_5e3d61(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.spvasm
index 437d7bf..be16c4b 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.wgsl
index 781ca2e..4aaef48 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicOr/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicOr_5e3d61();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
index 068a480..136c31d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
index 068a480..136c31d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.glsl
index 927d791..33f270d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.glsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicStore_8bea94();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.msl
index 1e0fd57..ba6fa5a 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.msl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicStore_8bea94(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.spvasm
index 63e9312..eef6685 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicStore_8bea94 "atomicStore_8bea94"
OpName %arg_1 "arg_1"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -47,7 +47,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %23
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%26 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.wgsl
index 0262122..9c22f99 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_i32.spvasm.expected.wgsl
@@ -10,7 +10,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicStore_8bea94();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
index 177a508..2627136 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
index 177a508..2627136 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.glsl
index 3b5c030..0daf920 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.glsl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicStore_726882();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.msl
index fd36267..1c721e4 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.msl
@@ -9,7 +9,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicStore_726882(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.spvasm
index 2b50c09..d89a59b 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.spvasm
@@ -13,7 +13,7 @@
OpName %atomicStore_726882 "atomicStore_726882"
OpName %arg_1 "arg_1"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -45,7 +45,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %21
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%24 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.wgsl
index fa0013a..8e40180 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicStore/workgroup_u32.spvasm.expected.wgsl
@@ -10,7 +10,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicStore_726882();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
index 6e2702e..439db07 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
index 6e2702e..439db07 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.glsl
index d02e98d..89ef3a6 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicSub_77883a();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.msl
index 208e18a..7eb4abe 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicSub_77883a(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.spvasm
index 9f3a065..4f9ad41 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.wgsl
index b2781ce..e4b82db 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicSub_77883a();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
index a60453f..90e0feb 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
index a60453f..90e0feb 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.glsl
index 30e8f51..f29b936 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicSub_0d26c2();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.msl
index ec9661d..11750e7 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicSub_0d26c2(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.spvasm
index c1b5f7a..341cd2d 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.wgsl
index 77f25f7..6a11894 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicSub/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicSub_0d26c2();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
index fc1b4cc..dbe3980 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
index fc1b4cc..dbe3980 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.glsl
index bdb9b79..d13ec57 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicXor_75dc95();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.msl
index 840c318..7578844 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicXor_75dc95(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.spvasm
index 2bac01d..9296ee7 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -51,7 +51,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %24
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%27 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.wgsl
index 54490e1..6bf52a0 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_i32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicXor_75dc95();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
index 21c9ae0..32ee7a8 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
index 21c9ae0..32ee7a8 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -13,7 +13,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.glsl
index ad695ee..b786728 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.glsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicXor_c8e6be();
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.msl
index 3eb2509..6c75f1e 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.msl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicXor_c8e6be(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.spvasm
index 83c9054..db28441 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -49,7 +49,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %22
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%25 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.wgsl
index c75d808..be98d87 100644
--- a/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/atomicXor/workgroup_u32.spvasm.expected.wgsl
@@ -12,7 +12,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicXor_c8e6be();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
index f839d4c..71de2a2 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
index f839d4c..71de2a2 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
index f0f8f83..5645979 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.glsl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
index 9f11082..6c220f4 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.msl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
index 843bd5a..4263a11 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -50,7 +50,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %23
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%26 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
index 540501a..cb88afd 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_i32.spvasm.expected.wgsl
@@ -11,7 +11,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
index dff6e7e..a91fde6 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
index dff6e7e..a91fde6 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
index a59e2dc..0b00772 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.glsl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
index 74b7a0d..ca9e8e5 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.msl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
index 77041b4..81eb6af 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -48,7 +48,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %21
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%24 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
index 64dabf4..c7c9565 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicDecrement/workgroup_u32.spvasm.expected.wgsl
@@ -11,7 +11,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
index 41d2c6e..9ccc48a 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.dxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
index 41d2c6e..9ccc48a 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.fxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
int atomic_result_1 = 0;
InterlockedExchange(arg_0, 0, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
index f0f8f83..5645979 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.glsl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0);
barrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
index dc059dd..d5ea965 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.msl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_int* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_int* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_794055(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
index ed49501..e98df4a 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -50,7 +50,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %23
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%26 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %14
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
index b5076c3..4bbcf34 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_i32.spvasm.expected.wgsl
@@ -11,7 +11,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0i);
workgroupBarrier();
atomicAdd_794055();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
index 3824cc7..e86b714 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.dxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
index 3824cc7..e86b714 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.fxc.hlsl
@@ -12,7 +12,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
uint atomic_result_1 = 0u;
InterlockedExchange(arg_0, 0u, atomic_result_1);
GroupMemoryBarrierWithGroupSync();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
index a59e2dc..0b00772 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.glsl
@@ -11,7 +11,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index) {
+void compute_main_inner(uint local_invocation_index_2) {
atomicExchange(arg_0, 0u);
barrier();
atomicAdd_d5db1d();
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
index 1b33ab8..02a71ee 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.msl
@@ -10,7 +10,7 @@
return;
}
-void compute_main_inner(uint local_invocation_index, threadgroup atomic_uint* const tint_symbol_1) {
+void compute_main_inner(uint local_invocation_index_2, threadgroup atomic_uint* const tint_symbol_1) {
atomic_store_explicit(tint_symbol_1, 0u, memory_order_relaxed);
threadgroup_barrier(mem_flags::mem_threadgroup);
atomicAdd_d5db1d(tint_symbol_1);
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
index 1388894..c21ef7e5 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.spvasm
@@ -14,7 +14,7 @@
OpName %arg_1 "arg_1"
OpName %res "res"
OpName %compute_main_inner "compute_main_inner"
- OpName %local_invocation_index "local_invocation_index"
+ OpName %local_invocation_index_2 "local_invocation_index_2"
OpName %compute_main_1 "compute_main_1"
OpName %compute_main_inner_1 "compute_main_inner_1"
OpName %local_invocation_index_1_param "local_invocation_index_1_param"
@@ -48,7 +48,7 @@
OpReturn
OpFunctionEnd
%compute_main_inner = OpFunction %void None %21
-%local_invocation_index = OpFunctionParameter %uint
+%local_invocation_index_2 = OpFunctionParameter %uint
%24 = OpLabel
OpAtomicStore %arg_0 %uint_2 %uint_0 %6
OpControlBarrier %uint_2 %uint_2 %uint_264
diff --git a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
index 7faf057..26effa5 100644
--- a/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
+++ b/test/tint/builtins/atomics/from_gen/var/spvAtomicIncrement/workgroup_u32.spvasm.expected.wgsl
@@ -11,7 +11,7 @@
return;
}
-fn compute_main_inner(local_invocation_index : u32) {
+fn compute_main_inner(local_invocation_index_2 : u32) {
atomicStore(&(arg_0), 0u);
workgroupBarrier();
atomicAdd_d5db1d();
diff --git a/test/tint/vk-gl-cts/binding_model/dynamic_offset/shader_reuse_differing_layout_graphics/0.wgsl b/test/tint/vk-gl-cts/binding_model/dynamic_offset/shader_reuse_differing_layout_graphics/0.wgsl
index e77dd7d..4f0478e 100644
--- a/test/tint/vk-gl-cts/binding_model/dynamic_offset/shader_reuse_differing_layout_graphics/0.wgsl
+++ b/test/tint/vk-gl-cts/binding_model/dynamic_offset/shader_reuse_differing_layout_graphics/0.wgsl
@@ -2,7 +2,7 @@
in_color : vec4<f32>,
}
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> frag_color : vec4<f32>;
@@ -11,7 +11,7 @@
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_24 : vec4<f32> = position;
+ let x_24 : vec4<f32> = pos;
gl_Position = x_24;
let x_27 : vec4<f32> = x_8.in_color;
frag_color = x_27;
@@ -27,7 +27,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position, frag_color);
}
diff --git a/test/tint/vk-gl-cts/combined_operations/negintdivand/0-opt.wgsl b/test/tint/vk-gl-cts/combined_operations/negintdivand/0-opt.wgsl
index 98179f8..3f8e233 100644
--- a/test/tint/vk-gl-cts/combined_operations/negintdivand/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/combined_operations/negintdivand/0-opt.wgsl
@@ -1,13 +1,13 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> frag_color : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_21 : vec4<f32> = position;
+ let x_21 : vec4<f32> = pos;
gl_Position = x_21;
- let x_23 : vec4<f32> = position;
+ let x_23 : vec4<f32> = pos;
frag_color = (x_23 * 0.5);
return;
}
@@ -21,7 +21,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position, frag_color);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_equal/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_equal/0-opt.wgsl
index b3544f7..6c2aa6d 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_equal/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_equal/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.5, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_greater/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_greater/0-opt.wgsl
index 811fe59..a7b5af0 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_greater/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_greater/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.600000024, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_less/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_less/0-opt.wgsl
index ddc27e7..f86f723 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_less/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_less/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.400000006, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_not_equal/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_not_equal/0-opt.wgsl
index 396a887..1fb130c 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_not_equal/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/early_fragment/depth_not_equal/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.300000012, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_1/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_1/0-opt.wgsl
index 868da48..5804b56 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_1/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_1/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.699999988, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_2/0-opt.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_2/0-opt.wgsl
index e59c3fc..0492336 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_2/0-opt.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/graphics/execution_mode/depthgreater_2/0-opt.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec4<f32>;
+var<private> pos : vec4<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = pos;
let x_23 : vec2<f32> = vec2<f32>(x_22.x, x_22.y);
gl_Position = vec4<f32>(x_23.x, x_23.y, 0.200000003, 1.0);
return;
@@ -16,7 +16,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
diff --git a/test/tint/vk-gl-cts/spirv_assembly/instruction/spirv1p4/hlsl_functionality1/decorate_string/0.wgsl b/test/tint/vk-gl-cts/spirv_assembly/instruction/spirv1p4/hlsl_functionality1/decorate_string/0.wgsl
index 330cec1..83223c4 100644
--- a/test/tint/vk-gl-cts/spirv_assembly/instruction/spirv1p4/hlsl_functionality1/decorate_string/0.wgsl
+++ b/test/tint/vk-gl-cts/spirv_assembly/instruction/spirv1p4/hlsl_functionality1/decorate_string/0.wgsl
@@ -1,11 +1,11 @@
-var<private> position : vec4<f32>;
+var<private> vert_pos : vec4<f32>;
var<private> pos : u32;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_22 : vec4<f32> = position;
+ let x_22 : vec4<f32> = vert_pos;
gl_Position = x_22;
pos = 0u;
return;
@@ -20,7 +20,7 @@
@vertex
fn main(@location(0) position_param : vec4<f32>) -> main_out {
- position = position_param;
+ vert_pos = position_param;
main_1();
return main_out(gl_Position, pos);
}
diff --git a/test/tint/vk-gl-cts/subgroup_uniform_control_flow/discard/subgroup_reconverge_discard00/0.wgsl b/test/tint/vk-gl-cts/subgroup_uniform_control_flow/discard/subgroup_reconverge_discard00/0.wgsl
index 162c715..f7b042d 100644
--- a/test/tint/vk-gl-cts/subgroup_uniform_control_flow/discard/subgroup_reconverge_discard00/0.wgsl
+++ b/test/tint/vk-gl-cts/subgroup_uniform_control_flow/discard/subgroup_reconverge_discard00/0.wgsl
@@ -1,9 +1,9 @@
-var<private> position : vec3<f32>;
+var<private> pos : vec3<f32>;
var<private> gl_Position : vec4<f32>;
fn main_1() {
- let x_21 : vec3<f32> = position;
+ let x_21 : vec3<f32> = pos;
gl_Position = vec4<f32>(x_21.x, x_21.y, x_21.z, 1.0);
return;
}
@@ -15,7 +15,7 @@
@vertex
fn main(@location(0) position_param : vec3<f32>) -> main_out {
- position = position_param;
+ pos = position_param;
main_1();
return main_out(gl_Position);
}
