transform: Reimplement FirstIndexOffset * It didn't always produce valid WGSL (crbug.com/tint/687) * It didn't handle builtins as entry point parameters * It used hard-coded symbols that could collide * It didn't use DataMap for input. The new implementation addresses all of this. Bug: tint:687 Change-Id: I447bec530b45414ebb8baeb4ee18261d73d1c0d2 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/47222 Commit-Queue: Ben Clayton <bclayton@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com> Reviewed-by: James Price <jrprice@google.com>
diff --git a/src/program_builder.h b/src/program_builder.h index 6c728cc..5fddb56 100644 --- a/src/program_builder.h +++ b/src/program_builder.h
@@ -445,9 +445,10 @@ /// @param name the alias name /// @param type the alias type /// @returns the alias pointer - type::Alias* alias(const std::string& name, type::Type* type) const { - return builder->create<type::Alias>(builder->Symbols().Register(name), - type); + template <typename NAME> + type::Alias* alias(NAME&& name, type::Type* type) const { + return builder->create<type::Alias>( + builder->Sym(std::forward<NAME>(name)), type); } /// @return the tint AST pointer to `type` with the given ast::StorageClass @@ -469,9 +470,10 @@ /// @param name the struct name /// @param impl the struct implementation /// @returns a struct pointer - type::Struct* struct_(const std::string& name, ast::Struct* impl) const { - return builder->create<type::Struct>(builder->Symbols().Register(name), - impl); + template <typename NAME> + type::Struct* struct_(NAME&& name, ast::Struct* impl) const { + return builder->create<type::Struct>( + builder->Sym(std::forward<NAME>(name)), impl); } private: @@ -1075,13 +1077,14 @@ /// @param members the struct members /// @param decorations the optional struct decorations /// @returns the struct type + template <typename NAME> type::Struct* Structure(const Source& source, - const std::string& name, + NAME&& name, ast::StructMemberList members, ast::DecorationList decorations = {}) { auto* impl = create<ast::Struct>(source, std::move(members), std::move(decorations)); - auto* type = ty.struct_(name, impl); + auto* type = ty.struct_(Sym(std::forward<NAME>(name)), impl); AST().AddConstructedType(type); return type; } @@ -1092,12 +1095,13 @@ /// @param members the struct members /// @param decorations the optional struct decorations /// @returns the struct type - type::Struct* Structure(const std::string& name, + template <typename NAME> + type::Struct* Structure(NAME&& name, ast::StructMemberList members, ast::DecorationList decorations = {}) { auto* impl = create<ast::Struct>(std::move(members), std::move(decorations)); - auto* type = ty.struct_(name, impl); + auto* type = ty.struct_(Sym(std::forward<NAME>(name)), impl); AST().AddConstructedType(type); return type; }
diff --git a/src/transform/first_index_offset.cc b/src/transform/first_index_offset.cc index 3766e01..a1adf66 100644 --- a/src/transform/first_index_offset.cc +++ b/src/transform/first_index_offset.cc
@@ -15,40 +15,34 @@ #include "src/transform/first_index_offset.h" #include <memory> +#include <unordered_map> #include <utility> #include "src/ast/struct_block_decoration.h" #include "src/program_builder.h" #include "src/semantic/function.h" +#include "src/semantic/member_accessor_expression.h" +#include "src/semantic/struct.h" +#include "src/semantic/variable.h" +TINT_INSTANTIATE_TYPEINFO(tint::transform::FirstIndexOffset::BindingPoint); TINT_INSTANTIATE_TYPEINFO(tint::transform::FirstIndexOffset::Data); namespace tint { namespace transform { namespace { -constexpr char kStructName[] = "TintFirstIndexOffsetData"; -constexpr char kBufferName[] = "tint_first_index_data"; -constexpr char kFirstVertexName[] = "tint_first_vertex_index"; -constexpr char kFirstInstanceName[] = "tint_first_instance_index"; -constexpr char kIndexOffsetPrefix[] = "tint_first_index_offset_"; - -ast::Variable* clone_variable_with_new_name(CloneContext* ctx, - ast::Variable* in, - std::string new_name) { - // Clone arguments outside of create() call to have deterministic ordering - auto source = ctx->Clone(in->source()); - auto symbol = ctx->dst->Symbols().Register(new_name); - auto* type = ctx->Clone(in->declared_type()); - auto* constructor = ctx->Clone(in->constructor()); - auto decorations = ctx->Clone(in->decorations()); - return ctx->dst->create<ast::Variable>( - source, symbol, in->declared_storage_class(), type, in->is_const(), - constructor, decorations); -} +// Uniform buffer member names +constexpr char kFirstVertexName[] = "first_vertex_index"; +constexpr char kFirstInstanceName[] = "first_instance_index"; } // namespace +FirstIndexOffset::BindingPoint::BindingPoint() = default; +FirstIndexOffset::BindingPoint::BindingPoint(uint32_t b, uint32_t g) + : binding(b), group(g) {} +FirstIndexOffset::BindingPoint::~BindingPoint() = default; + FirstIndexOffset::Data::Data(bool has_vtx_index, bool has_inst_index, uint32_t first_vtx_offset, @@ -57,172 +51,134 @@ has_instance_index(has_inst_index), first_vertex_offset(first_vtx_offset), first_instance_offset(first_inst_offset) {} - FirstIndexOffset::Data::Data(const Data&) = default; - FirstIndexOffset::Data::~Data() = default; +FirstIndexOffset::FirstIndexOffset() = default; FirstIndexOffset::FirstIndexOffset(uint32_t binding, uint32_t group) : binding_(binding), group_(group) {} FirstIndexOffset::~FirstIndexOffset() = default; -Transform::Output FirstIndexOffset::Run(const Program* in, const DataMap&) { - ProgramBuilder out; - - // First do a quick check to see if the transform has already been applied. - for (ast::Variable* var : in->AST().GlobalVariables()) { - if (auto* dec_var = var->As<ast::Variable>()) { - if (dec_var->symbol() == in->Symbols().Get(kBufferName)) { - out.Diagnostics().add_error( - "First index offset transform has already been applied."); - return Output(Program(std::move(out))); - } - } +Transform::Output FirstIndexOffset::Run(const Program* in, + const DataMap& data) { + // Get the uniform buffer binding point + uint32_t ub_binding = binding_; + uint32_t ub_group = group_; + if (auto* binding_point = data.Get<BindingPoint>()) { + ub_binding = binding_point->binding; + ub_group = binding_point->group; } - State state{&out, binding_, group_}; - - Symbol vertex_index_sym; - Symbol instance_index_sym; - - // Lazily construct the UniformBuffer on first call to - // maybe_create_buffer_var() - ast::Variable* buffer_var = nullptr; - auto maybe_create_buffer_var = [&]() { - if (buffer_var == nullptr) { - buffer_var = state.AddUniformBuffer(); - } - }; - - // Clone the AST, renaming the kVertexIndex and kInstanceIndex builtins, and - // add a CreateFirstIndexOffset() statement to each function that uses one of - // these builtins. - + ProgramBuilder out; CloneContext ctx(&out, in); - ctx.ReplaceAll([&](ast::Variable* var) -> ast::Variable* { - for (ast::Decoration* dec : var->decorations()) { - if (auto* blt_dec = dec->As<ast::BuiltinDecoration>()) { - ast::Builtin blt_type = blt_dec->value(); - if (blt_type == ast::Builtin::kVertexIndex) { - vertex_index_sym = var->symbol(); - state.has_vertex_index = true; - return clone_variable_with_new_name( - &ctx, var, - kIndexOffsetPrefix + in->Symbols().NameFor(var->symbol())); - } else if (blt_type == ast::Builtin::kInstanceIndex) { - instance_index_sym = var->symbol(); - state.has_instance_index = true; - return clone_variable_with_new_name( - &ctx, var, - kIndexOffsetPrefix + in->Symbols().NameFor(var->symbol())); - } - } - } - return nullptr; // Just clone var - }); - ctx.ReplaceAll( // Note: This happens in the same pass as the rename above - // which determines the original builtin variable names, - // but this should be fine, as variables are cloned first. - [&](ast::Function* func) -> ast::Function* { - maybe_create_buffer_var(); - if (buffer_var == nullptr) { - return nullptr; // no transform need, just clone func - } - auto* func_sem = in->Sem().Get(func); - ast::StatementList statements; - for (const auto& data : func_sem->LocalReferencedBuiltinVariables()) { - if (data.second->value() == ast::Builtin::kVertexIndex) { - statements.emplace_back(state.CreateFirstIndexOffset( - in->Symbols().NameFor(vertex_index_sym), kFirstVertexName, - buffer_var)); - } else if (data.second->value() == ast::Builtin::kInstanceIndex) { - statements.emplace_back(state.CreateFirstIndexOffset( - in->Symbols().NameFor(instance_index_sym), kFirstInstanceName, - buffer_var)); + + // Map of builtin usages + std::unordered_map<const semantic::Variable*, const char*> builtin_vars; + std::unordered_map<const semantic::StructMember*, const char*> + builtin_members; + + bool has_vertex_index = false; + bool has_instance_index = false; + + // Traverse the AST scanning for builtin accesses via variables (includes + // parameters) or structure member accesses. + for (auto* node : in->ASTNodes().Objects()) { + if (auto* var = node->As<ast::Variable>()) { + for (ast::Decoration* dec : var->decorations()) { + if (auto* builtin_dec = dec->As<ast::BuiltinDecoration>()) { + ast::Builtin builtin = builtin_dec->value(); + if (builtin == ast::Builtin::kVertexIndex) { + auto* sem_var = ctx.src->Sem().Get(var); + builtin_vars.emplace(sem_var, kFirstVertexName); + has_vertex_index = true; + } + if (builtin == ast::Builtin::kInstanceIndex) { + auto* sem_var = ctx.src->Sem().Get(var); + builtin_vars.emplace(sem_var, kFirstInstanceName); + has_instance_index = true; } } - return CloneWithStatementsAtStart(&ctx, func, statements); - }); + } + } + if (auto* member = node->As<ast::StructMember>()) { + for (ast::Decoration* dec : member->decorations()) { + if (auto* builtin_dec = dec->As<ast::BuiltinDecoration>()) { + ast::Builtin builtin = builtin_dec->value(); + if (builtin == ast::Builtin::kVertexIndex) { + auto* sem_mem = ctx.src->Sem().Get(member); + builtin_members.emplace(sem_mem, kFirstVertexName); + has_vertex_index = true; + } + if (builtin == ast::Builtin::kInstanceIndex) { + auto* sem_mem = ctx.src->Sem().Get(member); + builtin_members.emplace(sem_mem, kFirstInstanceName); + has_instance_index = true; + } + } + } + } + } + + // Byte offsets on the uniform buffer + uint32_t vertex_index_offset = 0; + uint32_t instance_index_offset = 0; + + if (has_vertex_index || has_instance_index) { + // Add uniform buffer members and calculate byte offsets + uint32_t offset = 0; + ast::StructMemberList members; + if (has_vertex_index) { + members.push_back(ctx.dst->Member(kFirstVertexName, ctx.dst->ty.u32())); + vertex_index_offset = offset; + offset += 4; + } + if (has_instance_index) { + members.push_back(ctx.dst->Member(kFirstInstanceName, ctx.dst->ty.u32())); + instance_index_offset = offset; + offset += 4; + } + auto* struct_type = + ctx.dst->Structure(ctx.dst->Symbols().New(), std::move(members), + {ctx.dst->create<ast::StructBlockDecoration>()}); + + // Create a global to hold the uniform buffer + Symbol buffer_name = ctx.dst->Symbols().New(); + ctx.dst->Global(buffer_name, struct_type, ast::StorageClass::kUniform, + nullptr, + ast::DecorationList{ + ctx.dst->create<ast::BindingDecoration>(ub_binding), + ctx.dst->create<ast::GroupDecoration>(ub_group), + }); + + // Fix up all references to the builtins with the offsets + ctx.ReplaceAll([=, &ctx](ast::Expression* expr) -> ast::Expression* { + auto* sem = ctx.src->Sem().Get(expr); + if (auto* user = sem->As<semantic::VariableUser>()) { + auto it = builtin_vars.find(user->Variable()); + if (it != builtin_vars.end()) { + return ctx.dst->Add(ctx.CloneWithoutTransform(expr), + ctx.dst->MemberAccessor(buffer_name, it->second)); + } + } + if (auto* access = sem->As<semantic::StructMemberAccess>()) { + auto it = builtin_members.find(access->Member()); + if (it != builtin_members.end()) { + return ctx.dst->Add(ctx.CloneWithoutTransform(expr), + ctx.dst->MemberAccessor(buffer_name, it->second)); + } + } + // Not interested in this experssion. Just clone. + return nullptr; + }); + } + ctx.Clone(); - return Output(Program(std::move(out)), - std::make_unique<Data>( - state.has_vertex_index, state.has_instance_index, - state.vertex_index_offset, state.instance_index_offset)); -} - -ast::Variable* FirstIndexOffset::State::AddUniformBuffer() { - auto* u32_type = dst->create<type::U32>(); - uint32_t offset = 0; - ast::StructMemberList members; - if (has_vertex_index) { - members.push_back(dst->create<ast::StructMember>( - Source{}, dst->Symbols().Register(kFirstVertexName), u32_type, - ast::DecorationList{})); - vertex_index_offset = offset; - offset += 4; - } - - if (has_instance_index) { - members.push_back(dst->create<ast::StructMember>( - Source{}, dst->Symbols().Register(kFirstInstanceName), u32_type, - ast::DecorationList{})); - instance_index_offset = offset; - offset += 4; - } - - ast::DecorationList decos; - decos.push_back(dst->create<ast::StructBlockDecoration>(Source{})); - - auto* struct_type = dst->create<type::Struct>( - dst->Symbols().Register(kStructName), - dst->create<ast::Struct>(Source{}, std::move(members), std::move(decos))); - - auto* idx_var = dst->create<ast::Variable>( - Source{}, // source - dst->Symbols().Register(kBufferName), // symbol - ast::StorageClass::kUniform, // storage_class - struct_type, // type - false, // is_const - nullptr, // constructor - ast::DecorationList{ - dst->create<ast::BindingDecoration>(Source{}, binding), - dst->create<ast::GroupDecoration>(Source{}, group), - }); - - dst->AST().AddConstructedType(struct_type); - - dst->AST().AddGlobalVariable(idx_var); - - return idx_var; -} - -ast::VariableDeclStatement* FirstIndexOffset::State::CreateFirstIndexOffset( - const std::string& original_name, - const std::string& field_name, - ast::Variable* buffer_var) { - auto* buffer = - dst->create<ast::IdentifierExpression>(Source{}, buffer_var->symbol()); - - auto lhs_name = kIndexOffsetPrefix + original_name; - auto* constructor = dst->create<ast::BinaryExpression>( - Source{}, ast::BinaryOp::kAdd, - dst->create<ast::IdentifierExpression>(Source{}, - dst->Symbols().Register(lhs_name)), - dst->create<ast::MemberAccessorExpression>( - Source{}, buffer, - dst->create<ast::IdentifierExpression>( - Source{}, dst->Symbols().Register(field_name)))); - auto* var = dst->create<ast::Variable>( - Source{}, // source - dst->Symbols().Register(original_name), // symbol - ast::StorageClass::kNone, // storage_class - dst->create<type::U32>(), // type - true, // is_const - constructor, // constructor - ast::DecorationList{}); // decorations - return dst->create<ast::VariableDeclStatement>(Source{}, var); + return Output( + Program(std::move(out)), + std::make_unique<Data>(has_vertex_index, has_instance_index, + vertex_index_offset, instance_index_offset)); } } // namespace transform
diff --git a/src/transform/first_index_offset.h b/src/transform/first_index_offset.h index ed092fb..7f819bc 100644 --- a/src/transform/first_index_offset.h +++ b/src/transform/first_index_offset.h
@@ -15,9 +15,6 @@ #ifndef SRC_TRANSFORM_FIRST_INDEX_OFFSET_H_ #define SRC_TRANSFORM_FIRST_INDEX_OFFSET_H_ -#include <string> - -#include "src/ast/variable_decl_statement.h" #include "src/transform/transform.h" namespace tint { @@ -60,6 +57,27 @@ /// class FirstIndexOffset : public Transform { public: + /// BindingPoint is consumed by the FirstIndexOffset transform. + /// BindingPoint specifies the binding point of the first index uniform + /// buffer. + struct BindingPoint : public Castable<BindingPoint, transform::Data> { + /// Constructor + BindingPoint(); + + /// Constructor + /// @param b the binding index + /// @param g the binding group + BindingPoint(uint32_t b, uint32_t g); + + /// Destructor + ~BindingPoint() override; + + /// [[binding()]] for the first vertex / first instance uniform buffer + uint32_t binding = 0; + /// [[group()]] for the first vertex / first instance uniform buffer + uint32_t group = 0; + }; + /// Data is outputted by the FirstIndexOffset transform. /// Data holds information about shader usage and constant buffer offsets. struct Data : public Castable<Data, transform::Data> { @@ -90,6 +108,9 @@ }; /// Constructor + FirstIndexOffset(); + /// Constructor + /// [DEPRECATED] - pass BindingPoint as part of the `data` to Run() /// @param binding the binding() for firstVertex/Instance uniform /// @param group the group() for firstVertex/Instance uniform FirstIndexOffset(uint32_t binding, uint32_t group); @@ -102,32 +123,10 @@ Output Run(const Program* program, const DataMap& data = {}) override; private: - struct State { - /// Adds uniform buffer with firstVertex/Instance to the program builder - /// @returns variable of new uniform buffer - ast::Variable* AddUniformBuffer(); - /// Adds constant with modified original_name builtin to func - /// @param original_name the name of the original builtin used in function - /// @param field_name name of field in firstVertex/Instance buffer - /// @param buffer_var variable of firstVertex/Instance buffer - ast::VariableDeclStatement* CreateFirstIndexOffset( - const std::string& original_name, - const std::string& field_name, - ast::Variable* buffer_var); - - ProgramBuilder* const dst; - uint32_t const binding; - uint32_t const group; - - bool has_vertex_index = false; - bool has_instance_index = false; - uint32_t vertex_index_offset = 0; - uint32_t instance_index_offset = 0; - }; - - uint32_t binding_; - uint32_t group_; + uint32_t binding_ = 0; + uint32_t group_ = 0; }; + } // namespace transform } // namespace tint
diff --git a/src/transform/first_index_offset_test.cc b/src/transform/first_index_offset_test.cc index ccfecf9..2a9b075 100644 --- a/src/transform/first_index_offset_test.cc +++ b/src/transform/first_index_offset_test.cc
@@ -26,45 +26,13 @@ using FirstIndexOffsetTest = TransformTest; -TEST_F(FirstIndexOffsetTest, Error_AlreadyTransformed) { - auto* src = R"( -[[builtin(vertex_index)]] var<in> vert_idx : u32; - -fn test() -> u32 { - return vert_idx; -} - -[[stage(vertex)]] -fn entry() { - test(); -} -)"; - - auto* expect = - "error: First index offset transform has already been applied."; - - std::vector<std::unique_ptr<transform::Transform>> transforms; - transforms.emplace_back(std::make_unique<FirstIndexOffset>(0, 0)); - transforms.emplace_back(std::make_unique<FirstIndexOffset>(1, 1)); - - auto got = Run(src, std::move(transforms)); - - EXPECT_EQ(expect, str(got)); - - auto* data = got.data.Get<FirstIndexOffset::Data>(); - - ASSERT_NE(data, nullptr); - EXPECT_EQ(data->has_vertex_index, true); - EXPECT_EQ(data->has_instance_index, false); - EXPECT_EQ(data->first_vertex_offset, 0u); - EXPECT_EQ(data->first_instance_offset, 0u); -} - TEST_F(FirstIndexOffsetTest, EmptyModule) { auto* src = ""; auto* expect = ""; - auto got = Run(src, std::make_unique<FirstIndexOffset>(0, 0)); + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(0, 0); + auto got = Run<FirstIndexOffset>(src, std::move(config)); EXPECT_EQ(expect, str(got)); @@ -79,6 +47,273 @@ TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex) { auto* src = R"( +fn test(vert_idx : u32) -> u32 { + return vert_idx; +} + +[[stage(vertex)]] +fn entry([[builtin(vertex_index)]] vert_idx : u32) { + test(vert_idx); +} +)"; + + auto* expect = R"( +[[block]] +struct tint_symbol_2 { + first_vertex_index : u32; +}; + +[[binding(1), group(2)]] var<uniform> tint_symbol_3 : tint_symbol_2; + +fn test(vert_idx : u32) -> u32 { + return vert_idx; +} + +[[stage(vertex)]] +fn entry([[builtin(vertex_index)]] vert_idx : u32) { + test((vert_idx + tint_symbol_3.first_vertex_index)); +} +)"; + + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(1, 2); + auto got = Run<FirstIndexOffset>(src, std::move(config)); + + EXPECT_EQ(expect, str(got)); + + auto* data = got.data.Get<FirstIndexOffset::Data>(); + + ASSERT_NE(data, nullptr); + EXPECT_EQ(data->has_vertex_index, true); + EXPECT_EQ(data->has_instance_index, false); + EXPECT_EQ(data->first_vertex_offset, 0u); + EXPECT_EQ(data->first_instance_offset, 0u); +} + +TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) { + auto* src = R"( +fn test(inst_idx : u32) -> u32 { + return inst_idx; +} + +[[stage(vertex)]] +fn entry([[builtin(instance_index)]] inst_idx : u32) { + test(inst_idx); +} +)"; + + auto* expect = R"( +[[block]] +struct tint_symbol_2 { + first_instance_index : u32; +}; + +[[binding(1), group(7)]] var<uniform> tint_symbol_3 : tint_symbol_2; + +fn test(inst_idx : u32) -> u32 { + return inst_idx; +} + +[[stage(vertex)]] +fn entry([[builtin(instance_index)]] inst_idx : u32) { + test((inst_idx + tint_symbol_3.first_instance_index)); +} +)"; + + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(1, 7); + auto got = Run<FirstIndexOffset>(src, std::move(config)); + + EXPECT_EQ(expect, str(got)); + + auto* data = got.data.Get<FirstIndexOffset::Data>(); + + ASSERT_NE(data, nullptr); + EXPECT_EQ(data->has_vertex_index, false); + EXPECT_EQ(data->has_instance_index, true); + EXPECT_EQ(data->first_vertex_offset, 0u); + EXPECT_EQ(data->first_instance_offset, 0u); +} + +TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex) { + auto* src = R"( +fn test(instance_idx : u32, vert_idx : u32) -> u32 { + return instance_idx + vert_idx; +} + +struct Inputs { + [[builtin(instance_index)]] instance_idx : u32; + [[builtin(vertex_index)]] vert_idx : u32; +}; + +[[stage(vertex)]] +fn entry(inputs : Inputs) { + test(inputs.instance_idx, inputs.vert_idx); +} +)"; + + auto* expect = R"( +[[block]] +struct tint_symbol_3 { + first_vertex_index : u32; + first_instance_index : u32; +}; + +[[binding(1), group(2)]] var<uniform> tint_symbol_4 : tint_symbol_3; + +fn test(instance_idx : u32, vert_idx : u32) -> u32 { + return (instance_idx + vert_idx); +} + +struct Inputs { + [[builtin(instance_index)]] + instance_idx : u32; + [[builtin(vertex_index)]] + vert_idx : u32; +}; + +[[stage(vertex)]] +fn entry(inputs : Inputs) { + test((inputs.instance_idx + tint_symbol_4.first_instance_index), (inputs.vert_idx + tint_symbol_4.first_vertex_index)); +} +)"; + + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(1, 2); + auto got = Run<FirstIndexOffset>(src, std::move(config)); + + EXPECT_EQ(expect, str(got)); + + auto* data = got.data.Get<FirstIndexOffset::Data>(); + + ASSERT_NE(data, nullptr); + EXPECT_EQ(data->has_vertex_index, true); + EXPECT_EQ(data->has_instance_index, true); + EXPECT_EQ(data->first_vertex_offset, 0u); + EXPECT_EQ(data->first_instance_offset, 4u); +} + +TEST_F(FirstIndexOffsetTest, NestedCalls) { + auto* src = R"( +fn func1(vert_idx : u32) -> u32 { + return vert_idx; +} + +fn func2(vert_idx : u32) -> u32 { + return func1(vert_idx); +} + +[[stage(vertex)]] +fn entry([[builtin(vertex_index)]] vert_idx : u32) { + func2(vert_idx); +} +)"; + + auto* expect = R"( +[[block]] +struct tint_symbol_2 { + first_vertex_index : u32; +}; + +[[binding(1), group(2)]] var<uniform> tint_symbol_3 : tint_symbol_2; + +fn func1(vert_idx : u32) -> u32 { + return vert_idx; +} + +fn func2(vert_idx : u32) -> u32 { + return func1(vert_idx); +} + +[[stage(vertex)]] +fn entry([[builtin(vertex_index)]] vert_idx : u32) { + func2((vert_idx + tint_symbol_3.first_vertex_index)); +} +)"; + + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(1, 2); + auto got = Run<FirstIndexOffset>(src, std::move(config)); + + EXPECT_EQ(expect, str(got)); + + auto* data = got.data.Get<FirstIndexOffset::Data>(); + + ASSERT_NE(data, nullptr); + EXPECT_EQ(data->has_vertex_index, true); + EXPECT_EQ(data->has_instance_index, false); + EXPECT_EQ(data->first_vertex_offset, 0u); + EXPECT_EQ(data->first_instance_offset, 0u); +} + +TEST_F(FirstIndexOffsetTest, MultipleEntryPoints) { + auto* src = R"( +fn func(i : u32) -> u32 { + return i; +} + +[[stage(vertex)]] +fn entry_a([[builtin(vertex_index)]] vert_idx : u32) { + func(vert_idx); +} + +[[stage(vertex)]] +fn entry_b([[builtin(vertex_index)]] vert_idx : u32, [[builtin(instance_index)]] inst_idx : u32) { + func(vert_idx + inst_idx); +} + +[[stage(vertex)]] +fn entry_c([[builtin(instance_index)]] inst_idx : u32) { + func(inst_idx); +} +)"; + + auto* expect = R"( +[[block]] +struct tint_symbol_3 { + first_vertex_index : u32; + first_instance_index : u32; +}; + +[[binding(1), group(2)]] var<uniform> tint_symbol_4 : tint_symbol_3; + +fn func(i : u32) -> u32 { + return i; +} + +[[stage(vertex)]] +fn entry_a([[builtin(vertex_index)]] vert_idx : u32) { + func((vert_idx + tint_symbol_4.first_vertex_index)); +} + +[[stage(vertex)]] +fn entry_b([[builtin(vertex_index)]] vert_idx : u32, [[builtin(instance_index)]] inst_idx : u32) { + func(((vert_idx + tint_symbol_4.first_vertex_index) + (inst_idx + tint_symbol_4.first_instance_index))); +} + +[[stage(vertex)]] +fn entry_c([[builtin(instance_index)]] inst_idx : u32) { + func((inst_idx + tint_symbol_4.first_instance_index)); +} +)"; + + DataMap config; + config.Add<FirstIndexOffset::BindingPoint>(1, 2); + auto got = Run<FirstIndexOffset>(src, std::move(config)); + + EXPECT_EQ(expect, str(got)); + + auto* data = got.data.Get<FirstIndexOffset::Data>(); + + ASSERT_NE(data, nullptr); + EXPECT_EQ(data->has_vertex_index, true); + EXPECT_EQ(data->has_instance_index, true); + EXPECT_EQ(data->first_vertex_offset, 0u); + EXPECT_EQ(data->first_instance_offset, 4u); +} + +TEST_F(FirstIndexOffsetTest, OLD_BasicModuleVertexIndex) { + auto* src = R"( [[builtin(vertex_index)]] var<in> vert_idx : u32; fn test() -> u32 { @@ -93,17 +328,16 @@ auto* expect = R"( [[block]] -struct TintFirstIndexOffsetData { - tint_first_vertex_index : u32; +struct tint_symbol_2 { + first_vertex_index : u32; }; -[[binding(1), group(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData; +[[binding(1), group(2)]] var<uniform> tint_symbol_3 : tint_symbol_2; -[[builtin(vertex_index)]] var<in> tint_first_index_offset_vert_idx : u32; +[[builtin(vertex_index)]] var<in> vert_idx : u32; fn test() -> u32 { - let vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index); - return vert_idx; + return (vert_idx + tint_symbol_3.first_vertex_index); } [[stage(vertex)]] @@ -125,7 +359,7 @@ EXPECT_EQ(data->first_instance_offset, 0u); } -TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) { +TEST_F(FirstIndexOffsetTest, OLD_BasicModuleInstanceIndex) { auto* src = R"( [[builtin(instance_index)]] var<in> inst_idx : u32; @@ -141,17 +375,16 @@ auto* expect = R"( [[block]] -struct TintFirstIndexOffsetData { - tint_first_instance_index : u32; +struct tint_symbol_2 { + first_instance_index : u32; }; -[[binding(1), group(7)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData; +[[binding(1), group(7)]] var<uniform> tint_symbol_3 : tint_symbol_2; -[[builtin(instance_index)]] var<in> tint_first_index_offset_inst_idx : u32; +[[builtin(instance_index)]] var<in> inst_idx : u32; fn test() -> u32 { - let inst_idx : u32 = (tint_first_index_offset_inst_idx + tint_first_index_data.tint_first_instance_index); - return inst_idx; + return (inst_idx + tint_symbol_3.first_instance_index); } [[stage(vertex)]] @@ -173,7 +406,7 @@ EXPECT_EQ(data->first_instance_offset, 0u); } -TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex) { +TEST_F(FirstIndexOffsetTest, OLD_BasicModuleBothIndex) { auto* src = R"( [[builtin(instance_index)]] var<in> instance_idx : u32; [[builtin(vertex_index)]] var<in> vert_idx : u32; @@ -190,21 +423,19 @@ auto* expect = R"( [[block]] -struct TintFirstIndexOffsetData { - tint_first_vertex_index : u32; - tint_first_instance_index : u32; +struct tint_symbol_3 { + first_vertex_index : u32; + first_instance_index : u32; }; -[[binding(1), group(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData; +[[binding(1), group(2)]] var<uniform> tint_symbol_4 : tint_symbol_3; -[[builtin(instance_index)]] var<in> tint_first_index_offset_instance_idx : u32; +[[builtin(instance_index)]] var<in> instance_idx : u32; -[[builtin(vertex_index)]] var<in> tint_first_index_offset_vert_idx : u32; +[[builtin(vertex_index)]] var<in> vert_idx : u32; fn test() -> u32 { - let instance_idx : u32 = (tint_first_index_offset_instance_idx + tint_first_index_data.tint_first_instance_index); - let vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index); - return (instance_idx + vert_idx); + return ((instance_idx + tint_symbol_4.first_instance_index) + (vert_idx + tint_symbol_4.first_vertex_index)); } [[stage(vertex)]] @@ -226,7 +457,7 @@ EXPECT_EQ(data->first_instance_offset, 4u); } -TEST_F(FirstIndexOffsetTest, NestedCalls) { +TEST_F(FirstIndexOffsetTest, OLD_NestedCalls) { auto* src = R"( [[builtin(vertex_index)]] var<in> vert_idx : u32; @@ -246,17 +477,16 @@ auto* expect = R"( [[block]] -struct TintFirstIndexOffsetData { - tint_first_vertex_index : u32; +struct tint_symbol_2 { + first_vertex_index : u32; }; -[[binding(1), group(2)]] var<uniform> tint_first_index_data : TintFirstIndexOffsetData; +[[binding(1), group(2)]] var<uniform> tint_symbol_3 : tint_symbol_2; -[[builtin(vertex_index)]] var<in> tint_first_index_offset_vert_idx : u32; +[[builtin(vertex_index)]] var<in> vert_idx : u32; fn func1() -> u32 { - let vert_idx : u32 = (tint_first_index_offset_vert_idx + tint_first_index_data.tint_first_vertex_index); - return vert_idx; + return (vert_idx + tint_symbol_3.first_vertex_index); } fn func2() -> u32 {