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

Move BuiltinValue to builtin/ 

This CL moves the BuiltinValue enum to the builtin/ folder.

Change-Id: I9db5128c1bc272e8e8d5181d629e6724ac38322e
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/120361
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
This commit is contained in:
dan sinclair 2023-02-17 21:56:35 +00:00 committed by Dawn LUCI CQ
parent 32cb509307
commit 6392579ee1
62 changed files with 530 additions and 480 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/tint/BUILD.gn
View File

@ -431,6 +431,7 @@ libtint_source_set("libtint_transform_src") {
deps = [ deps = [
":libtint_ast_src", ":libtint_ast_src",
":libtint_base_src", ":libtint_base_src",
":libtint_builtins_src",
":libtint_program_src", ":libtint_program_src",
":libtint_sem_src", ":libtint_sem_src",
":libtint_text_src", ":libtint_text_src",
@ -452,7 +453,6 @@ libtint_source_set("libtint_ast_hdrs") {
"ast/break_if_statement.h", "ast/break_if_statement.h",
"ast/break_statement.h", "ast/break_statement.h",
"ast/builtin_attribute.h", "ast/builtin_attribute.h",
"ast/builtin_value.h",
"ast/call_expression.h", "ast/call_expression.h",
"ast/call_statement.h", "ast/call_statement.h",
"ast/case_selector.h", "ast/case_selector.h",
@ -519,6 +519,7 @@ libtint_source_set("libtint_ast_hdrs") {
] ]
deps = [ deps = [
":libtint_base_src", ":libtint_base_src",
":libtint_builtins_src",
":libtint_clone_context_hdrs", ":libtint_clone_context_hdrs",
":libtint_type_src", ":libtint_type_src",
] ]
@ -538,7 +539,6 @@ libtint_source_set("libtint_ast_src") {
"ast/break_if_statement.cc", "ast/break_if_statement.cc",
"ast/break_statement.cc", "ast/break_statement.cc",
"ast/builtin_attribute.cc", "ast/builtin_attribute.cc",
"ast/builtin_value.cc",
"ast/call_expression.cc", "ast/call_expression.cc",
"ast/call_statement.cc", "ast/call_statement.cc",
"ast/case_selector.cc", "ast/case_selector.cc",
@ -690,6 +690,13 @@ libtint_source_set("libtint_sem_src") {
] ]
} }
libtint_source_set("libtint_builtins_src") {
sources = [
"builtin/builtin_value.cc",
"builtin/builtin_value.h",
]
}
libtint_source_set("libtint_type_src") { libtint_source_set("libtint_type_src") {
sources = [ sources = [
"type/abstract_float.cc", "type/abstract_float.cc",
@ -826,6 +833,7 @@ libtint_source_set("libtint_spv_reader_src") {
deps = [ deps = [
":libtint_ast_src", ":libtint_ast_src",
":libtint_base_src", ":libtint_base_src",
":libtint_builtins_src",
":libtint_program_src", ":libtint_program_src",
":libtint_reader_src", ":libtint_reader_src",
":libtint_sem_src", ":libtint_sem_src",
@ -1212,7 +1220,6 @@ if (tint_build_unittests) {
"ast/builtin_attribute_test.cc", "ast/builtin_attribute_test.cc",
"ast/builtin_texture_helper_test.cc", "ast/builtin_texture_helper_test.cc",
"ast/builtin_texture_helper_test.h", "ast/builtin_texture_helper_test.h",
"ast/builtin_value_test.cc",
"ast/call_expression_test.cc", "ast/call_expression_test.cc",
"ast/call_statement_test.cc", "ast/call_statement_test.cc",
"ast/case_selector_test.cc", "ast/case_selector_test.cc",
@ -1274,6 +1281,11 @@ if (tint_build_unittests) {
} }
} }
tint_unittests_source_set("tint_unittests_builtins_src") {
sources = [ "builtin/builtin_value_test.cc" ]
deps = [ ":libtint_builtins_src" ]
}
tint_unittests_source_set("tint_unittests_diagnostic_src") { tint_unittests_source_set("tint_unittests_diagnostic_src") {
sources = [ sources = [
"diagnostic/diagnostic_test.cc", "diagnostic/diagnostic_test.cc",
@ -1614,6 +1626,7 @@ if (tint_build_unittests) {
deps = [ deps = [
":libtint_base_src", ":libtint_base_src",
":libtint_builtins_src",
":libtint_spv_writer_src", ":libtint_spv_writer_src",
":tint_unittests_ast_src", ":tint_unittests_ast_src",
"${tint_spirv_tools_dir}/:spvtools", "${tint_spirv_tools_dir}/:spvtools",
@ -1931,6 +1944,7 @@ if (tint_build_unittests) {
":libtint_wgsl_writer_src", ":libtint_wgsl_writer_src",
":tint_unittests_ast_src", ":tint_unittests_ast_src",
":tint_unittests_base_src", ":tint_unittests_base_src",
":tint_unittests_builtins_src",
":tint_unittests_constant_src", ":tint_unittests_constant_src",
":tint_unittests_core_src", ":tint_unittests_core_src",
":tint_unittests_demangler_src", ":tint_unittests_demangler_src",

2
src/tint/CMakeLists.txt
View File

@ -548,7 +548,7 @@ list(APPEND TINT_LIB_SRCS
writer/writer.h writer/writer.h
) )
tint_generated(ast/builtin_value BENCH TEST) tint_generated(builtin/builtin_value BENCH TEST)
tint_generated(ast/diagnostic_control BENCH TEST) tint_generated(ast/diagnostic_control BENCH TEST)
tint_generated(ast/extension BENCH TEST) tint_generated(ast/extension BENCH TEST)
tint_generated(ast/interpolate_attribute BENCH TEST) tint_generated(ast/interpolate_attribute BENCH TEST)

5
src/tint/ast/builtin_attribute.cc
View File

@ -22,7 +22,10 @@ TINT_INSTANTIATE_TYPEINFO(tint::ast::BuiltinAttribute);
namespace tint::ast { namespace tint::ast {
BuiltinAttribute::BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, BuiltinValue b) BuiltinAttribute::BuiltinAttribute(ProgramID pid,
NodeID nid,
const Source& src,
builtin::BuiltinValue b)
: Base(pid, nid, src), builtin(b) {} : Base(pid, nid, src), builtin(b) {}
BuiltinAttribute::~BuiltinAttribute() = default; BuiltinAttribute::~BuiltinAttribute() = default;

6
src/tint/ast/builtin_attribute.h
View File

@ -18,7 +18,7 @@
#include <string> #include <string>
#include "src/tint/ast/attribute.h" #include "src/tint/ast/attribute.h"
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
namespace tint::ast { namespace tint::ast {
@ -30,7 +30,7 @@ class BuiltinAttribute final : public Castable<BuiltinAttribute, Attribute> {
/// @param nid the unique node identifier /// @param nid the unique node identifier
/// @param src the source of this node /// @param src the source of this node
/// @param builtin the builtin value /// @param builtin the builtin value
BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, BuiltinValue builtin); BuiltinAttribute(ProgramID pid, NodeID nid, const Source& src, builtin::BuiltinValue builtin);
~BuiltinAttribute() override; ~BuiltinAttribute() override;
/// @returns the WGSL name for the attribute /// @returns the WGSL name for the attribute
@ -43,7 +43,7 @@ class BuiltinAttribute final : public Castable<BuiltinAttribute, Attribute> {
const BuiltinAttribute* Clone(CloneContext* ctx) const override; const BuiltinAttribute* Clone(CloneContext* ctx) const override;
/// The builtin value /// The builtin value
const BuiltinValue builtin; const builtin::BuiltinValue builtin;
}; };
} // namespace tint::ast } // namespace tint::ast

4
src/tint/ast/builtin_attribute_test.cc
View File

@ -20,8 +20,8 @@ namespace {
using BuiltinAttributeTest = TestHelper; using BuiltinAttributeTest = TestHelper;
TEST_F(BuiltinAttributeTest, Creation) { TEST_F(BuiltinAttributeTest, Creation) {
auto* d = create<BuiltinAttribute>(BuiltinValue::kFragDepth); auto* d = create<BuiltinAttribute>(builtin::BuiltinValue::kFragDepth);
EXPECT_EQ(BuiltinValue::kFragDepth, d->builtin); EXPECT_EQ(builtin::BuiltinValue::kFragDepth, d->builtin);
} }
} // namespace } // namespace

2
src/tint/ast/variable_test.cc
View File

@ -93,7 +93,7 @@ TEST_F(VariableTest, Assert_DifferentProgramID_Initializer) {
TEST_F(VariableTest, WithAttributes) { TEST_F(VariableTest, WithAttributes) {
auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Location(1_u), auto* var = Var("my_var", ty.i32(), type::AddressSpace::kFunction, Location(1_u),
Builtin(BuiltinValue::kPosition), Id(1200_u)); Builtin(builtin::BuiltinValue::kPosition), Id(1200_u));
auto& attributes = var->attributes; auto& attributes = var->attributes;
EXPECT_TRUE(ast::HasAttribute<ast::LocationAttribute>(attributes)); EXPECT_TRUE(ast::HasAttribute<ast::LocationAttribute>(attributes));

8
src/tint/ast/builtin_value.cc → src/tint/builtin/builtin_value.cc
View File

@ -15,14 +15,14 @@
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen // File generated by tools/src/cmd/gen
// using the template: // using the template:
// src/tint/ast/builtin_value.cc.tmpl // src/tint/builtin/builtin_value.cc.tmpl
// //
// Do not modify this file directly // Do not modify this file directly
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
namespace tint::ast { namespace tint::builtin {
/// ParseBuiltinValue parses a BuiltinValue from a string. /// ParseBuiltinValue parses a BuiltinValue from a string.
/// @param str the string to parse /// @param str the string to parse
@ -101,4 +101,4 @@ std::ostream& operator<<(std::ostream& out, BuiltinValue value) {
return out << "<unknown>"; return out << "<unknown>";
} }
} // namespace tint::ast } // namespace tint::builtin

6
src/tint/ast/builtin_value.cc.tmpl → src/tint/builtin/builtin_value.cc.tmpl
View File

@ -11,12 +11,12 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "builtin_value") -}} {{- $enum := (Sem.Enum "builtin_value") -}}
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
namespace tint::ast { namespace tint::builtin {
{{ Eval "ParseEnum" $enum}} {{ Eval "ParseEnum" $enum}}
{{ Eval "EnumOStream" $enum}} {{ Eval "EnumOStream" $enum}}
} // namespace tint::ast } // namespace tint::builtin

12
src/tint/ast/builtin_value.h → src/tint/builtin/builtin_value.h
View File

@ -15,17 +15,17 @@
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen // File generated by tools/src/cmd/gen
// using the template: // using the template:
// src/tint/ast/builtin_value.h.tmpl // src/tint/builtin/builtin_value.h.tmpl
// //
// Do not modify this file directly // Do not modify this file directly
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#ifndef SRC_TINT_AST_BUILTIN_VALUE_H_ #ifndef SRC_TINT_BUILTIN_BUILTIN_VALUE_H_
#define SRC_TINT_AST_BUILTIN_VALUE_H_ #define SRC_TINT_BUILTIN_BUILTIN_VALUE_H_
#include <ostream> #include <ostream>
namespace tint::ast { namespace tint::builtin {
/// Builtin value defined with `@builtin(<name>)`. /// Builtin value defined with `@builtin(<name>)`.
enum class BuiltinValue { enum class BuiltinValue {
@ -64,6 +64,6 @@ constexpr const char* kBuiltinValueStrings[] = {
"vertex_index", "workgroup_id", "vertex_index", "workgroup_id",
}; };
} // namespace tint::ast } // namespace tint::builtin
#endif // SRC_TINT_AST_BUILTIN_VALUE_H_ #endif // SRC_TINT_BUILTIN_BUILTIN_VALUE_H_

10
src/tint/ast/builtin_value.h.tmpl → src/tint/builtin/builtin_value.h.tmpl
View File

@ -11,16 +11,16 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "builtin_value") -}} {{- $enum := (Sem.Enum "builtin_value") -}}
#ifndef SRC_TINT_AST_BUILTIN_VALUE_H_ #ifndef SRC_TINT_BUILTIN_BUILTIN_VALUE_H_
#define SRC_TINT_AST_BUILTIN_VALUE_H_ #define SRC_TINT_BUILTIN_BUILTIN_VALUE_H_
#include <ostream> #include <ostream>
namespace tint::ast { namespace tint::builtin {
/// Builtin value defined with `@builtin(<name>)`. /// Builtin value defined with `@builtin(<name>)`.
{{ Eval "DeclareEnum" $enum}} {{ Eval "DeclareEnum" $enum}}
} // namespace tint::ast } // namespace tint::builtin
#endif // SRC_TINT_AST_BUILTIN_VALUE_H_ #endif // SRC_TINT_BUILTIN_BUILTIN_VALUE_H_

8
src/tint/ast/builtin_value_bench.cc → src/tint/builtin/builtin_value_bench.cc
View File

@ -15,18 +15,18 @@
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen // File generated by tools/src/cmd/gen
// using the template: // using the template:
// src/tint/ast/builtin_value_bench.cc.tmpl // src/tint/builtin/builtin_value_bench.cc.tmpl
// //
// Do not modify this file directly // Do not modify this file directly
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
#include <array> #include <array>
#include "benchmark/benchmark.h" #include "benchmark/benchmark.h"
namespace tint::ast { namespace tint::builtin {
namespace { namespace {
void BuiltinValueParser(::benchmark::State& state) { void BuiltinValueParser(::benchmark::State& state) {
@ -127,4 +127,4 @@ void BuiltinValueParser(::benchmark::State& state) {
BENCHMARK(BuiltinValueParser); BENCHMARK(BuiltinValueParser);
} // namespace } // namespace
} // namespace tint::ast } // namespace tint::builtin

6
src/tint/ast/builtin_value_bench.cc.tmpl → src/tint/builtin/builtin_value_bench.cc.tmpl
View File

@ -11,16 +11,16 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "builtin_value") -}} {{- $enum := (Sem.Enum "builtin_value") -}}
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
#include <array> #include <array>
#include "benchmark/benchmark.h" #include "benchmark/benchmark.h"
namespace tint::ast { namespace tint::builtin {
namespace { namespace {
{{ Eval "BenchmarkParseEnum" $enum }} {{ Eval "BenchmarkParseEnum" $enum }}
} // namespace } // namespace
} // namespace tint::ast } // namespace tint::builtin

11
src/tint/ast/builtin_value_test.cc → src/tint/builtin/builtin_value_test.cc
View File

@ -15,19 +15,20 @@
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen // File generated by tools/src/cmd/gen
// using the template: // using the template:
// src/tint/ast/builtin_value_test.cc.tmpl // src/tint/builtin/builtin_value_test.cc.tmpl
// //
// Do not modify this file directly // Do not modify this file directly
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
#include <gtest/gtest.h>
#include <string> #include <string>
#include "src/tint/ast/test_helper.h"
#include "src/tint/utils/string.h" #include "src/tint/utils/string.h"
namespace tint::ast { namespace tint::builtin {
namespace { namespace {
namespace parse_print_tests { namespace parse_print_tests {
@ -119,4 +120,4 @@ INSTANTIATE_TEST_SUITE_P(ValidCases, BuiltinValuePrintTest, testing::ValuesIn(kV
} // namespace parse_print_tests } // namespace parse_print_tests
} // namespace } // namespace
} // namespace tint::ast } // namespace tint::builtin

9
src/tint/ast/builtin_value_test.cc.tmpl → src/tint/builtin/builtin_value_test.cc.tmpl
View File

@ -11,17 +11,18 @@ See:
{{- Import "src/tint/templates/enums.tmpl.inc" -}} {{- Import "src/tint/templates/enums.tmpl.inc" -}}
{{- $enum := (Sem.Enum "builtin_value") -}} {{- $enum := (Sem.Enum "builtin_value") -}}
#include "src/tint/ast/builtin_value.h" #include "src/tint/builtin/builtin_value.h"
#include <gtest/gtest.h>
#include <string> #include <string>
#include "src/tint/ast/test_helper.h"
#include "src/tint/utils/string.h" #include "src/tint/utils/string.h"
namespace tint::ast { namespace tint::builtin {
namespace { namespace {
{{ Eval "TestParsePrintEnum" $enum}} {{ Eval "TestParsePrintEnum" $enum}}
} // namespace } // namespace
} // namespace tint::ast } // namespace tint::builtin

16
src/tint/inspector/inspector.cc
View File

@ -216,15 +216,15 @@ EntryPoint Inspector::GetEntryPoint(const tint::ast::Function* func) {
param->Location(), entry_point.input_variables); param->Location(), entry_point.input_variables);
entry_point.input_position_used |= ContainsBuiltin( entry_point.input_position_used |= ContainsBuiltin(
ast::BuiltinValue::kPosition, param->Type(), param->Declaration()->attributes); builtin::BuiltinValue::kPosition, param->Type(), param->Declaration()->attributes);
entry_point.front_facing_used |= ContainsBuiltin( entry_point.front_facing_used |= ContainsBuiltin(
ast::BuiltinValue::kFrontFacing, param->Type(), param->Declaration()->attributes); builtin::BuiltinValue::kFrontFacing, param->Type(), param->Declaration()->attributes);
entry_point.sample_index_used |= ContainsBuiltin( entry_point.sample_index_used |= ContainsBuiltin(
ast::BuiltinValue::kSampleIndex, param->Type(), param->Declaration()->attributes); builtin::BuiltinValue::kSampleIndex, param->Type(), param->Declaration()->attributes);
entry_point.input_sample_mask_used |= ContainsBuiltin( entry_point.input_sample_mask_used |= ContainsBuiltin(
ast::BuiltinValue::kSampleMask, param->Type(), param->Declaration()->attributes); builtin::BuiltinValue::kSampleMask, param->Type(), param->Declaration()->attributes);
entry_point.num_workgroups_used |= ContainsBuiltin( entry_point.num_workgroups_used |= ContainsBuiltin(
ast::BuiltinValue::kNumWorkgroups, param->Type(), param->Declaration()->attributes); builtin::BuiltinValue::kNumWorkgroups, param->Type(), param->Declaration()->attributes);
} }
if (!sem->ReturnType()->Is<type::Void>()) { if (!sem->ReturnType()->Is<type::Void>()) {
@ -232,9 +232,9 @@ EntryPoint Inspector::GetEntryPoint(const tint::ast::Function* func) {
sem->ReturnLocation(), entry_point.output_variables); sem->ReturnLocation(), entry_point.output_variables);
entry_point.output_sample_mask_used = ContainsBuiltin( entry_point.output_sample_mask_used = ContainsBuiltin(
ast::BuiltinValue::kSampleMask, sem->ReturnType(), func->return_type_attributes); builtin::BuiltinValue::kSampleMask, sem->ReturnType(), func->return_type_attributes);
entry_point.frag_depth_used = ContainsBuiltin( entry_point.frag_depth_used = ContainsBuiltin(
ast::BuiltinValue::kFragDepth, sem->ReturnType(), func->return_type_attributes); builtin::BuiltinValue::kFragDepth, sem->ReturnType(), func->return_type_attributes);
} }
for (auto* var : sem->TransitivelyReferencedGlobals()) { for (auto* var : sem->TransitivelyReferencedGlobals()) {
@ -681,7 +681,7 @@ void Inspector::AddEntryPointInOutVariables(std::string name,
variables.push_back(stage_variable); variables.push_back(stage_variable);
} }
bool Inspector::ContainsBuiltin(ast::BuiltinValue builtin, bool Inspector::ContainsBuiltin(builtin::BuiltinValue builtin,
const type::Type* type, const type::Type* type,
utils::VectorRef<const ast::Attribute*> attributes) const { utils::VectorRef<const ast::Attribute*> attributes) const {
auto* unwrapped_type = type->UnwrapRef(); auto* unwrapped_type = type->UnwrapRef();

2
src/tint/inspector/inspector.h
View File

@ -183,7 +183,7 @@ class Inspector {
/// Recursively determine if the type contains builtin. /// Recursively determine if the type contains builtin.
/// If `type` is a struct, recurse into members to check for the attribute. /// If `type` is a struct, recurse into members to check for the attribute.
/// Otherwise, check `attributes` for the attribute. /// Otherwise, check `attributes` for the attribute.
bool ContainsBuiltin(ast::BuiltinValue builtin, bool ContainsBuiltin(builtin::BuiltinValue builtin,
const type::Type* type, const type::Type* type,
utils::VectorRef<const ast::Attribute*> attributes) const; utils::VectorRef<const ast::Attribute*> attributes) const;

44
src/tint/inspector/inspector_test.cc
View File

@ -464,7 +464,7 @@ TEST_F(InspectorGetEntryPointTest, MultipleEntryPointsInOutVariables) {
TEST_F(InspectorGetEntryPointTest, BuiltInsNotStageVariables) { TEST_F(InspectorGetEntryPointTest, BuiltInsNotStageVariables) {
auto* in_var0 = Param("in_var0", ty.u32(), auto* in_var0 = Param("in_var0", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
}); });
auto* in_var1 = Param("in_var1", ty.f32(), auto* in_var1 = Param("in_var1", ty.f32(),
utils::Vector{ utils::Vector{
@ -478,7 +478,7 @@ TEST_F(InspectorGetEntryPointTest, BuiltInsNotStageVariables) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
Inspector& inspector = Build(); Inspector& inspector = Build();
@ -1049,7 +1049,7 @@ TEST_F(InspectorGetEntryPointTest, BuiltinNotReferenced) {
TEST_F(InspectorGetEntryPointTest, InputSampleMaskSimpleReferenced) { TEST_F(InspectorGetEntryPointTest, InputSampleMaskSimpleReferenced) {
auto* in_var = Param("in_var", ty.u32(), auto* in_var = Param("in_var", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleMask), Builtin(builtin::BuiltinValue::kSampleMask),
}); });
Func("ep_func", utils::Vector{in_var}, ty.void_(), Func("ep_func", utils::Vector{in_var}, ty.void_(),
utils::Vector{ utils::Vector{
@ -1069,7 +1069,8 @@ TEST_F(InspectorGetEntryPointTest, InputSampleMaskSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, InputSampleMaskStructReferenced) { TEST_F(InspectorGetEntryPointTest, InputSampleMaskStructReferenced) {
utils::Vector members{ utils::Vector members{
Member("inner_position", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleMask)}), Member("inner_position", ty.u32(),
utils::Vector{Builtin(builtin::BuiltinValue::kSampleMask)}),
}; };
Structure("in_struct", members); Structure("in_struct", members);
@ -1097,7 +1098,7 @@ TEST_F(InspectorGetEntryPointTest, InputSampleMaskStructReferenced) {
TEST_F(InspectorGetEntryPointTest, OutputSampleMaskSimpleReferenced) { TEST_F(InspectorGetEntryPointTest, OutputSampleMaskSimpleReferenced) {
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
Param("in_var", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleMask)}), Param("in_var", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kSampleMask)}),
}, },
ty.u32(), ty.u32(),
utils::Vector{ utils::Vector{
@ -1107,7 +1108,7 @@ TEST_F(InspectorGetEntryPointTest, OutputSampleMaskSimpleReferenced) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleMask), Builtin(builtin::BuiltinValue::kSampleMask),
}); });
Inspector& inspector = Build(); Inspector& inspector = Build();
@ -1121,7 +1122,7 @@ TEST_F(InspectorGetEntryPointTest, OutputSampleMaskSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, OutputSampleMaskStructReferenced) { TEST_F(InspectorGetEntryPointTest, OutputSampleMaskStructReferenced) {
Structure("out_struct", utils::Vector{ Structure("out_struct", utils::Vector{
Member("inner_sample_mask", ty.u32(), Member("inner_sample_mask", ty.u32(),
utils::Vector{Builtin(ast::BuiltinValue::kSampleMask)}), utils::Vector{Builtin(builtin::BuiltinValue::kSampleMask)}),
}); });
Func("ep_func", utils::Empty, ty("out_struct"), Func("ep_func", utils::Empty, ty("out_struct"),
@ -1144,7 +1145,8 @@ TEST_F(InspectorGetEntryPointTest, OutputSampleMaskStructReferenced) {
TEST_F(InspectorGetEntryPointTest, InputPositionSimpleReferenced) { TEST_F(InspectorGetEntryPointTest, InputPositionSimpleReferenced) {
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
Param("in_var", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Param("in_var", ty.vec4<f32>(),
utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -1165,7 +1167,7 @@ TEST_F(InspectorGetEntryPointTest, InputPositionSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, InputPositionStructReferenced) { TEST_F(InspectorGetEntryPointTest, InputPositionStructReferenced) {
Structure("in_struct", utils::Vector{ Structure("in_struct", utils::Vector{
Member("inner_position", ty.vec4<f32>(), Member("inner_position", ty.vec4<f32>(),
utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
}); });
Func("ep_func", Func("ep_func",
@ -1191,7 +1193,8 @@ TEST_F(InspectorGetEntryPointTest, InputPositionStructReferenced) {
TEST_F(InspectorGetEntryPointTest, FrontFacingSimpleReferenced) { TEST_F(InspectorGetEntryPointTest, FrontFacingSimpleReferenced) {
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
Param("in_var", ty.bool_(), utils::Vector{Builtin(ast::BuiltinValue::kFrontFacing)}), Param("in_var", ty.bool_(),
utils::Vector{Builtin(builtin::BuiltinValue::kFrontFacing)}),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -1212,7 +1215,7 @@ TEST_F(InspectorGetEntryPointTest, FrontFacingSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, FrontFacingStructReferenced) { TEST_F(InspectorGetEntryPointTest, FrontFacingStructReferenced) {
Structure("in_struct", utils::Vector{ Structure("in_struct", utils::Vector{
Member("inner_position", ty.bool_(), Member("inner_position", ty.bool_(),
utils::Vector{Builtin(ast::BuiltinValue::kFrontFacing)}), utils::Vector{Builtin(builtin::BuiltinValue::kFrontFacing)}),
}); });
Func("ep_func", Func("ep_func",
@ -1238,7 +1241,7 @@ TEST_F(InspectorGetEntryPointTest, FrontFacingStructReferenced) {
TEST_F(InspectorGetEntryPointTest, SampleIndexSimpleReferenced) { TEST_F(InspectorGetEntryPointTest, SampleIndexSimpleReferenced) {
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
Param("in_var", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)}), Param("in_var", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)}),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -1259,7 +1262,7 @@ TEST_F(InspectorGetEntryPointTest, SampleIndexSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, SampleIndexStructReferenced) { TEST_F(InspectorGetEntryPointTest, SampleIndexStructReferenced) {
Structure("in_struct", utils::Vector{ Structure("in_struct", utils::Vector{
Member("inner_position", ty.u32(), Member("inner_position", ty.u32(),
utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)}), utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)}),
}); });
Func("ep_func", Func("ep_func",
@ -1286,7 +1289,7 @@ TEST_F(InspectorGetEntryPointTest, NumWorkgroupsSimpleReferenced) {
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
Param("in_var", ty.vec3<u32>(), Param("in_var", ty.vec3<u32>(),
utils::Vector{Builtin(ast::BuiltinValue::kNumWorkgroups)}), utils::Vector{Builtin(builtin::BuiltinValue::kNumWorkgroups)}),
}, },
ty.void_(), ty.void_(),
utils::Vector{ utils::Vector{
@ -1303,10 +1306,11 @@ TEST_F(InspectorGetEntryPointTest, NumWorkgroupsSimpleReferenced) {
} }
TEST_F(InspectorGetEntryPointTest, NumWorkgroupsStructReferenced) { TEST_F(InspectorGetEntryPointTest, NumWorkgroupsStructReferenced) {
Structure("in_struct", utils::Vector{ Structure("in_struct",
Member("inner_position", ty.vec3<u32>(), utils::Vector{
utils::Vector{Builtin(ast::BuiltinValue::kNumWorkgroups)}), Member("inner_position", ty.vec3<u32>(),
}); utils::Vector{Builtin(builtin::BuiltinValue::kNumWorkgroups)}),
});
Func("ep_func", Func("ep_func",
utils::Vector{ utils::Vector{
@ -1335,7 +1339,7 @@ TEST_F(InspectorGetEntryPointTest, FragDepthSimpleReferenced) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
Inspector& inspector = Build(); Inspector& inspector = Build();
@ -1349,7 +1353,7 @@ TEST_F(InspectorGetEntryPointTest, FragDepthSimpleReferenced) {
TEST_F(InspectorGetEntryPointTest, FragDepthStructReferenced) { TEST_F(InspectorGetEntryPointTest, FragDepthStructReferenced) {
Structure("out_struct", utils::Vector{ Structure("out_struct", utils::Vector{
Member("inner_frag_depth", ty.f32(), Member("inner_frag_depth", ty.f32(),
utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}), utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)}),
}); });
Func("ep_func", utils::Empty, ty("out_struct"), Func("ep_func", utils::Empty, ty("out_struct"),

4
src/tint/program_builder.h
View File

@ -3436,14 +3436,14 @@ class ProgramBuilder {
/// @param source the source information /// @param source the source information
/// @param builtin the builtin value /// @param builtin the builtin value
/// @returns the builtin attribute pointer /// @returns the builtin attribute pointer
const ast::BuiltinAttribute* Builtin(const Source& source, ast::BuiltinValue builtin) { const ast::BuiltinAttribute* Builtin(const Source& source, builtin::BuiltinValue builtin) {
return create<ast::BuiltinAttribute>(source, builtin); return create<ast::BuiltinAttribute>(source, builtin);
} }
/// Creates an ast::BuiltinAttribute /// Creates an ast::BuiltinAttribute
/// @param builtin the builtin value /// @param builtin the builtin value
/// @returns the builtin attribute pointer /// @returns the builtin attribute pointer
const ast::BuiltinAttribute* Builtin(ast::BuiltinValue builtin) { const ast::BuiltinAttribute* Builtin(builtin::BuiltinValue builtin) {
return create<ast::BuiltinAttribute>(source_, builtin); return create<ast::BuiltinAttribute>(source_, builtin);
} }

30
src/tint/reader/spirv/enum_converter.cc
View File

@ -64,40 +64,40 @@ type::AddressSpace EnumConverter::ToAddressSpace(const spv::StorageClass sc) {
return type::AddressSpace::kUndefined; return type::AddressSpace::kUndefined;
} }
ast::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) { builtin::BuiltinValue EnumConverter::ToBuiltin(spv::BuiltIn b) {
switch (b) { switch (b) {
case spv::BuiltIn::Position: case spv::BuiltIn::Position:
return ast::BuiltinValue::kPosition; return builtin::BuiltinValue::kPosition;
case spv::BuiltIn::VertexIndex: case spv::BuiltIn::VertexIndex:
return ast::BuiltinValue::kVertexIndex; return builtin::BuiltinValue::kVertexIndex;
case spv::BuiltIn::InstanceIndex: case spv::BuiltIn::InstanceIndex:
return ast::BuiltinValue::kInstanceIndex; return builtin::BuiltinValue::kInstanceIndex;
case spv::BuiltIn::FrontFacing: case spv::BuiltIn::FrontFacing:
return ast::BuiltinValue::kFrontFacing; return builtin::BuiltinValue::kFrontFacing;
case spv::BuiltIn::FragCoord: case spv::BuiltIn::FragCoord:
return ast::BuiltinValue::kPosition; return builtin::BuiltinValue::kPosition;
case spv::BuiltIn::FragDepth: case spv::BuiltIn::FragDepth:
return ast::BuiltinValue::kFragDepth; return builtin::BuiltinValue::kFragDepth;
case spv::BuiltIn::LocalInvocationId: case spv::BuiltIn::LocalInvocationId:
return ast::BuiltinValue::kLocalInvocationId; return builtin::BuiltinValue::kLocalInvocationId;
case spv::BuiltIn::LocalInvocationIndex: case spv::BuiltIn::LocalInvocationIndex:
return ast::BuiltinValue::kLocalInvocationIndex; return builtin::BuiltinValue::kLocalInvocationIndex;
case spv::BuiltIn::GlobalInvocationId: case spv::BuiltIn::GlobalInvocationId:
return ast::BuiltinValue::kGlobalInvocationId; return builtin::BuiltinValue::kGlobalInvocationId;
case spv::BuiltIn::NumWorkgroups: case spv::BuiltIn::NumWorkgroups:
return ast::BuiltinValue::kNumWorkgroups; return builtin::BuiltinValue::kNumWorkgroups;
case spv::BuiltIn::WorkgroupId: case spv::BuiltIn::WorkgroupId:
return ast::BuiltinValue::kWorkgroupId; return builtin::BuiltinValue::kWorkgroupId;
case spv::BuiltIn::SampleId: case spv::BuiltIn::SampleId:
return ast::BuiltinValue::kSampleIndex; return builtin::BuiltinValue::kSampleIndex;
case spv::BuiltIn::SampleMask: case spv::BuiltIn::SampleMask:
return ast::BuiltinValue::kSampleMask; return builtin::BuiltinValue::kSampleMask;
default: default:
break; break;
} }
Fail() << "unknown SPIR-V builtin: " << uint32_t(b); Fail() << "unknown SPIR-V builtin: " << uint32_t(b);
return ast::BuiltinValue::kUndefined; return builtin::BuiltinValue::kUndefined;
} }
type::TextureDimension EnumConverter::ToDim(spv::Dim dim, bool arrayed) { type::TextureDimension EnumConverter::ToDim(spv::Dim dim, bool arrayed) {

4
src/tint/reader/spirv/enum_converter.h
View File

@ -17,8 +17,8 @@
#include "spirv/unified1/spirv.h" #include "spirv/unified1/spirv.h"
#include "spirv/unified1/spirv.hpp11" #include "spirv/unified1/spirv.hpp11"
#include "src/tint/ast/builtin_value.h"
#include "src/tint/ast/pipeline_stage.h" #include "src/tint/ast/pipeline_stage.h"
#include "src/tint/builtin/builtin_value.h"
#include "src/tint/reader/spirv/fail_stream.h" #include "src/tint/reader/spirv/fail_stream.h"
#include "src/tint/type/address_space.h" #include "src/tint/type/address_space.h"
#include "src/tint/type/storage_texture.h" #include "src/tint/type/storage_texture.h"
@ -51,7 +51,7 @@ class EnumConverter {
/// On failure, logs an error and returns kNone /// On failure, logs an error and returns kNone
/// @param b the SPIR-V builtin /// @param b the SPIR-V builtin
/// @returns a Tint AST builtin /// @returns a Tint AST builtin
ast::BuiltinValue ToBuiltin(spv::BuiltIn b); builtin::BuiltinValue ToBuiltin(spv::BuiltIn b);
/// Converts a possibly arrayed SPIR-V Dim to a Tint texture dimension. /// Converts a possibly arrayed SPIR-V Dim to a Tint texture dimension.
/// On failure, logs an error and returns kNone /// On failure, logs an error and returns kNone

37
src/tint/reader/spirv/enum_converter_test.cc
View File

@ -145,7 +145,7 @@ INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
struct BuiltinCase { struct BuiltinCase {
spv::BuiltIn builtin; spv::BuiltIn builtin;
bool expect_success; bool expect_success;
ast::BuiltinValue expected; builtin::BuiltinValue expected;
}; };
inline std::ostream& operator<<(std::ostream& out, BuiltinCase bc) { inline std::ostream& operator<<(std::ostream& out, BuiltinCase bc) {
out << "BuiltinCase{ spv::BuiltIn::" << int(bc.builtin) out << "BuiltinCase{ spv::BuiltIn::" << int(bc.builtin)
@ -185,32 +185,35 @@ INSTANTIATE_TEST_SUITE_P(
EnumConverterGood_Input, EnumConverterGood_Input,
SpvBuiltinTest, SpvBuiltinTest,
testing::Values( testing::Values(
BuiltinCase{spv::BuiltIn::Position, true, ast::BuiltinValue::kPosition}, BuiltinCase{spv::BuiltIn::Position, true, builtin::BuiltinValue::kPosition},
BuiltinCase{spv::BuiltIn::InstanceIndex, true, ast::BuiltinValue::kInstanceIndex}, BuiltinCase{spv::BuiltIn::InstanceIndex, true, builtin::BuiltinValue::kInstanceIndex},
BuiltinCase{spv::BuiltIn::FrontFacing, true, ast::BuiltinValue::kFrontFacing}, BuiltinCase{spv::BuiltIn::FrontFacing, true, builtin::BuiltinValue::kFrontFacing},
BuiltinCase{spv::BuiltIn::FragCoord, true, ast::BuiltinValue::kPosition}, BuiltinCase{spv::BuiltIn::FragCoord, true, builtin::BuiltinValue::kPosition},
BuiltinCase{spv::BuiltIn::LocalInvocationId, true, ast::BuiltinValue::kLocalInvocationId}, BuiltinCase{spv::BuiltIn::LocalInvocationId, true,
builtin::BuiltinValue::kLocalInvocationId},
BuiltinCase{spv::BuiltIn::LocalInvocationIndex, true, BuiltinCase{spv::BuiltIn::LocalInvocationIndex, true,
ast::BuiltinValue::kLocalInvocationIndex}, builtin::BuiltinValue::kLocalInvocationIndex},
BuiltinCase{spv::BuiltIn::GlobalInvocationId, true, ast::BuiltinValue::kGlobalInvocationId}, BuiltinCase{spv::BuiltIn::GlobalInvocationId, true,
BuiltinCase{spv::BuiltIn::NumWorkgroups, true, ast::BuiltinValue::kNumWorkgroups}, builtin::BuiltinValue::kGlobalInvocationId},
BuiltinCase{spv::BuiltIn::WorkgroupId, true, ast::BuiltinValue::kWorkgroupId}, BuiltinCase{spv::BuiltIn::NumWorkgroups, true, builtin::BuiltinValue::kNumWorkgroups},
BuiltinCase{spv::BuiltIn::SampleId, true, ast::BuiltinValue::kSampleIndex}, BuiltinCase{spv::BuiltIn::WorkgroupId, true, builtin::BuiltinValue::kWorkgroupId},
BuiltinCase{spv::BuiltIn::SampleMask, true, ast::BuiltinValue::kSampleMask})); BuiltinCase{spv::BuiltIn::SampleId, true, builtin::BuiltinValue::kSampleIndex},
BuiltinCase{spv::BuiltIn::SampleMask, true, builtin::BuiltinValue::kSampleMask}));
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
EnumConverterGood_Output, EnumConverterGood_Output,
SpvBuiltinTest, SpvBuiltinTest,
testing::Values(BuiltinCase{spv::BuiltIn::Position, true, ast::BuiltinValue::kPosition}, testing::Values(BuiltinCase{spv::BuiltIn::Position, true, builtin::BuiltinValue::kPosition},
BuiltinCase{spv::BuiltIn::FragDepth, true, ast::BuiltinValue::kFragDepth}, BuiltinCase{spv::BuiltIn::FragDepth, true, builtin::BuiltinValue::kFragDepth},
BuiltinCase{spv::BuiltIn::SampleMask, true, ast::BuiltinValue::kSampleMask})); BuiltinCase{spv::BuiltIn::SampleMask, true,
builtin::BuiltinValue::kSampleMask}));
INSTANTIATE_TEST_SUITE_P(EnumConverterBad, INSTANTIATE_TEST_SUITE_P(EnumConverterBad,
SpvBuiltinTest, SpvBuiltinTest,
testing::Values(BuiltinCase{static_cast<spv::BuiltIn>(9999), false, testing::Values(BuiltinCase{static_cast<spv::BuiltIn>(9999), false,
ast::BuiltinValue::kUndefined}, builtin::BuiltinValue::kUndefined},
BuiltinCase{static_cast<spv::BuiltIn>(9999), false, BuiltinCase{static_cast<spv::BuiltIn>(9999), false,
ast::BuiltinValue::kUndefined})); builtin::BuiltinValue::kUndefined}));
// Dim // Dim

6
src/tint/reader/spirv/function.cc
View File

@ -21,7 +21,6 @@
#include "src/tint/ast/bitcast_expression.h" #include "src/tint/ast/bitcast_expression.h"
#include "src/tint/ast/break_statement.h" #include "src/tint/ast/break_statement.h"
#include "src/tint/ast/builtin_attribute.h" #include "src/tint/ast/builtin_attribute.h"
#include "src/tint/ast/builtin_value.h"
#include "src/tint/ast/call_statement.h" #include "src/tint/ast/call_statement.h"
#include "src/tint/ast/continue_statement.h" #include "src/tint/ast/continue_statement.h"
#include "src/tint/ast/discard_statement.h" #include "src/tint/ast/discard_statement.h"
@ -32,6 +31,7 @@
#include "src/tint/ast/switch_statement.h" #include "src/tint/ast/switch_statement.h"
#include "src/tint/ast/unary_op_expression.h" #include "src/tint/ast/unary_op_expression.h"
#include "src/tint/ast/variable_decl_statement.h" #include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/builtin/builtin_value.h"
#include "src/tint/sem/builtin_type.h" #include "src/tint/sem/builtin_type.h"
#include "src/tint/transform/spirv_atomic.h" #include "src/tint/transform/spirv_atomic.h"
#include "src/tint/type/depth_texture.h" #include "src/tint/type/depth_texture.h"
@ -760,7 +760,7 @@ struct LoopStatementBuilder final : public Castable<LoopStatementBuilder, Statem
/// @returns true if the decorations include a SampleMask builtin /// @returns true if the decorations include a SampleMask builtin
bool HasBuiltinSampleMask(utils::VectorRef<const ast::Attribute*> decos) { bool HasBuiltinSampleMask(utils::VectorRef<const ast::Attribute*> decos) {
if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(decos)) { if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(decos)) {
return builtin->builtin == ast::BuiltinValue::kSampleMask; return builtin->builtin == builtin::BuiltinValue::kSampleMask;
} }
return false; return false;
} }
@ -1331,7 +1331,7 @@ bool FunctionEmitter::EmitEntryPointAsWrapper() {
// a gl_Position variable. Substitute the type. // a gl_Position variable. Substitute the type.
const Type* param_type = ty_.Vector(ty_.F32(), 4); const Type* param_type = ty_.Vector(ty_.F32(), 4);
AttributeList out_decos{ AttributeList out_decos{
create<ast::BuiltinAttribute>(source, ast::BuiltinValue::kPosition)}; create<ast::BuiltinAttribute>(source, builtin::BuiltinValue::kPosition)};
const auto var_name = namer_.GetName(var_id); const auto var_name = namer_.GetName(var_id);
return_members.Push( return_members.Push(

2
src/tint/reader/spirv/parser_impl.cc
View File

@ -1699,7 +1699,7 @@ bool ParserImpl::ConvertDecorationsForVariable(uint32_t id,
break; break;
} }
auto ast_builtin = enum_converter_.ToBuiltin(spv_builtin); auto ast_builtin = enum_converter_.ToBuiltin(spv_builtin);
if (ast_builtin == ast::BuiltinValue::kUndefined) { if (ast_builtin == builtin::BuiltinValue::kUndefined) {
// A diagnostic has already been emitted. // A diagnostic has already been emitted.
return false; return false;
} }

4
src/tint/reader/wgsl/parser_impl.cc
View File

@ -1648,8 +1648,8 @@ Expect<ast::InterpolationType> ParserImpl::expect_interpolation_type_name() {
// | sample_mask // | sample_mask
// | vertex_index // | vertex_index
// | workgroup_id // | workgroup_id
Expect<ast::BuiltinValue> ParserImpl::expect_builtin() { Expect<builtin::BuiltinValue> ParserImpl::expect_builtin() {
return expect_enum("builtin", ast::ParseBuiltinValue, ast::kBuiltinValueStrings); return expect_enum("builtin", builtin::ParseBuiltinValue, builtin::kBuiltinValueStrings);
} }
// compound_statement // compound_statement

2
src/tint/reader/wgsl/parser_impl.h
View File

@ -540,7 +540,7 @@ class ParserImpl {
/// Parses a builtin identifier, erroring if the next token does not match a /// Parses a builtin identifier, erroring if the next token does not match a
/// valid builtin name. /// valid builtin name.
/// @returns the parsed builtin. /// @returns the parsed builtin.
Expect<ast::BuiltinValue> expect_builtin(); Expect<builtin::BuiltinValue> expect_builtin();
/// Parses a `compound_statement` grammar element, erroring on parse failure. /// Parses a `compound_statement` grammar element, erroring on parse failure.
/// @param use a description of what was being parsed if an error was raised /// @param use a description of what was being parsed if an error was raised
/// @returns the parsed statements /// @returns the parsed statements

2
src/tint/reader/wgsl/parser_impl_param_list_test.cc
View File

@ -102,7 +102,7 @@ TEST_F(ParserImplTest, ParamList_Attributes) {
auto attrs_0 = e.value[0]->attributes; auto attrs_0 = e.value[0]->attributes;
ASSERT_EQ(attrs_0.Length(), 1u); ASSERT_EQ(attrs_0.Length(), 1u);
EXPECT_TRUE(attrs_0[0]->Is<ast::BuiltinAttribute>()); EXPECT_TRUE(attrs_0[0]->Is<ast::BuiltinAttribute>());
EXPECT_EQ(attrs_0[0]->As<ast::BuiltinAttribute>()->builtin, ast::BuiltinValue::kPosition); EXPECT_EQ(attrs_0[0]->As<ast::BuiltinAttribute>()->builtin, builtin::BuiltinValue::kPosition);
ASSERT_EQ(e.value[0]->source.range.begin.line, 1u); ASSERT_EQ(e.value[0]->source.range.begin.line, 1u);
ASSERT_EQ(e.value[0]->source.range.begin.column, 20u); ASSERT_EQ(e.value[0]->source.range.begin.column, 20u);

2
src/tint/reader/wgsl/parser_impl_variable_attribute_list_test.cc
View File

@ -38,7 +38,7 @@ TEST_F(ParserImplTest, AttributeList_Parses) {
EXPECT_EQ(exp->value, 4u); EXPECT_EQ(exp->value, 4u);
ASSERT_TRUE(attr_1->Is<ast::BuiltinAttribute>()); ASSERT_TRUE(attr_1->Is<ast::BuiltinAttribute>());
EXPECT_EQ(attr_1->As<ast::BuiltinAttribute>()->builtin, ast::BuiltinValue::kPosition); EXPECT_EQ(attr_1->As<ast::BuiltinAttribute>()->builtin, builtin::BuiltinValue::kPosition);
} }
TEST_F(ParserImplTest, AttributeList_Invalid) { TEST_F(ParserImplTest, AttributeList_Invalid) {

27
src/tint/reader/wgsl/parser_impl_variable_attribute_test.cc
View File

@ -217,7 +217,7 @@ TEST_F(ParserImplTest, Attribute_Location_MissingInvalid) {
struct BuiltinData { struct BuiltinData {
const char* input; const char* input;
ast::BuiltinValue result; builtin::BuiltinValue result;
}; };
inline std::ostream& operator<<(std::ostream& out, BuiltinData data) { inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
out << std::string(data.input); out << std::string(data.input);
@ -261,18 +261,19 @@ TEST_P(BuiltinTest, Attribute_Builtin_TrailingComma) {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
ParserImplTest, ParserImplTest,
BuiltinTest, BuiltinTest,
testing::Values(BuiltinData{"position", ast::BuiltinValue::kPosition}, testing::Values(BuiltinData{"position", builtin::BuiltinValue::kPosition},
BuiltinData{"vertex_index", ast::BuiltinValue::kVertexIndex}, BuiltinData{"vertex_index", builtin::BuiltinValue::kVertexIndex},
BuiltinData{"instance_index", ast::BuiltinValue::kInstanceIndex}, BuiltinData{"instance_index", builtin::BuiltinValue::kInstanceIndex},
BuiltinData{"front_facing", ast::BuiltinValue::kFrontFacing}, BuiltinData{"front_facing", builtin::BuiltinValue::kFrontFacing},
BuiltinData{"frag_depth", ast::BuiltinValue::kFragDepth}, BuiltinData{"frag_depth", builtin::BuiltinValue::kFragDepth},
BuiltinData{"local_invocation_id", ast::BuiltinValue::kLocalInvocationId}, BuiltinData{"local_invocation_id", builtin::BuiltinValue::kLocalInvocationId},
BuiltinData{"local_invocation_index", ast::BuiltinValue::kLocalInvocationIndex}, BuiltinData{"local_invocation_index",
BuiltinData{"global_invocation_id", ast::BuiltinValue::kGlobalInvocationId}, builtin::BuiltinValue::kLocalInvocationIndex},
BuiltinData{"workgroup_id", ast::BuiltinValue::kWorkgroupId}, BuiltinData{"global_invocation_id", builtin::BuiltinValue::kGlobalInvocationId},
BuiltinData{"num_workgroups", ast::BuiltinValue::kNumWorkgroups}, BuiltinData{"workgroup_id", builtin::BuiltinValue::kWorkgroupId},
BuiltinData{"sample_index", ast::BuiltinValue::kSampleIndex}, BuiltinData{"num_workgroups", builtin::BuiltinValue::kNumWorkgroups},
BuiltinData{"sample_mask", ast::BuiltinValue::kSampleMask})); BuiltinData{"sample_index", builtin::BuiltinValue::kSampleIndex},
BuiltinData{"sample_mask", builtin::BuiltinValue::kSampleMask}));
TEST_F(ParserImplTest, Attribute_Builtin_MissingLeftParen) { TEST_F(ParserImplTest, Attribute_Builtin_MissingLeftParen) {
auto p = parser("builtin position)"); auto p = parser("builtin position)");

18
src/tint/resolver/attribute_validation_test.cc
View File

@ -95,7 +95,7 @@ static utils::Vector<const ast::Attribute*, 2> createAttributes(const Source& so
case AttributeKind::kBinding: case AttributeKind::kBinding:
return {builder.Binding(source, 1_a)}; return {builder.Binding(source, 1_a)};
case AttributeKind::kBuiltin: case AttributeKind::kBuiltin:
return {builder.Builtin(source, ast::BuiltinValue::kPosition)}; return {builder.Builtin(source, builtin::BuiltinValue::kPosition)};
case AttributeKind::kDiagnostic: case AttributeKind::kDiagnostic:
return {builder.DiagnosticAttribute(source, ast::DiagnosticSeverity::kInfo, return {builder.DiagnosticAttribute(source, ast::DiagnosticSeverity::kInfo,
"chromium_unreachable_code")}; "chromium_unreachable_code")};
@ -257,7 +257,7 @@ TEST_P(FragmentShaderParameterAttributeTest, IsValid) {
auto& params = GetParam(); auto& params = GetParam();
auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind); auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind);
if (params.kind != AttributeKind::kBuiltin && params.kind != AttributeKind::kLocation) { if (params.kind != AttributeKind::kBuiltin && params.kind != AttributeKind::kLocation) {
attrs.Push(Builtin(Source{{34, 56}}, ast::BuiltinValue::kPosition)); attrs.Push(Builtin(Source{{34, 56}}, builtin::BuiltinValue::kPosition));
} }
auto* p = Param("a", ty.vec4<f32>(), attrs); auto* p = Param("a", ty.vec4<f32>(), attrs);
Func("frag_main", utils::Vector{p}, ty.void_(), utils::Empty, Func("frag_main", utils::Vector{p}, ty.void_(), utils::Empty,
@ -306,7 +306,7 @@ TEST_P(VertexShaderParameterAttributeTest, IsValid) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
if (params.should_pass) { if (params.should_pass) {
@ -453,7 +453,7 @@ TEST_P(VertexShaderReturnTypeAttributeTest, IsValid) {
auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind); auto attrs = createAttributes(Source{{12, 34}}, *this, params.kind);
// a vertex shader must include the 'position' builtin in its return type // a vertex shader must include the 'position' builtin in its return type
if (params.kind != AttributeKind::kBuiltin) { if (params.kind != AttributeKind::kBuiltin) {
attrs.Push(Builtin(Source{{34, 56}}, ast::BuiltinValue::kPosition)); attrs.Push(Builtin(Source{{34, 56}}, builtin::BuiltinValue::kPosition));
} }
Func("vertex_main", utils::Empty, ty.vec4<f32>(), Func("vertex_main", utils::Empty, ty.vec4<f32>(),
utils::Vector{ utils::Vector{
@ -654,7 +654,7 @@ TEST_F(StructMemberAttributeTest, InvariantAttributeWithPosition) {
Member("a", ty.vec4<f32>(), Member("a", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Invariant(), Invariant(),
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}), }),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -1374,7 +1374,7 @@ TEST_F(InvariantAttributeTests, InvariantWithPosition) {
auto* param = Param("p", ty.vec4<f32>(), auto* param = Param("p", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Invariant(Source{{12, 34}}), Invariant(Source{{12, 34}}),
Builtin(Source{{56, 78}}, ast::BuiltinValue::kPosition), Builtin(Source{{56, 78}}, builtin::BuiltinValue::kPosition),
}); });
Func("main", utils::Vector{param}, ty.vec4<f32>(), Func("main", utils::Vector{param}, ty.vec4<f32>(),
utils::Vector{ utils::Vector{
@ -1619,7 +1619,7 @@ TEST_F(InterpolateTest, VertexOutput_Integer_MissingFlatInterpolation) {
auto* s = Structure( auto* s = Structure(
"S", "S",
utils::Vector{ utils::Vector{
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
Member(Source{{12, 34}}, "u", ty.u32(), utils::Vector{Location(0_a)}), Member(Source{{12, 34}}, "u", ty.u32(), utils::Vector{Location(0_a)}),
}); });
Func("main", utils::Empty, ty.Of(s), Func("main", utils::Empty, ty.Of(s),
@ -1642,7 +1642,7 @@ TEST_F(InterpolateTest, MissingLocationAttribute_Parameter) {
utils::Vector{ utils::Vector{
Param("a", ty.vec4<f32>(), Param("a", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat, Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
ast::InterpolationSampling::kUndefined), ast::InterpolationSampling::kUndefined),
}), }),
@ -1666,7 +1666,7 @@ TEST_F(InterpolateTest, MissingLocationAttribute_ReturnType) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat, Interpolate(Source{{12, 34}}, ast::InterpolationType::kFlat,
ast::InterpolationSampling::kUndefined), ast::InterpolationSampling::kUndefined),
}); });

221
src/tint/resolver/builtins_validation_test.cc
View File

@ -33,67 +33,79 @@ class ResolverBuiltinsValidationTest : public resolver::TestHelper, public testi
namespace StageTest { namespace StageTest {
struct Params { struct Params {
builder::ast_type_func_ptr type; builder::ast_type_func_ptr type;
ast::BuiltinValue builtin; builtin::BuiltinValue builtin;
ast::PipelineStage stage; ast::PipelineStage stage;
bool is_valid; bool is_valid;
}; };
template <typename T> template <typename T>
constexpr Params ParamsFor(ast::BuiltinValue builtin, ast::PipelineStage stage, bool is_valid) { constexpr Params ParamsFor(builtin::BuiltinValue builtin, ast::PipelineStage stage, bool is_valid) {
return Params{DataType<T>::AST, builtin, stage, is_valid}; return Params{DataType<T>::AST, builtin, stage, is_valid};
} }
static constexpr Params cases[] = { static constexpr Params cases[] = {
ParamsFor<vec4<f32>>(ast::BuiltinValue::kPosition, ast::PipelineStage::kVertex, false), ParamsFor<vec4<f32>>(builtin::BuiltinValue::kPosition, ast::PipelineStage::kVertex, false),
ParamsFor<vec4<f32>>(ast::BuiltinValue::kPosition, ast::PipelineStage::kFragment, true), ParamsFor<vec4<f32>>(builtin::BuiltinValue::kPosition, ast::PipelineStage::kFragment, true),
ParamsFor<vec4<f32>>(ast::BuiltinValue::kPosition, ast::PipelineStage::kCompute, false), ParamsFor<vec4<f32>>(builtin::BuiltinValue::kPosition, ast::PipelineStage::kCompute, false),
ParamsFor<u32>(ast::BuiltinValue::kVertexIndex, ast::PipelineStage::kVertex, true), ParamsFor<u32>(builtin::BuiltinValue::kVertexIndex, ast::PipelineStage::kVertex, true),
ParamsFor<u32>(ast::BuiltinValue::kVertexIndex, ast::PipelineStage::kFragment, false), ParamsFor<u32>(builtin::BuiltinValue::kVertexIndex, ast::PipelineStage::kFragment, false),
ParamsFor<u32>(ast::BuiltinValue::kVertexIndex, ast::PipelineStage::kCompute, false), ParamsFor<u32>(builtin::BuiltinValue::kVertexIndex, ast::PipelineStage::kCompute, false),
ParamsFor<u32>(ast::BuiltinValue::kInstanceIndex, ast::PipelineStage::kVertex, true), ParamsFor<u32>(builtin::BuiltinValue::kInstanceIndex, ast::PipelineStage::kVertex, true),
ParamsFor<u32>(ast::BuiltinValue::kInstanceIndex, ast::PipelineStage::kFragment, false), ParamsFor<u32>(builtin::BuiltinValue::kInstanceIndex, ast::PipelineStage::kFragment, false),
ParamsFor<u32>(ast::BuiltinValue::kInstanceIndex, ast::PipelineStage::kCompute, false), ParamsFor<u32>(builtin::BuiltinValue::kInstanceIndex, ast::PipelineStage::kCompute, false),
ParamsFor<bool>(ast::BuiltinValue::kFrontFacing, ast::PipelineStage::kVertex, false), ParamsFor<bool>(builtin::BuiltinValue::kFrontFacing, ast::PipelineStage::kVertex, false),
ParamsFor<bool>(ast::BuiltinValue::kFrontFacing, ast::PipelineStage::kFragment, true), ParamsFor<bool>(builtin::BuiltinValue::kFrontFacing, ast::PipelineStage::kFragment, true),
ParamsFor<bool>(ast::BuiltinValue::kFrontFacing, ast::PipelineStage::kCompute, false), ParamsFor<bool>(builtin::BuiltinValue::kFrontFacing, ast::PipelineStage::kCompute, false),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kLocalInvocationId, ast::PipelineStage::kVertex, false), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kLocalInvocationId,
ParamsFor<vec3<u32>>(ast::BuiltinValue::kLocalInvocationId,
ast::PipelineStage::kFragment,
false),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kLocalInvocationId, ast::PipelineStage::kCompute, true),
ParamsFor<u32>(ast::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kVertex, false),
ParamsFor<u32>(ast::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kFragment, false),
ParamsFor<u32>(ast::BuiltinValue::kLocalInvocationIndex, ast::PipelineStage::kCompute, true),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kGlobalInvocationId,
ast::PipelineStage::kVertex, ast::PipelineStage::kVertex,
false), false),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kGlobalInvocationId, ParamsFor<vec3<u32>>(builtin::BuiltinValue::kLocalInvocationId,
ast::PipelineStage::kFragment, ast::PipelineStage::kFragment,
false), false),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kGlobalInvocationId, ParamsFor<vec3<u32>>(builtin::BuiltinValue::kLocalInvocationId,
ast::PipelineStage::kCompute, ast::PipelineStage::kCompute,
true), true),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kWorkgroupId, ast::PipelineStage::kVertex, false), ParamsFor<u32>(builtin::BuiltinValue::kLocalInvocationIndex,
ParamsFor<vec3<u32>>(ast::BuiltinValue::kWorkgroupId, ast::PipelineStage::kFragment, false), ast::PipelineStage::kVertex,
ParamsFor<vec3<u32>>(ast::BuiltinValue::kWorkgroupId, ast::PipelineStage::kCompute, true), false),
ParamsFor<u32>(builtin::BuiltinValue::kLocalInvocationIndex,
ast::PipelineStage::kFragment,
false),
ParamsFor<u32>(builtin::BuiltinValue::kLocalInvocationIndex,
ast::PipelineStage::kCompute,
true),
ParamsFor<vec3<u32>>(ast::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kVertex, false), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kGlobalInvocationId,
ParamsFor<vec3<u32>>(ast::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kFragment, false), ast::PipelineStage::kVertex,
ParamsFor<vec3<u32>>(ast::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kCompute, true), false),
ParamsFor<vec3<u32>>(builtin::BuiltinValue::kGlobalInvocationId,
ast::PipelineStage::kFragment,
false),
ParamsFor<vec3<u32>>(builtin::BuiltinValue::kGlobalInvocationId,
ast::PipelineStage::kCompute,
true),
ParamsFor<u32>(ast::BuiltinValue::kSampleIndex, ast::PipelineStage::kVertex, false), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kWorkgroupId, ast::PipelineStage::kVertex, false),
ParamsFor<u32>(ast::BuiltinValue::kSampleIndex, ast::PipelineStage::kFragment, true), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kWorkgroupId, ast::PipelineStage::kFragment, false),
ParamsFor<u32>(ast::BuiltinValue::kSampleIndex, ast::PipelineStage::kCompute, false), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kWorkgroupId, ast::PipelineStage::kCompute, true),
ParamsFor<u32>(ast::BuiltinValue::kSampleMask, ast::PipelineStage::kVertex, false), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kVertex, false),
ParamsFor<u32>(ast::BuiltinValue::kSampleMask, ast::PipelineStage::kFragment, true), ParamsFor<vec3<u32>>(builtin::BuiltinValue::kNumWorkgroups,
ParamsFor<u32>(ast::BuiltinValue::kSampleMask, ast::PipelineStage::kCompute, false), ast::PipelineStage::kFragment,
false),
ParamsFor<vec3<u32>>(builtin::BuiltinValue::kNumWorkgroups, ast::PipelineStage::kCompute, true),
ParamsFor<u32>(builtin::BuiltinValue::kSampleIndex, ast::PipelineStage::kVertex, false),
ParamsFor<u32>(builtin::BuiltinValue::kSampleIndex, ast::PipelineStage::kFragment, true),
ParamsFor<u32>(builtin::BuiltinValue::kSampleIndex, ast::PipelineStage::kCompute, false),
ParamsFor<u32>(builtin::BuiltinValue::kSampleMask, ast::PipelineStage::kVertex, false),
ParamsFor<u32>(builtin::BuiltinValue::kSampleMask, ast::PipelineStage::kFragment, true),
ParamsFor<u32>(builtin::BuiltinValue::kSampleMask, ast::PipelineStage::kCompute, false),
}; };
using ResolverBuiltinsStageTest = ResolverTestWithParam<Params>; using ResolverBuiltinsStageTest = ResolverTestWithParam<Params>;
@ -108,7 +120,7 @@ TEST_P(ResolverBuiltinsStageTest, All_input) {
Func("main", utils::Vector{input}, ty.vec4<f32>(), utils::Vector{Return(p)}, Func("main", utils::Vector{input}, ty.vec4<f32>(), utils::Vector{Return(p)},
utils::Vector{Stage(ast::PipelineStage::kVertex)}, utils::Vector{Stage(ast::PipelineStage::kVertex)},
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kPosition), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kPosition),
}); });
break; break;
case ast::PipelineStage::kFragment: case ast::PipelineStage::kFragment:
@ -152,7 +164,7 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInput_Fail) {
utils::Vector{ utils::Vector{
Param("fd", ty.f32(), Param("fd", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFragDepth), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFragDepth),
}), }),
}, },
ty.f32(), ty.f32(),
@ -182,7 +194,7 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsInputStruct_Fail) {
utils::Vector{ utils::Vector{
Member("frag_depth", ty.f32(), Member("frag_depth", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFragDepth), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFragDepth),
}), }),
}); });
@ -217,7 +229,7 @@ TEST_F(ResolverBuiltinsValidationTest, StructBuiltinInsideEntryPoint_Ignored) {
Structure("S", utils::Vector{ Structure("S", utils::Vector{
Member("idx", ty.u32(), Member("idx", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kVertexIndex), Builtin(builtin::BuiltinValue::kVertexIndex),
}), }),
}); });
@ -241,7 +253,7 @@ TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_Struct_Fail) {
utils::Vector{ utils::Vector{
Member("position", ty.vec4<u32>(), Member("position", ty.vec4<u32>(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kPosition), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kPosition),
}), }),
}); });
Func("fragShader", Func("fragShader",
@ -272,7 +284,7 @@ TEST_F(ResolverBuiltinsValidationTest, PositionNotF32_ReturnType_Fail) {
}, },
utils::Vector{Stage(ast::PipelineStage::kVertex)}, utils::Vector{Stage(ast::PipelineStage::kVertex)},
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kPosition), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kPosition),
}); });
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -290,7 +302,7 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthNotF32_Struct_Fail) {
utils::Vector{ utils::Vector{
Member("frag_depth", ty.i32(), Member("frag_depth", ty.i32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFragDepth), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFragDepth),
}), }),
}); });
Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(), Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(),
@ -315,13 +327,13 @@ TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_Struct_Fail) {
// @fragment // @fragment
// fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
auto* s = Structure("MyInputs", auto* s = Structure(
utils::Vector{ "MyInputs", utils::Vector{
Member("m", ty.f32(), Member("m", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kSampleMask), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kSampleMask),
}), }),
}); });
Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(), Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(),
utils::Vector{ utils::Vector{
Return(1_f), Return(1_f),
@ -345,7 +357,7 @@ TEST_F(ResolverBuiltinsValidationTest, SampleMaskNotU32_ReturnType_Fail) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kSampleMask), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kSampleMask),
}); });
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -361,7 +373,7 @@ TEST_F(ResolverBuiltinsValidationTest, SampleMaskIsNotU32_Fail) {
utils::Vector{ utils::Vector{
Param("arg", ty.bool_(), Param("arg", ty.bool_(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kSampleMask), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kSampleMask),
}), }),
}, },
ty.f32(), ty.f32(),
@ -385,13 +397,13 @@ TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Struct_Fail) {
// @fragment // @fragment
// fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
auto* s = Structure("MyInputs", auto* s = Structure(
utils::Vector{ "MyInputs", utils::Vector{
Member("m", ty.f32(), Member("m", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kSampleIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kSampleIndex),
}), }),
}); });
Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(), Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(),
utils::Vector{ utils::Vector{
Return(1_f), Return(1_f),
@ -416,7 +428,7 @@ TEST_F(ResolverBuiltinsValidationTest, SampleIndexIsNotU32_Fail) {
utils::Vector{ utils::Vector{
Param("arg", ty.bool_(), Param("arg", ty.bool_(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kSampleIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kSampleIndex),
}), }),
}, },
ty.f32(), ty.f32(),
@ -442,7 +454,7 @@ TEST_F(ResolverBuiltinsValidationTest, PositionIsNotF32_Fail) {
utils::Vector{ utils::Vector{
Param("p", ty.vec3<f32>(), Param("p", ty.vec3<f32>(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kPosition), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kPosition),
}), }),
}, },
ty.f32(), ty.f32(),
@ -472,7 +484,7 @@ TEST_F(ResolverBuiltinsValidationTest, FragDepthIsNotF32_Fail) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFragDepth), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFragDepth),
}); });
EXPECT_FALSE(r()->Resolve()); 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'");
@ -486,18 +498,18 @@ TEST_F(ResolverBuiltinsValidationTest, VertexIndexIsNotU32_Fail) {
// ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); } // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); }
auto* p = Param("p", ty.vec4<f32>(), auto* p = Param("p", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
auto* vi = Param("vi", ty.f32(), auto* vi = Param("vi", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kVertexIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kVertexIndex),
}); });
Func("main", utils::Vector{vi, p}, ty.vec4<f32>(), utils::Vector{Return(Expr("p"))}, Func("main", utils::Vector{vi, p}, ty.vec4<f32>(), utils::Vector{Return(Expr("p"))},
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_FALSE(r()->Resolve()); 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'");
@ -511,18 +523,18 @@ TEST_F(ResolverBuiltinsValidationTest, InstanceIndexIsNotU32) {
// ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); } // ) -> @builtin(kPosition) vec4<f32> { return vec4<f32>(); }
auto* p = Param("p", ty.vec4<f32>(), auto* p = Param("p", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
auto* ii = Param("ii", ty.f32(), auto* ii = Param("ii", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kInstanceIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kInstanceIndex),
}); });
Func("main", utils::Vector{ii, p}, ty.vec4<f32>(), utils::Vector{Return(Expr("p"))}, Func("main", utils::Vector{ii, p}, ty.vec4<f32>(), utils::Vector{Return(Expr("p"))},
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_FALSE(r()->Resolve()); 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'");
@ -538,19 +550,19 @@ TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) {
// ) -> @builtin(frag_depth) f32 { var fd: f32; return fd; } // ) -> @builtin(frag_depth) f32 { var fd: f32; return fd; }
auto* p = Param("p", ty.vec4<f32>(), auto* p = Param("p", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
auto* ff = Param("ff", ty.bool_(), auto* ff = Param("ff", ty.bool_(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFrontFacing), Builtin(builtin::BuiltinValue::kFrontFacing),
}); });
auto* si = Param("si", ty.u32(), auto* si = Param("si", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
}); });
auto* sm = Param("sm", ty.u32(), auto* sm = Param("sm", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleMask), Builtin(builtin::BuiltinValue::kSampleMask),
}); });
auto* var_fd = Var("fd", ty.f32()); auto* var_fd = Var("fd", ty.f32());
Func("fs_main", utils::Vector{p, ff, si, sm}, ty.f32(), Func("fs_main", utils::Vector{p, ff, si, sm}, ty.f32(),
@ -562,7 +574,7 @@ TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltin_Pass) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
} }
@ -575,12 +587,12 @@ TEST_F(ResolverBuiltinsValidationTest, VertexBuiltin_Pass) {
// ) -> @builtin(position) vec4<f32> { var p :vec4<f32>; return p; } // ) -> @builtin(position) vec4<f32> { var p :vec4<f32>; return p; }
auto* vi = Param("vi", ty.u32(), auto* vi = Param("vi", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kVertexIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kVertexIndex),
}); });
auto* ii = Param("ii", ty.u32(), auto* ii = Param("ii", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kInstanceIndex), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kInstanceIndex),
}); });
auto* p = Var("p", ty.vec4<f32>()); auto* p = Var("p", ty.vec4<f32>());
Func("main", utils::Vector{vi, ii}, ty.vec4<f32>(), Func("main", utils::Vector{vi, ii}, ty.vec4<f32>(),
@ -590,7 +602,7 @@ TEST_F(ResolverBuiltinsValidationTest, VertexBuiltin_Pass) {
}, },
utils::Vector{Stage(ast::PipelineStage::kVertex)}, utils::Vector{Stage(ast::PipelineStage::kVertex)},
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -608,23 +620,23 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_Pass) {
auto* li_id = Param("li_id", ty.vec3<u32>(), auto* li_id = Param("li_id", ty.vec3<u32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kLocalInvocationId), Builtin(builtin::BuiltinValue::kLocalInvocationId),
}); });
auto* li_index = Param("li_index", ty.u32(), auto* li_index = Param("li_index", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kLocalInvocationIndex), Builtin(builtin::BuiltinValue::kLocalInvocationIndex),
}); });
auto* gi = Param("gi", ty.vec3<u32>(), auto* gi = Param("gi", ty.vec3<u32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kGlobalInvocationId), Builtin(builtin::BuiltinValue::kGlobalInvocationId),
}); });
auto* wi = Param("wi", ty.vec3<u32>(), auto* wi = Param("wi", ty.vec3<u32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kWorkgroupId), Builtin(builtin::BuiltinValue::kWorkgroupId),
}); });
auto* nwgs = Param("nwgs", ty.vec3<u32>(), auto* nwgs = Param("nwgs", ty.vec3<u32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kNumWorkgroups), Builtin(builtin::BuiltinValue::kNumWorkgroups),
}); });
Func("main", utils::Vector{li_id, li_index, gi, wi, nwgs}, ty.void_(), utils::Empty, Func("main", utils::Vector{li_id, li_index, gi, wi, nwgs}, ty.void_(), utils::Empty,
@ -637,7 +649,7 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_Pass) {
TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) { TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) {
auto* wi = Param("wi", ty.f32(), auto* wi = Param("wi", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kWorkgroupId), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kWorkgroupId),
}); });
Func("main", utils::Vector{wi}, ty.void_(), utils::Empty, Func("main", utils::Vector{wi}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
@ -652,7 +664,7 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_WorkGroupIdNotVec3U32) {
TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) { TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) {
auto* nwgs = Param("nwgs", ty.f32(), auto* nwgs = Param("nwgs", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kNumWorkgroups), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kNumWorkgroups),
}); });
Func("main", utils::Vector{nwgs}, ty.void_(), utils::Empty, Func("main", utils::Vector{nwgs}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
@ -667,7 +679,7 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_NumWorkgroupsNotVec3U32) {
TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32) { TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32) {
auto* gi = Param("gi", ty.vec3<i32>(), auto* gi = Param("gi", ty.vec3<i32>(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kGlobalInvocationId), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kGlobalInvocationId),
}); });
Func("main", utils::Vector{gi}, ty.void_(), utils::Empty, Func("main", utils::Vector{gi}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
@ -680,10 +692,11 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_GlobalInvocationNotVec3U32
} }
TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32) { TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32) {
auto* li_index = Param("li_index", ty.vec3<u32>(), auto* li_index =
utils::Vector{ Param("li_index", ty.vec3<u32>(),
Builtin(Source{{12, 34}}, ast::BuiltinValue::kLocalInvocationIndex), utils::Vector{
}); Builtin(Source{{12, 34}}, builtin::BuiltinValue::kLocalInvocationIndex),
});
Func("main", utils::Vector{li_index}, ty.void_(), utils::Empty, Func("main", utils::Vector{li_index}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))}); WorkgroupSize(Expr(Source{Source::Location{12, 34}}, 2_i))});
@ -697,7 +710,7 @@ TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationIndexNotU32
TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationNotVec3U32) { TEST_F(ResolverBuiltinsValidationTest, ComputeBuiltin_LocalInvocationNotVec3U32) {
auto* li_id = Param("li_id", ty.vec2<u32>(), auto* li_id = Param("li_id", ty.vec2<u32>(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kLocalInvocationId), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kLocalInvocationId),
}); });
Func("main", utils::Vector{li_id}, ty.void_(), utils::Empty, Func("main", utils::Vector{li_id}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), utils::Vector{Stage(ast::PipelineStage::kCompute),
@ -722,19 +735,19 @@ TEST_F(ResolverBuiltinsValidationTest, FragmentBuiltinStruct_Pass) {
auto* s = Structure("MyInputs", utils::Vector{ auto* s = Structure("MyInputs", utils::Vector{
Member("position", ty.vec4<f32>(), Member("position", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}), }),
Member("front_facing", ty.bool_(), Member("front_facing", ty.bool_(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFrontFacing), Builtin(builtin::BuiltinValue::kFrontFacing),
}), }),
Member("sample_index", ty.u32(), Member("sample_index", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
}), }),
Member("sample_mask", ty.u32(), Member("sample_mask", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleMask), Builtin(builtin::BuiltinValue::kSampleMask),
}), }),
}); });
Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(), Func("fragShader", utils::Vector{Param("arg", ty.Of(s))}, ty.f32(),
@ -758,7 +771,7 @@ TEST_F(ResolverBuiltinsValidationTest, FrontFacingParamIsNotBool_Fail) {
auto* is_front = Param("is_front", ty.i32(), auto* is_front = Param("is_front", ty.i32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFrontFacing), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFrontFacing),
}); });
Func("fs_main", utils::Vector{is_front}, ty.f32(), Func("fs_main", utils::Vector{is_front}, ty.f32(),
utils::Vector{ utils::Vector{
@ -782,13 +795,13 @@ TEST_F(ResolverBuiltinsValidationTest, FrontFacingMemberIsNotBool_Fail) {
// @fragment // @fragment
// fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; } // fn fragShader(is_front: MyInputs) -> @location(0) f32 { return 1.0; }
auto* s = Structure("MyInputs", auto* s = Structure(
utils::Vector{ "MyInputs", utils::Vector{
Member("pos", ty.f32(), Member("pos", ty.f32(),
utils::Vector{ utils::Vector{
Builtin(Source{{12, 34}}, ast::BuiltinValue::kFrontFacing), Builtin(Source{{12, 34}}, builtin::BuiltinValue::kFrontFacing),
}), }),
}); });
Func("fragShader", utils::Vector{Param("is_front", ty.Of(s))}, ty.f32(), Func("fragShader", utils::Vector{Param("is_front", ty.Of(s))}, ty.f32(),
utils::Vector{ utils::Vector{
Return(1_f), Return(1_f),

54
src/tint/resolver/entry_point_validation_test.cc
View File

@ -74,7 +74,7 @@ TEST_F(ResolverEntryPointValidationTest, ReturnTypeAttribute_Builtin) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -111,7 +111,7 @@ TEST_F(ResolverEntryPointValidationTest, ReturnTypeAttribute_Multiple) {
}, },
utils::Vector{ utils::Vector{
Location(Source{{13, 43}}, 0_a), Location(Source{{13, 43}}, 0_a),
Builtin(Source{{14, 52}}, ast::BuiltinValue::kPosition), Builtin(Source{{14, 52}}, builtin::BuiltinValue::kPosition),
}); });
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
@ -129,10 +129,11 @@ TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_Valid) {
// return Output(); // return Output();
// } // }
auto* output = Structure( auto* output = Structure(
"Output", utils::Vector{ "Output",
Member("a", ty.f32(), utils::Vector{Location(0_a)}), utils::Vector{
Member("b", ty.f32(), utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}), Member("a", ty.f32(), utils::Vector{Location(0_a)}),
}); Member("b", ty.f32(), utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)}),
});
Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output), Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output),
utils::Vector{ utils::Vector{
Return(Call(ty.Of(output))), Return(Call(ty.Of(output))),
@ -157,7 +158,7 @@ TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_MemberMultipleAttribu
utils::Vector{ utils::Vector{
Member("a", ty.f32(), Member("a", ty.f32(),
utils::Vector{Location(Source{{13, 43}}, 0_a), utils::Vector{Location(Source{{13, 43}}, 0_a),
Builtin(Source{{14, 52}}, ast::BuiltinValue::kFragDepth)}), Builtin(Source{{14, 52}}, builtin::BuiltinValue::kFragDepth)}),
}); });
Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output), Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output),
utils::Vector{ utils::Vector{
@ -211,10 +212,11 @@ TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_DuplicateBuiltins) {
// return Output(); // return Output();
// } // }
auto* output = Structure( auto* output = Structure(
"Output", utils::Vector{ "Output",
Member("a", ty.f32(), utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}), utils::Vector{
Member("b", ty.f32(), utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}), Member("a", ty.f32(), utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)}),
}); Member("b", ty.f32(), utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)}),
});
Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output), Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output),
utils::Vector{ utils::Vector{
Return(Call(ty.Of(output))), Return(Call(ty.Of(output))),
@ -272,7 +274,7 @@ TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Multiple) {
auto* param = Param("param", ty.u32(), auto* param = Param("param", ty.u32(),
utils::Vector{ utils::Vector{
Location(Source{{13, 43}}, 0_a), Location(Source{{13, 43}}, 0_a),
Builtin(Source{{14, 52}}, ast::BuiltinValue::kSampleIndex), Builtin(Source{{14, 52}}, builtin::BuiltinValue::kSampleIndex),
}); });
Func(Source{{12, 34}}, "main", Func(Source{{12, 34}}, "main",
utils::Vector{ utils::Vector{
@ -296,10 +298,11 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_Valid) {
// @fragment // @fragment
// fn main(param : Input) {} // fn main(param : Input) {}
auto* input = Structure( auto* input = Structure(
"Input", utils::Vector{ "Input",
Member("a", ty.f32(), utils::Vector{Location(0_a)}), utils::Vector{
Member("b", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)}), Member("a", ty.f32(), utils::Vector{Location(0_a)}),
}); Member("b", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)}),
});
auto* param = Param("param", ty.Of(input)); auto* param = Param("param", ty.Of(input));
Func(Source{{12, 34}}, "main", Func(Source{{12, 34}}, "main",
utils::Vector{ utils::Vector{
@ -324,7 +327,7 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_MemberMultipleAttribut
utils::Vector{ utils::Vector{
Member("a", ty.u32(), Member("a", ty.u32(),
utils::Vector{Location(Source{{13, 43}}, 0_a), utils::Vector{Location(Source{{13, 43}}, 0_a),
Builtin(Source{{14, 52}}, ast::BuiltinValue::kSampleIndex)}), Builtin(Source{{14, 52}}, builtin::BuiltinValue::kSampleIndex)}),
}); });
auto* param = Param("param", ty.Of(input)); auto* param = Param("param", ty.Of(input));
Func(Source{{12, 34}}, "main", Func(Source{{12, 34}}, "main",
@ -375,11 +378,11 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_DuplicateBuiltins) {
// @builtin(sample_index) param_b : u32) {} // @builtin(sample_index) param_b : u32) {}
auto* param_a = Param("param_a", ty.u32(), auto* param_a = Param("param_a", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
}); });
auto* param_b = Param("param_b", ty.u32(), auto* param_b = Param("param_b", ty.u32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
}); });
Func(Source{{12, 34}}, "main", Func(Source{{12, 34}}, "main",
utils::Vector{ utils::Vector{
@ -409,12 +412,12 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_DuplicateBuiltins) {
auto* input_a = Structure( auto* input_a = Structure(
"InputA", "InputA",
utils::Vector{ utils::Vector{
Member("a", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)}), Member("a", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)}),
}); });
auto* input_b = Structure( auto* input_b = Structure(
"InputB", "InputB",
utils::Vector{ utils::Vector{
Member("a", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)}), Member("a", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)}),
}); });
auto* param_a = Param("param_a", ty.Of(input_a)); auto* param_a = Param("param_a", ty.Of(input_a));
auto* param_b = Param("param_b", ty.Of(input_b)); auto* param_b = Param("param_b", ty.Of(input_b));
@ -984,10 +987,11 @@ TEST_F(LocationAttributeTests, ReturnType_Struct_Valid) {
// return Output(); // return Output();
// } // }
auto* output = Structure( auto* output = Structure(
"Output", utils::Vector{ "Output",
Member("a", ty.f32(), utils::Vector{Location(0_a)}), utils::Vector{
Member("b", ty.f32(), utils::Vector{Builtin(ast::BuiltinValue::kFragDepth)}), Member("a", ty.f32(), utils::Vector{Location(0_a)}),
}); Member("b", ty.f32(), utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)}),
});
Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output), Func(Source{{12, 34}}, "main", utils::Empty, ty.Of(output),
utils::Vector{ utils::Vector{
Return(Call(ty.Of(output))), Return(Call(ty.Of(output))),

2
src/tint/resolver/function_validation_test.cc
View File

@ -188,7 +188,7 @@ TEST_F(ResolverFunctionValidationTest, DiscardCalledDirectlyFromVertexEntryPoint
Return(Call(ty.vec4<f32>())), Return(Call(ty.vec4<f32>())),
}, },
utils::Vector{Stage(ast::PipelineStage::kVertex)}, utils::Vector{Stage(ast::PipelineStage::kVertex)},
utils::Vector{Builtin(ast::BuiltinValue::kPosition)}); utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), EXPECT_EQ(r()->error(),

7
src/tint/resolver/resolver_test.cc
View File

@ -873,7 +873,8 @@ TEST_F(ResolverTest, Function_Parameters) {
TEST_F(ResolverTest, Function_Parameters_Locations) { TEST_F(ResolverTest, Function_Parameters_Locations) {
auto* param_a = Param("a", ty.f32(), utils::Vector{Location(3_a)}); auto* param_a = Param("a", ty.f32(), utils::Vector{Location(3_a)});
auto* param_b = Param("b", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kVertexIndex)}); auto* param_b =
Param("b", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kVertexIndex)});
auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)}); auto* param_c = Param("c", ty.u32(), utils::Vector{Location(1_a)});
GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate); GlobalVar("my_vec", ty.vec4<f32>(), type::AddressSpace::kPrivate);
@ -891,7 +892,7 @@ TEST_F(ResolverTest, Function_Parameters_Locations) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();
@ -974,7 +975,7 @@ TEST_F(ResolverTest, Function_ReturnType_NoLocation) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_TRUE(r()->Resolve()) << r()->error(); EXPECT_TRUE(r()->Resolve()) << r()->error();

19
src/tint/resolver/struct_pipeline_stage_use_test.cc
View File

@ -69,7 +69,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderParam) {
Func("main", utils::Vector{Param("param", ty.Of(s))}, ty.vec4<f32>(), Func("main", utils::Vector{Param("param", ty.Of(s))}, ty.vec4<f32>(),
utils::Vector{Return(Call(ty.vec4<f32>()))}, utils::Vector{Return(Call(ty.vec4<f32>()))},
utils::Vector{Stage(ast::PipelineStage::kVertex)}, utils::Vector{Stage(ast::PipelineStage::kVertex)},
utils::Vector{Builtin(ast::BuiltinValue::kPosition)}); utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
ASSERT_TRUE(r()->Resolve()) << r()->error(); ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -80,9 +80,9 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderParam) {
} }
TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderReturnType) { TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderReturnType) {
auto* s = auto* s = Structure(
Structure("S", utils::Vector{Member("a", ty.vec4<f32>(), "S", utils::Vector{Member("a", ty.vec4<f32>(),
utils::Vector{Builtin(ast::BuiltinValue::kPosition)})}); utils::Vector{Builtin(builtin::BuiltinValue::kPosition)})});
Func("main", utils::Empty, ty.Of(s), utils::Vector{Return(Call(ty.Of(s)))}, Func("main", utils::Empty, ty.Of(s), utils::Vector{Return(Call(ty.Of(s)))},
utils::Vector{Stage(ast::PipelineStage::kVertex)}); utils::Vector{Stage(ast::PipelineStage::kVertex)});
@ -125,8 +125,9 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderReturnType) {
TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) { TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
auto* s = Structure( auto* s = Structure(
"S", utils::Vector{Member( "S",
"a", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kLocalInvocationIndex)})}); utils::Vector{Member(
"a", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kLocalInvocationIndex)})});
Func("main", utils::Vector{Param("param", ty.Of(s))}, ty.void_(), utils::Empty, Func("main", utils::Vector{Param("param", ty.Of(s))}, ty.void_(), utils::Empty,
utils::Vector{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)}); utils::Vector{Stage(ast::PipelineStage::kCompute), WorkgroupSize(1_i)});
@ -140,9 +141,9 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
} }
TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) { TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) {
auto* s = auto* s = Structure(
Structure("S", utils::Vector{Member("a", ty.vec4<f32>(), "S", utils::Vector{Member("a", ty.vec4<f32>(),
utils::Vector{Builtin(ast::BuiltinValue::kPosition)})}); utils::Vector{Builtin(builtin::BuiltinValue::kPosition)})});
Func("vert_main", utils::Empty, ty.Of(s), utils::Vector{Return(Call(ty.Of(s)))}, Func("vert_main", utils::Empty, ty.Of(s), utils::Vector{Return(Call(ty.Of(s)))},
utils::Vector{Stage(ast::PipelineStage::kVertex)}); utils::Vector{Stage(ast::PipelineStage::kVertex)});

4
src/tint/resolver/uniformity.cc
View File

@ -1148,8 +1148,8 @@ class UniformityGraph {
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. // Only the num_workgroups and workgroup_id builtins are uniform.
if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(obj->attributes)) { if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(obj->attributes)) {
if (builtin->builtin == ast::BuiltinValue::kNumWorkgroups || if (builtin->builtin == builtin::BuiltinValue::kNumWorkgroups ||
builtin->builtin == ast::BuiltinValue::kWorkgroupId) { builtin->builtin == builtin::BuiltinValue::kWorkgroupId) {
return false; return false;
} }
} }

2
src/tint/resolver/validation_test.cc
View File

@ -75,7 +75,7 @@ TEST_F(ResolverValidationTest, WorkgroupMemoryUsedInVertexStage) {
Stage(ast::PipelineStage::kVertex), Stage(ast::PipelineStage::kVertex),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
EXPECT_FALSE(r()->Resolve()); EXPECT_FALSE(r()->Resolve());

34
src/tint/resolver/validator.cc
View File

@ -868,7 +868,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
bool is_stage_mismatch = false; bool is_stage_mismatch = false;
bool is_output = !is_input; bool is_output = !is_input;
switch (attr->builtin) { switch (attr->builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!((is_input && stage == ast::PipelineStage::kFragment) || !((is_input && stage == ast::PipelineStage::kFragment) ||
(is_output && stage == ast::PipelineStage::kVertex))) { (is_output && stage == ast::PipelineStage::kVertex))) {
@ -880,10 +880,10 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
case ast::BuiltinValue::kNumWorkgroups: case builtin::BuiltinValue::kNumWorkgroups:
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kCompute && is_input)) { !(stage == ast::PipelineStage::kCompute && is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -894,7 +894,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kFragment && !is_input)) { !(stage == ast::PipelineStage::kFragment && !is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -904,7 +904,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kFragment && is_input)) { !(stage == ast::PipelineStage::kFragment && is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -914,7 +914,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kCompute && is_input)) { !(stage == ast::PipelineStage::kCompute && is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -924,8 +924,8 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kVertex && is_input)) { !(stage == ast::PipelineStage::kVertex && is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -935,7 +935,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
if (stage != ast::PipelineStage::kNone && !(stage == ast::PipelineStage::kFragment)) { if (stage != ast::PipelineStage::kNone && !(stage == ast::PipelineStage::kFragment)) {
is_stage_mismatch = true; is_stage_mismatch = true;
} }
@ -944,7 +944,7 @@ bool Validator::BuiltinAttribute(const ast::BuiltinAttribute* attr,
return false; return false;
} }
break; break;
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
if (stage != ast::PipelineStage::kNone && if (stage != ast::PipelineStage::kNone &&
!(stage == ast::PipelineStage::kFragment && is_input)) { !(stage == ast::PipelineStage::kFragment && is_input)) {
is_stage_mismatch = true; is_stage_mismatch = true;
@ -1076,7 +1076,7 @@ bool Validator::EntryPoint(const sem::Function* func, ast::PipelineStage stage)
// order to catch conflicts. // order to catch conflicts.
// TODO(jrprice): This state could be stored in sem::Function instead, and then passed to // TODO(jrprice): This state could be stored in sem::Function instead, and then passed to
// sem::Function since it would be useful there too. // sem::Function since it would be useful there too.
utils::Hashset<ast::BuiltinValue, 4> builtins; utils::Hashset<builtin::BuiltinValue, 4> builtins;
utils::Hashset<uint32_t, 8> locations; utils::Hashset<uint32_t, 8> locations;
enum class ParamOrRetType { enum class ParamOrRetType {
kParameter, kParameter,
@ -1211,7 +1211,7 @@ bool Validator::EntryPoint(const sem::Function* func, ast::PipelineStage stage)
bool has_position = false; bool has_position = false;
if (pipeline_io_attribute) { if (pipeline_io_attribute) {
if (auto* builtin = pipeline_io_attribute->As<ast::BuiltinAttribute>()) { if (auto* builtin = pipeline_io_attribute->As<ast::BuiltinAttribute>()) {
has_position = (builtin->builtin == ast::BuiltinValue::kPosition); has_position = (builtin->builtin == builtin::BuiltinValue::kPosition);
} }
} }
if (!has_position) { if (!has_position) {
@ -1275,13 +1275,13 @@ bool Validator::EntryPoint(const sem::Function* func, ast::PipelineStage stage)
} }
if (decl->PipelineStage() == ast::PipelineStage::kVertex && if (decl->PipelineStage() == ast::PipelineStage::kVertex &&
!builtins.Contains(ast::BuiltinValue::kPosition)) { !builtins.Contains(builtin::BuiltinValue::kPosition)) {
// Check module-scope variables, as the SPIR-V sanitizer generates these. // Check module-scope variables, as the SPIR-V sanitizer generates these.
bool found = false; bool found = false;
for (auto* global : func->TransitivelyReferencedGlobals()) { for (auto* global : func->TransitivelyReferencedGlobals()) {
if (auto* builtin = if (auto* builtin =
ast::GetAttribute<ast::BuiltinAttribute>(global->Declaration()->attributes)) { ast::GetAttribute<ast::BuiltinAttribute>(global->Declaration()->attributes)) {
if (builtin->builtin == ast::BuiltinValue::kPosition) { if (builtin->builtin == builtin::BuiltinValue::kPosition) {
found = true; found = true;
break; break;
} }
@ -2123,7 +2123,7 @@ bool Validator::Structure(const sem::Struct* str, ast::PipelineStage stage) cons
/* is_input */ false)) { /* is_input */ false)) {
return false; return false;
} }
if (builtin->builtin == ast::BuiltinValue::kPosition) { if (builtin->builtin == builtin::BuiltinValue::kPosition) {
has_position = true; has_position = true;
} }
return true; return true;

82
src/tint/transform/canonicalize_entry_point_io.cc
View File

@ -47,33 +47,33 @@ struct MemberInfo {
/// FXC is sensitive to field order in structures, this is used by StructMemberComparator to ensure /// FXC is sensitive to field order in structures, this is used by StructMemberComparator to ensure
/// that FXC is happy with the order of emitted fields. /// that FXC is happy with the order of emitted fields.
uint32_t BuiltinOrder(ast::BuiltinValue builtin) { uint32_t BuiltinOrder(builtin::BuiltinValue builtin) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
return 1; return 1;
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
return 2; return 2;
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
return 3; return 3;
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
return 4; return 4;
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
return 5; return 5;
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
return 6; return 6;
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
return 7; return 7;
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
return 8; return 8;
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
return 9; return 9;
case ast::BuiltinValue::kNumWorkgroups: case builtin::BuiltinValue::kNumWorkgroups:
return 10; return 10;
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
return 11; return 11;
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
return 12; return 12;
case ast::BuiltinValue::kPointSize: case builtin::BuiltinValue::kPointSize:
return 13; return 13;
default: default:
break; break;
@ -118,7 +118,7 @@ bool IsShaderIOAttribute(const ast::Attribute* attr) {
// Returns true if `attrs` contains a `sample_mask` builtin. // Returns true if `attrs` contains a `sample_mask` builtin.
bool HasSampleMask(utils::VectorRef<const ast::Attribute*> attrs) { bool HasSampleMask(utils::VectorRef<const ast::Attribute*> attrs) {
auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attrs); auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(attrs);
return builtin && builtin->builtin == ast::BuiltinValue::kSampleMask; return builtin && builtin->builtin == builtin::BuiltinValue::kSampleMask;
} }
} // namespace } // namespace
@ -244,7 +244,7 @@ struct CanonicalizeEntryPointIO::State {
if (builtin) { if (builtin) {
if (cfg.shader_style == ShaderStyle::kGlsl) { if (cfg.shader_style == ShaderStyle::kGlsl) {
value = FromGLSLBuiltin(builtin->builtin, value, ast_type); value = FromGLSLBuiltin(builtin->builtin, value, ast_type);
} else if (builtin->builtin == ast::BuiltinValue::kSampleMask) { } else if (builtin->builtin == builtin::BuiltinValue::kSampleMask) {
// Vulkan requires the type of a SampleMask builtin to be an array. // Vulkan requires the type of a SampleMask builtin to be an array.
// Declare it as array<u32, 1> and then load the first element. // Declare it as array<u32, 1> and then load the first element.
ast_type = ctx.dst->ty.array(ast_type, 1_u); ast_type = ctx.dst->ty.array(ast_type, 1_u);
@ -422,7 +422,7 @@ struct CanonicalizeEntryPointIO::State {
// No existing sample mask builtin was found, so create a new output value // No existing sample mask builtin was found, so create a new output value
// using the fixed sample mask. // using the fixed sample mask.
AddOutput("fixed_sample_mask", ctx.dst->create<type::U32>(), std::nullopt, AddOutput("fixed_sample_mask", ctx.dst->create<type::U32>(), std::nullopt,
{ctx.dst->Builtin(ast::BuiltinValue::kSampleMask)}, {ctx.dst->Builtin(builtin::BuiltinValue::kSampleMask)},
ctx.dst->Expr(u32(cfg.fixed_sample_mask))); ctx.dst->Expr(u32(cfg.fixed_sample_mask)));
} }
@ -430,7 +430,7 @@ struct CanonicalizeEntryPointIO::State {
void AddVertexPointSize() { void AddVertexPointSize() {
// Create a new output value and assign it a literal 1.0 value. // Create a new output value and assign it a literal 1.0 value.
AddOutput("vertex_point_size", ctx.dst->create<type::F32>(), std::nullopt, AddOutput("vertex_point_size", ctx.dst->create<type::F32>(), std::nullopt,
{ctx.dst->Builtin(ast::BuiltinValue::kPointSize)}, ctx.dst->Expr(1_f)); {ctx.dst->Builtin(builtin::BuiltinValue::kPointSize)}, ctx.dst->Expr(1_f));
} }
/// Create an expression for gl_Position.[component] /// Create an expression for gl_Position.[component]
@ -675,11 +675,11 @@ struct CanonicalizeEntryPointIO::State {
/// @param stage the current pipeline stage /// @param stage the current pipeline stage
/// @param address_space the address space (input or output) /// @param address_space the address space (input or output)
/// @returns the gl_ string corresponding to that builtin /// @returns the gl_ string corresponding to that builtin
const char* GLSLBuiltinToString(ast::BuiltinValue builtin, const char* GLSLBuiltinToString(builtin::BuiltinValue builtin,
ast::PipelineStage stage, ast::PipelineStage stage,
type::AddressSpace address_space) { type::AddressSpace address_space) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
switch (stage) { switch (stage) {
case ast::PipelineStage::kVertex: case ast::PipelineStage::kVertex:
return "gl_Position"; return "gl_Position";
@ -688,27 +688,27 @@ struct CanonicalizeEntryPointIO::State {
default: default:
return ""; return "";
} }
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
return "gl_VertexID"; return "gl_VertexID";
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
return "gl_InstanceID"; return "gl_InstanceID";
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
return "gl_FrontFacing"; return "gl_FrontFacing";
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
return "gl_FragDepth"; return "gl_FragDepth";
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
return "gl_LocalInvocationID"; return "gl_LocalInvocationID";
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
return "gl_LocalInvocationIndex"; return "gl_LocalInvocationIndex";
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
return "gl_GlobalInvocationID"; return "gl_GlobalInvocationID";
case ast::BuiltinValue::kNumWorkgroups: case builtin::BuiltinValue::kNumWorkgroups:
return "gl_NumWorkGroups"; return "gl_NumWorkGroups";
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
return "gl_WorkGroupID"; return "gl_WorkGroupID";
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
return "gl_SampleID"; return "gl_SampleID";
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
if (address_space == type::AddressSpace::kIn) { if (address_space == type::AddressSpace::kIn) {
return "gl_SampleMaskIn"; return "gl_SampleMaskIn";
} else { } else {
@ -725,18 +725,18 @@ struct CanonicalizeEntryPointIO::State {
/// @param ast_type (inout) the incoming WGSL and outgoing GLSL types /// @param ast_type (inout) the incoming WGSL and outgoing GLSL types
/// @returns an expression representing the GLSL builtin converted to what /// @returns an expression representing the GLSL builtin converted to what
/// WGSL expects /// WGSL expects
const ast::Expression* FromGLSLBuiltin(ast::BuiltinValue builtin, const ast::Expression* FromGLSLBuiltin(builtin::BuiltinValue builtin,
const ast::Expression* value, const ast::Expression* value,
ast::Type& ast_type) { ast::Type& ast_type) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
// GLSL uses i32 for these, so bitcast to u32. // GLSL uses i32 for these, so bitcast to u32.
value = ctx.dst->Bitcast(ast_type, value); value = ctx.dst->Bitcast(ast_type, value);
ast_type = ctx.dst->ty.i32(); ast_type = ctx.dst->ty.i32();
break; break;
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
// gl_SampleMask is an array of i32. Retrieve the first element and // gl_SampleMask is an array of i32. Retrieve the first element and
// bitcast it to u32. // bitcast it to u32.
value = ctx.dst->IndexAccessor(value, 0_i); value = ctx.dst->IndexAccessor(value, 0_i);
@ -755,14 +755,14 @@ struct CanonicalizeEntryPointIO::State {
/// @param value the value to convert /// @param value the value to convert
/// @param type (out) the type to which the value was converted /// @param type (out) the type to which the value was converted
/// @returns the converted value which can be assigned to the GLSL builtin /// @returns the converted value which can be assigned to the GLSL builtin
const ast::Expression* ToGLSLBuiltin(ast::BuiltinValue builtin, const ast::Expression* ToGLSLBuiltin(builtin::BuiltinValue builtin,
const ast::Expression* value, const ast::Expression* value,
const type::Type*& type) { const type::Type*& type) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
type = ctx.dst->create<type::I32>(); type = ctx.dst->create<type::I32>();
value = ctx.dst->Bitcast(CreateASTTypeFor(ctx, type), value); value = ctx.dst->Bitcast(CreateASTTypeFor(ctx, type), value);
break; break;

4
src/tint/transform/clamp_frag_depth.cc
View File

@ -18,10 +18,10 @@
#include "src/tint/ast/attribute.h" #include "src/tint/ast/attribute.h"
#include "src/tint/ast/builtin_attribute.h" #include "src/tint/ast/builtin_attribute.h"
#include "src/tint/ast/builtin_value.h"
#include "src/tint/ast/function.h" #include "src/tint/ast/function.h"
#include "src/tint/ast/module.h" #include "src/tint/ast/module.h"
#include "src/tint/ast/struct.h" #include "src/tint/ast/struct.h"
#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program_builder.h" #include "src/tint/program_builder.h"
#include "src/tint/sem/function.h" #include "src/tint/sem/function.h"
#include "src/tint/sem/statement.h" #include "src/tint/sem/statement.h"
@ -38,7 +38,7 @@ namespace {
bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attributes) { bool ContainsFragDepth(utils::VectorRef<const ast::Attribute*> attributes) {
for (auto* attribute : attributes) { for (auto* attribute : attributes) {
if (auto* builtin_attribute = attribute->As<ast::BuiltinAttribute>()) { if (auto* builtin_attribute = attribute->As<ast::BuiltinAttribute>()) {
if (builtin_attribute->builtin == ast::BuiltinValue::kFragDepth) { if (builtin_attribute->builtin == builtin::BuiltinValue::kFragDepth) {
return true; return true;
} }
} }

12
src/tint/transform/first_index_offset.cc
View File

@ -88,13 +88,13 @@ Transform::ApplyResult FirstIndexOffset::Apply(const Program* src,
if (auto* var = node->As<ast::Variable>()) { if (auto* var = node->As<ast::Variable>()) {
for (auto* attr : var->attributes) { for (auto* attr : var->attributes) {
if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) { if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
ast::BuiltinValue builtin = builtin_attr->builtin; builtin::BuiltinValue builtin = builtin_attr->builtin;
if (builtin == ast::BuiltinValue::kVertexIndex) { if (builtin == builtin::BuiltinValue::kVertexIndex) {
auto* sem_var = ctx.src->Sem().Get(var); auto* sem_var = ctx.src->Sem().Get(var);
builtin_vars.emplace(sem_var, kFirstVertexName); builtin_vars.emplace(sem_var, kFirstVertexName);
has_vertex_or_instance_index = true; has_vertex_or_instance_index = true;
} }
if (builtin == ast::BuiltinValue::kInstanceIndex) { if (builtin == builtin::BuiltinValue::kInstanceIndex) {
auto* sem_var = ctx.src->Sem().Get(var); auto* sem_var = ctx.src->Sem().Get(var);
builtin_vars.emplace(sem_var, kFirstInstanceName); builtin_vars.emplace(sem_var, kFirstInstanceName);
has_vertex_or_instance_index = true; has_vertex_or_instance_index = true;
@ -105,13 +105,13 @@ Transform::ApplyResult FirstIndexOffset::Apply(const Program* src,
if (auto* member = node->As<ast::StructMember>()) { if (auto* member = node->As<ast::StructMember>()) {
for (auto* attr : member->attributes) { for (auto* attr : member->attributes) {
if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) { if (auto* builtin_attr = attr->As<ast::BuiltinAttribute>()) {
ast::BuiltinValue builtin = builtin_attr->builtin; builtin::BuiltinValue builtin = builtin_attr->builtin;
if (builtin == ast::BuiltinValue::kVertexIndex) { if (builtin == builtin::BuiltinValue::kVertexIndex) {
auto* sem_mem = ctx.src->Sem().Get(member); auto* sem_mem = ctx.src->Sem().Get(member);
builtin_members.emplace(sem_mem, kFirstVertexName); builtin_members.emplace(sem_mem, kFirstVertexName);
has_vertex_or_instance_index = true; has_vertex_or_instance_index = true;
} }
if (builtin == ast::BuiltinValue::kInstanceIndex) { if (builtin == builtin::BuiltinValue::kInstanceIndex) {
auto* sem_mem = ctx.src->Sem().Get(member); auto* sem_mem = ctx.src->Sem().Get(member);
builtin_members.emplace(sem_mem, kFirstInstanceName); builtin_members.emplace(sem_mem, kFirstInstanceName);
has_vertex_or_instance_index = true; has_vertex_or_instance_index = true;

4
src/tint/transform/num_workgroups_from_uniform.cc
View File

@ -33,7 +33,7 @@ namespace {
bool ShouldRun(const Program* program) { bool ShouldRun(const Program* program) {
for (auto* node : program->ASTNodes().Objects()) { for (auto* node : program->ASTNodes().Objects()) {
if (auto* attr = node->As<ast::BuiltinAttribute>()) { if (auto* attr = node->As<ast::BuiltinAttribute>()) {
if (attr->builtin == ast::BuiltinValue::kNumWorkgroups) { if (attr->builtin == builtin::BuiltinValue::kNumWorkgroups) {
return true; return true;
} }
} }
@ -100,7 +100,7 @@ Transform::ApplyResult NumWorkgroupsFromUniform::Apply(const Program* src,
for (auto* member : str->Members()) { for (auto* member : str->Members()) {
auto* builtin = auto* builtin =
ast::GetAttribute<ast::BuiltinAttribute>(member->Declaration()->attributes); ast::GetAttribute<ast::BuiltinAttribute>(member->Declaration()->attributes);
if (!builtin || builtin->builtin != ast::BuiltinValue::kNumWorkgroups) { if (!builtin || builtin->builtin != builtin::BuiltinValue::kNumWorkgroups) {
continue; continue;
} }

12
src/tint/transform/vertex_pulling.cc
View File

@ -778,11 +778,11 @@ struct VertexPulling::State {
return; return;
} }
// Check for existing vertex_index and instance_index builtins. // Check for existing vertex_index and instance_index builtins.
if (builtin->builtin == ast::BuiltinValue::kVertexIndex) { if (builtin->builtin == builtin::BuiltinValue::kVertexIndex) {
vertex_index_expr = [this, param]() { vertex_index_expr = [this, param]() {
return b.Expr(ctx.Clone(param->name->symbol)); return b.Expr(ctx.Clone(param->name->symbol));
}; };
} else if (builtin->builtin == ast::BuiltinValue::kInstanceIndex) { } else if (builtin->builtin == builtin::BuiltinValue::kInstanceIndex) {
instance_index_expr = [this, param]() { instance_index_expr = [this, param]() {
return b.Expr(ctx.Clone(param->name->symbol)); return b.Expr(ctx.Clone(param->name->symbol));
}; };
@ -831,9 +831,9 @@ struct VertexPulling::State {
return; return;
} }
// Check for existing vertex_index and instance_index builtins. // Check for existing vertex_index and instance_index builtins.
if (builtin->builtin == ast::BuiltinValue::kVertexIndex) { if (builtin->builtin == builtin::BuiltinValue::kVertexIndex) {
vertex_index_expr = member_expr; vertex_index_expr = member_expr;
} else if (builtin->builtin == ast::BuiltinValue::kInstanceIndex) { } else if (builtin->builtin == builtin::BuiltinValue::kInstanceIndex) {
instance_index_expr = member_expr; instance_index_expr = member_expr;
} }
members_to_clone.Push(member); members_to_clone.Push(member);
@ -899,7 +899,7 @@ struct VertexPulling::State {
auto name = b.Symbols().New("tint_pulling_vertex_index"); auto name = b.Symbols().New("tint_pulling_vertex_index");
new_function_parameters.Push( new_function_parameters.Push(
b.Param(name, b.ty.u32(), b.Param(name, b.ty.u32(),
utils::Vector{b.Builtin(ast::BuiltinValue::kVertexIndex)})); utils::Vector{b.Builtin(builtin::BuiltinValue::kVertexIndex)}));
vertex_index_expr = [this, name]() { return b.Expr(name); }; vertex_index_expr = [this, name]() { return b.Expr(name); };
break; break;
} }
@ -911,7 +911,7 @@ struct VertexPulling::State {
auto name = b.Symbols().New("tint_pulling_instance_index"); auto name = b.Symbols().New("tint_pulling_instance_index");
new_function_parameters.Push( new_function_parameters.Push(
b.Param(name, b.ty.u32(), b.Param(name, b.ty.u32(),
utils::Vector{b.Builtin(ast::BuiltinValue::kInstanceIndex)})); utils::Vector{b.Builtin(builtin::BuiltinValue::kInstanceIndex)}));
instance_index_expr = [this, name]() { return b.Expr(name); }; instance_index_expr = [this, name]() { return b.Expr(name); };
break; break;
} }

6
src/tint/transform/zero_init_workgroup_memory.cc
View File

@ -159,7 +159,7 @@ struct ZeroInitWorkgroupMemory::State {
std::function<const ast::Expression*()> local_index; std::function<const ast::Expression*()> local_index;
for (auto* param : fn->params) { for (auto* param : fn->params) {
if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes)) { if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(param->attributes)) {
if (builtin->builtin == ast::BuiltinValue::kLocalInvocationIndex) { if (builtin->builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
local_index = [=] { return b.Expr(ctx.Clone(param->name->symbol)); }; local_index = [=] { return b.Expr(ctx.Clone(param->name->symbol)); };
break; break;
} }
@ -169,7 +169,7 @@ struct ZeroInitWorkgroupMemory::State {
for (auto* member : str->Members()) { for (auto* member : str->Members()) {
if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>( if (auto* builtin = ast::GetAttribute<ast::BuiltinAttribute>(
member->Declaration()->attributes)) { member->Declaration()->attributes)) {
if (builtin->builtin == ast::BuiltinValue::kLocalInvocationIndex) { if (builtin->builtin == builtin::BuiltinValue::kLocalInvocationIndex) {
local_index = [=] { local_index = [=] {
auto* param_expr = b.Expr(ctx.Clone(param->name->symbol)); auto* param_expr = b.Expr(ctx.Clone(param->name->symbol));
auto* member_name = ctx.Clone(member->Declaration()->name); auto* member_name = ctx.Clone(member->Declaration()->name);
@ -185,7 +185,7 @@ struct ZeroInitWorkgroupMemory::State {
// No existing local index parameter. Append one to the entry point. // No existing local index parameter. Append one to the entry point.
auto* param = b.Param(b.Symbols().New("local_invocation_index"), b.ty.u32(), auto* param = b.Param(b.Symbols().New("local_invocation_index"), b.ty.u32(),
utils::Vector{ utils::Vector{
b.Builtin(ast::BuiltinValue::kLocalInvocationIndex), b.Builtin(builtin::BuiltinValue::kLocalInvocationIndex),
}); });
ctx.InsertBack(fn->params, param); ctx.InsertBack(fn->params, param);
local_index = [=] { return b.Expr(param->name->symbol); }; local_index = [=] { return b.Expr(param->name->symbol); };

6
src/tint/writer/glsl/generator_impl.cc
View File

@ -90,10 +90,10 @@ bool IsRelational(tint::ast::BinaryOp op) {
op == tint::ast::BinaryOp::kGreaterThanEqual; op == tint::ast::BinaryOp::kGreaterThanEqual;
} }
bool RequiresOESSampleVariables(tint::ast::BuiltinValue builtin) { bool RequiresOESSampleVariables(tint::builtin::BuiltinValue builtin) {
switch (builtin) { switch (builtin) {
case tint::ast::BuiltinValue::kSampleIndex: case tint::builtin::BuiltinValue::kSampleIndex:
case tint::ast::BuiltinValue::kSampleMask: case tint::builtin::BuiltinValue::kSampleMask:
return true; return true;
default: default:
return false; return false;

4
src/tint/writer/glsl/generator_impl.h
View File

@ -471,11 +471,11 @@ class GeneratorImpl : public TextGenerator {
/// @param builtin the builtin to convert /// @param builtin the builtin to convert
/// @param stage pipeline stage in which this builtin is used /// @param stage pipeline stage in which this builtin is used
/// @returns the string name of the builtin or blank on error /// @returns the string name of the builtin or blank on error
const char* builtin_to_string(ast::BuiltinValue builtin, ast::PipelineStage stage); const char* builtin_to_string(builtin::BuiltinValue builtin, ast::PipelineStage stage);
/// Converts a builtin to a type::Type appropriate for GLSL. /// Converts a builtin to a type::Type appropriate for GLSL.
/// @param builtin the builtin to convert /// @param builtin the builtin to convert
/// @returns the appropriate semantic type or null on error. /// @returns the appropriate semantic type or null on error.
type::Type* builtin_type(ast::BuiltinValue builtin); type::Type* builtin_type(builtin::BuiltinValue builtin);
private: private:
enum class VarType { kIn, kOut }; enum class VarType { kIn, kOut };

8
src/tint/writer/glsl/generator_impl_function_test.cc
View File

@ -166,7 +166,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
// return coord.x; // return coord.x;
// } // }
auto* coord_in = auto* coord_in =
Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}); Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
Func("frag_main", Func("frag_main",
utils::Vector{ utils::Vector{
coord_in, coord_in,
@ -179,7 +179,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
@ -217,7 +217,7 @@ TEST_F(GlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_SharedStruct_Di
auto* interface_struct = Structure( auto* interface_struct = Structure(
"Interface", "Interface",
utils::Vector{ utils::Vector{
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
Member("col1", ty.f32(), utils::Vector{Location(1_a)}), Member("col1", ty.f32(), utils::Vector{Location(1_a)}),
Member("col2", ty.f32(), utils::Vector{Location(2_a)}), Member("col2", ty.f32(), utils::Vector{Location(2_a)}),
}); });
@ -297,7 +297,7 @@ TEST_F(GlslGeneratorImplTest_Function,
// } // }
auto* vertex_output_struct = Structure( auto* vertex_output_struct = Structure(
"VertexOutput", "VertexOutput",
{Member("pos", ty.vec4<f32>(), {Builtin(ast::BuiltinValue::kPosition)})}); {Member("pos", ty.vec4<f32>(), {Builtin(builtin::BuiltinValue::kPosition)})});
Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct), Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct),
{Return(Call(ty.Of(vertex_output_struct), {Return(Call(ty.Of(vertex_output_struct),

4
src/tint/writer/glsl/generator_impl_test.cc
View File

@ -59,7 +59,7 @@ void my_func() {
TEST_F(GlslGeneratorImplTest, GenerateSampleIndexES) { TEST_F(GlslGeneratorImplTest, GenerateSampleIndexES) {
GlobalVar("gl_SampleID", ty.i32(), GlobalVar("gl_SampleID", ty.i32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
Disable(ast::DisabledValidation::kIgnoreAddressSpace), Disable(ast::DisabledValidation::kIgnoreAddressSpace),
}, },
type::AddressSpace::kIn); type::AddressSpace::kIn);
@ -84,7 +84,7 @@ int my_func() {
TEST_F(GlslGeneratorImplTest, GenerateSampleIndexDesktop) { TEST_F(GlslGeneratorImplTest, GenerateSampleIndexDesktop) {
GlobalVar("gl_SampleID", ty.i32(), GlobalVar("gl_SampleID", ty.i32(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kSampleIndex), Builtin(builtin::BuiltinValue::kSampleIndex),
Disable(ast::DisabledValidation::kIgnoreAddressSpace), Disable(ast::DisabledValidation::kIgnoreAddressSpace),
}, },
type::AddressSpace::kIn); type::AddressSpace::kIn);

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

@ -3154,29 +3154,29 @@ bool GeneratorImpl::EmitWorkgroupVariable(const sem::Variable* var) {
return true; return true;
} }
std::string GeneratorImpl::builtin_to_attribute(ast::BuiltinValue builtin) const { std::string GeneratorImpl::builtin_to_attribute(builtin::BuiltinValue builtin) const {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
return "SV_Position"; return "SV_Position";
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
return "SV_VertexID"; return "SV_VertexID";
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
return "SV_InstanceID"; return "SV_InstanceID";
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
return "SV_IsFrontFace"; return "SV_IsFrontFace";
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
return "SV_Depth"; return "SV_Depth";
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
return "SV_GroupThreadID"; return "SV_GroupThreadID";
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
return "SV_GroupIndex"; return "SV_GroupIndex";
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
return "SV_DispatchThreadID"; return "SV_DispatchThreadID";
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
return "SV_GroupID"; return "SV_GroupID";
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
return "SV_SampleIndex"; return "SV_SampleIndex";
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
return "SV_Coverage"; return "SV_Coverage";
default: default:
break; break;

2
src/tint/writer/hlsl/generator_impl.h
View File

@ -495,7 +495,7 @@ class GeneratorImpl : public TextGenerator {
/// Converts a builtin to an attribute name /// Converts a builtin to an attribute name
/// @param builtin the builtin to convert /// @param builtin the builtin to convert
/// @returns the string name of the builtin or blank on error /// @returns the string name of the builtin or blank on error
std::string builtin_to_attribute(ast::BuiltinValue builtin) const; std::string builtin_to_attribute(builtin::BuiltinValue builtin) const;
/// Converts interpolation attributes to a HLSL modifiers /// Converts interpolation attributes to a HLSL modifiers
/// @param type the interpolation type /// @param type the interpolation type

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

@ -157,7 +157,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
// return coord.x; // return coord.x;
// } // }
auto* coord_in = auto* coord_in =
Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}); Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
Func("frag_main", utils::Vector{coord_in}, ty.f32(), Func("frag_main", utils::Vector{coord_in}, ty.f32(),
utils::Vector{ utils::Vector{
Return(MemberAccessor("coord", "x")), Return(MemberAccessor("coord", "x")),
@ -166,7 +166,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_WithInOut_Built
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
@ -209,7 +209,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_SharedStruct_Di
auto* interface_struct = Structure( auto* interface_struct = Structure(
"Interface", "Interface",
utils::Vector{ utils::Vector{
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
Member("col1", ty.f32(), utils::Vector{Location(1_a)}), Member("col1", ty.f32(), utils::Vector{Location(1_a)}),
Member("col2", ty.f32(), utils::Vector{Location(2_a)}), Member("col2", ty.f32(), utils::Vector{Location(2_a)}),
}); });
@ -292,7 +292,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Attribute_EntryPoint_SharedStruct_He
auto* vertex_output_struct = auto* vertex_output_struct =
Structure("VertexOutput", Structure("VertexOutput",
utils::Vector{Member("pos", ty.vec4<f32>(), utils::Vector{Member("pos", ty.vec4<f32>(),
utils::Vector{Builtin(ast::BuiltinValue::kPosition)})}); utils::Vector{Builtin(builtin::BuiltinValue::kPosition)})});
Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct), Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct),
utils::Vector{ utils::Vector{

25
src/tint/writer/hlsl/generator_impl_test.cc
View File

@ -49,7 +49,7 @@ TEST_F(HlslGeneratorImplTest, Generate) {
} }
struct HlslBuiltinData { struct HlslBuiltinData {
ast::BuiltinValue builtin; builtin::BuiltinValue builtin;
const char* attribute_name; const char* attribute_name;
}; };
inline std::ostream& operator<<(std::ostream& out, HlslBuiltinData data) { inline std::ostream& operator<<(std::ostream& out, HlslBuiltinData data) {
@ -66,17 +66,18 @@ TEST_P(HlslBuiltinConversionTest, Emit) {
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest, HlslGeneratorImplTest,
HlslBuiltinConversionTest, HlslBuiltinConversionTest,
testing::Values(HlslBuiltinData{ast::BuiltinValue::kPosition, "SV_Position"}, testing::Values(HlslBuiltinData{builtin::BuiltinValue::kPosition, "SV_Position"},
HlslBuiltinData{ast::BuiltinValue::kVertexIndex, "SV_VertexID"}, HlslBuiltinData{builtin::BuiltinValue::kVertexIndex, "SV_VertexID"},
HlslBuiltinData{ast::BuiltinValue::kInstanceIndex, "SV_InstanceID"}, HlslBuiltinData{builtin::BuiltinValue::kInstanceIndex, "SV_InstanceID"},
HlslBuiltinData{ast::BuiltinValue::kFrontFacing, "SV_IsFrontFace"}, HlslBuiltinData{builtin::BuiltinValue::kFrontFacing, "SV_IsFrontFace"},
HlslBuiltinData{ast::BuiltinValue::kFragDepth, "SV_Depth"}, HlslBuiltinData{builtin::BuiltinValue::kFragDepth, "SV_Depth"},
HlslBuiltinData{ast::BuiltinValue::kLocalInvocationId, "SV_GroupThreadID"}, HlslBuiltinData{builtin::BuiltinValue::kLocalInvocationId, "SV_GroupThreadID"},
HlslBuiltinData{ast::BuiltinValue::kLocalInvocationIndex, "SV_GroupIndex"}, HlslBuiltinData{builtin::BuiltinValue::kLocalInvocationIndex, "SV_GroupIndex"},
HlslBuiltinData{ast::BuiltinValue::kGlobalInvocationId, "SV_DispatchThreadID"}, HlslBuiltinData{builtin::BuiltinValue::kGlobalInvocationId,
HlslBuiltinData{ast::BuiltinValue::kWorkgroupId, "SV_GroupID"}, "SV_DispatchThreadID"},
HlslBuiltinData{ast::BuiltinValue::kSampleIndex, "SV_SampleIndex"}, HlslBuiltinData{builtin::BuiltinValue::kWorkgroupId, "SV_GroupID"},
HlslBuiltinData{ast::BuiltinValue::kSampleMask, "SV_Coverage"})); HlslBuiltinData{builtin::BuiltinValue::kSampleIndex, "SV_SampleIndex"},
HlslBuiltinData{builtin::BuiltinValue::kSampleMask, "SV_Coverage"}));
} // namespace } // namespace
} // namespace tint::writer::hlsl } // namespace tint::writer::hlsl

28
src/tint/writer/msl/generator_impl.cc
View File

@ -1905,33 +1905,33 @@ bool GeneratorImpl::EmitFunction(const ast::Function* func) {
return true; return true;
} }
std::string GeneratorImpl::builtin_to_attribute(ast::BuiltinValue builtin) const { std::string GeneratorImpl::builtin_to_attribute(builtin::BuiltinValue builtin) const {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
return "position"; return "position";
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
return "vertex_id"; return "vertex_id";
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
return "instance_id"; return "instance_id";
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
return "front_facing"; return "front_facing";
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
return "depth(any)"; return "depth(any)";
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
return "thread_position_in_threadgroup"; return "thread_position_in_threadgroup";
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
return "thread_index_in_threadgroup"; return "thread_index_in_threadgroup";
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
return "thread_position_in_grid"; return "thread_position_in_grid";
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
return "threadgroup_position_in_grid"; return "threadgroup_position_in_grid";
case ast::BuiltinValue::kNumWorkgroups: case builtin::BuiltinValue::kNumWorkgroups:
return "threadgroups_per_grid"; return "threadgroups_per_grid";
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
return "sample_id"; return "sample_id";
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
return "sample_mask"; return "sample_mask";
case ast::BuiltinValue::kPointSize: case builtin::BuiltinValue::kPointSize:
return "point_size"; return "point_size";
default: default:
break; break;

2
src/tint/writer/msl/generator_impl.h
View File

@ -360,7 +360,7 @@ class GeneratorImpl : public TextGenerator {
/// Converts a builtin to an attribute name /// Converts a builtin to an attribute name
/// @param builtin the builtin to convert /// @param builtin the builtin to convert
/// @returns the string name of the builtin or blank on error /// @returns the string name of the builtin or blank on error
std::string builtin_to_attribute(ast::BuiltinValue builtin) const; std::string builtin_to_attribute(builtin::BuiltinValue builtin) const;
/// Converts interpolation attributes to an MSL attribute /// Converts interpolation attributes to an MSL attribute
/// @param type the interpolation type /// @param type the interpolation type

8
src/tint/writer/msl/generator_impl_function_test.cc
View File

@ -136,7 +136,7 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_WithInOut_Builtins) {
// return coord.x; // return coord.x;
// } // }
auto* coord_in = auto* coord_in =
Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}); Param("coord", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
Func("frag_main", utils::Vector{coord_in}, ty.f32(), Func("frag_main", utils::Vector{coord_in}, ty.f32(),
utils::Vector{ utils::Vector{
Return(MemberAccessor("coord", "x")), Return(MemberAccessor("coord", "x")),
@ -145,7 +145,7 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_WithInOut_Builtins) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
@ -190,7 +190,7 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_SharedStruct_DifferentSta
utils::Vector{ utils::Vector{
Member("col1", ty.f32(), utils::Vector{Location(1_a)}), Member("col1", ty.f32(), utils::Vector{Location(1_a)}),
Member("col2", ty.f32(), utils::Vector{Location(2_a)}), Member("col2", ty.f32(), utils::Vector{Location(2_a)}),
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
}); });
Func("vert_main", utils::Empty, ty.Of(interface_struct), Func("vert_main", utils::Empty, ty.Of(interface_struct),
@ -271,7 +271,7 @@ TEST_F(MslGeneratorImplTest, Emit_Attribute_EntryPoint_SharedStruct_HelperFuncti
auto* vertex_output_struct = Structure( auto* vertex_output_struct = Structure(
"VertexOutput", "VertexOutput",
utils::Vector{ utils::Vector{
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
}); });
Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct), Func("foo", utils::Vector{Param("x", ty.f32())}, ty.Of(vertex_output_struct),

32
src/tint/writer/msl/generator_impl_test.cc
View File

@ -61,7 +61,7 @@ kernel void my_func() {
} }
struct MslBuiltinData { struct MslBuiltinData {
ast::BuiltinValue builtin; builtin::BuiltinValue builtin;
const char* attribute_name; const char* attribute_name;
}; };
inline std::ostream& operator<<(std::ostream& out, MslBuiltinData data) { inline std::ostream& operator<<(std::ostream& out, MslBuiltinData data) {
@ -80,25 +80,25 @@ INSTANTIATE_TEST_SUITE_P(
MslGeneratorImplTest, MslGeneratorImplTest,
MslBuiltinConversionTest, MslBuiltinConversionTest,
testing::Values( testing::Values(
MslBuiltinData{ast::BuiltinValue::kPosition, "position"}, MslBuiltinData{builtin::BuiltinValue::kPosition, "position"},
MslBuiltinData{ast::BuiltinValue::kVertexIndex, "vertex_id"}, MslBuiltinData{builtin::BuiltinValue::kVertexIndex, "vertex_id"},
MslBuiltinData{ast::BuiltinValue::kInstanceIndex, "instance_id"}, MslBuiltinData{builtin::BuiltinValue::kInstanceIndex, "instance_id"},
MslBuiltinData{ast::BuiltinValue::kFrontFacing, "front_facing"}, MslBuiltinData{builtin::BuiltinValue::kFrontFacing, "front_facing"},
MslBuiltinData{ast::BuiltinValue::kFragDepth, "depth(any)"}, MslBuiltinData{builtin::BuiltinValue::kFragDepth, "depth(any)"},
MslBuiltinData{ast::BuiltinValue::kLocalInvocationId, "thread_position_in_threadgroup"}, MslBuiltinData{builtin::BuiltinValue::kLocalInvocationId, "thread_position_in_threadgroup"},
MslBuiltinData{ast::BuiltinValue::kLocalInvocationIndex, "thread_index_in_threadgroup"}, MslBuiltinData{builtin::BuiltinValue::kLocalInvocationIndex, "thread_index_in_threadgroup"},
MslBuiltinData{ast::BuiltinValue::kGlobalInvocationId, "thread_position_in_grid"}, MslBuiltinData{builtin::BuiltinValue::kGlobalInvocationId, "thread_position_in_grid"},
MslBuiltinData{ast::BuiltinValue::kWorkgroupId, "threadgroup_position_in_grid"}, MslBuiltinData{builtin::BuiltinValue::kWorkgroupId, "threadgroup_position_in_grid"},
MslBuiltinData{ast::BuiltinValue::kNumWorkgroups, "threadgroups_per_grid"}, MslBuiltinData{builtin::BuiltinValue::kNumWorkgroups, "threadgroups_per_grid"},
MslBuiltinData{ast::BuiltinValue::kSampleIndex, "sample_id"}, MslBuiltinData{builtin::BuiltinValue::kSampleIndex, "sample_id"},
MslBuiltinData{ast::BuiltinValue::kSampleMask, "sample_mask"}, MslBuiltinData{builtin::BuiltinValue::kSampleMask, "sample_mask"},
MslBuiltinData{ast::BuiltinValue::kPointSize, "point_size"})); MslBuiltinData{builtin::BuiltinValue::kPointSize, "point_size"}));
TEST_F(MslGeneratorImplTest, HasInvariantAttribute_True) { TEST_F(MslGeneratorImplTest, HasInvariantAttribute_True) {
auto* out = Structure("Out", utils::Vector{ auto* out = Structure("Out", utils::Vector{
Member("pos", ty.vec4<f32>(), Member("pos", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
Invariant(), Invariant(),
}), }),
}); });
@ -136,7 +136,7 @@ TEST_F(MslGeneratorImplTest, HasInvariantAttribute_False) {
auto* out = Structure("Out", utils::Vector{ auto* out = Structure("Out", utils::Vector{
Member("pos", ty.vec4<f32>(), Member("pos", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}), }),
}); });
Func("vert_main", utils::Empty, ty.Of(out), utils::Vector{Return(Call(ty.Of(out)))}, Func("vert_main", utils::Empty, ty.Of(out), utils::Vector{Return(Call(ty.Of(out)))},

32
src/tint/writer/spirv/builder.cc
View File

@ -549,7 +549,7 @@ bool Builder::GenerateExecutionModes(const ast::Function* func, uint32_t id) {
} }
for (auto builtin : func_sem->TransitivelyReferencedBuiltinVariables()) { for (auto builtin : func_sem->TransitivelyReferencedBuiltinVariables()) {
if (builtin.second->builtin == ast::BuiltinValue::kFragDepth) { if (builtin.second->builtin == builtin::BuiltinValue::kFragDepth) {
push_execution_mode(spv::Op::OpExecutionMode, push_execution_mode(spv::Op::OpExecutionMode,
{Operand(id), U32Operand(SpvExecutionModeDepthReplacing)}); {Operand(id), U32Operand(SpvExecutionModeDepthReplacing)});
} }
@ -4004,9 +4004,9 @@ SpvStorageClass Builder::ConvertAddressSpace(type::AddressSpace klass) const {
return SpvStorageClassMax; return SpvStorageClassMax;
} }
SpvBuiltIn Builder::ConvertBuiltin(ast::BuiltinValue builtin, type::AddressSpace storage) { SpvBuiltIn Builder::ConvertBuiltin(builtin::BuiltinValue builtin, type::AddressSpace storage) {
switch (builtin) { switch (builtin) {
case ast::BuiltinValue::kPosition: case builtin::BuiltinValue::kPosition:
if (storage == type::AddressSpace::kIn) { if (storage == type::AddressSpace::kIn) {
return SpvBuiltInFragCoord; return SpvBuiltInFragCoord;
} else if (TINT_LIKELY(storage == type::AddressSpace::kOut)) { } else if (TINT_LIKELY(storage == type::AddressSpace::kOut)) {
@ -4015,32 +4015,32 @@ SpvBuiltIn Builder::ConvertBuiltin(ast::BuiltinValue builtin, type::AddressSpace
TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for builtin"; TINT_ICE(Writer, builder_.Diagnostics()) << "invalid address space for builtin";
break; break;
} }
case ast::BuiltinValue::kVertexIndex: case builtin::BuiltinValue::kVertexIndex:
return SpvBuiltInVertexIndex; return SpvBuiltInVertexIndex;
case ast::BuiltinValue::kInstanceIndex: case builtin::BuiltinValue::kInstanceIndex:
return SpvBuiltInInstanceIndex; return SpvBuiltInInstanceIndex;
case ast::BuiltinValue::kFrontFacing: case builtin::BuiltinValue::kFrontFacing:
return SpvBuiltInFrontFacing; return SpvBuiltInFrontFacing;
case ast::BuiltinValue::kFragDepth: case builtin::BuiltinValue::kFragDepth:
return SpvBuiltInFragDepth; return SpvBuiltInFragDepth;
case ast::BuiltinValue::kLocalInvocationId: case builtin::BuiltinValue::kLocalInvocationId:
return SpvBuiltInLocalInvocationId; return SpvBuiltInLocalInvocationId;
case ast::BuiltinValue::kLocalInvocationIndex: case builtin::BuiltinValue::kLocalInvocationIndex:
return SpvBuiltInLocalInvocationIndex; return SpvBuiltInLocalInvocationIndex;
case ast::BuiltinValue::kGlobalInvocationId: case builtin::BuiltinValue::kGlobalInvocationId:
return SpvBuiltInGlobalInvocationId; return SpvBuiltInGlobalInvocationId;
case ast::BuiltinValue::kPointSize: case builtin::BuiltinValue::kPointSize:
return SpvBuiltInPointSize; return SpvBuiltInPointSize;
case ast::BuiltinValue::kWorkgroupId: case builtin::BuiltinValue::kWorkgroupId:
return SpvBuiltInWorkgroupId; return SpvBuiltInWorkgroupId;
case ast::BuiltinValue::kNumWorkgroups: case builtin::BuiltinValue::kNumWorkgroups:
return SpvBuiltInNumWorkgroups; return SpvBuiltInNumWorkgroups;
case ast::BuiltinValue::kSampleIndex: case builtin::BuiltinValue::kSampleIndex:
push_capability(SpvCapabilitySampleRateShading); push_capability(SpvCapabilitySampleRateShading);
return SpvBuiltInSampleId; return SpvBuiltInSampleId;
case ast::BuiltinValue::kSampleMask: case builtin::BuiltinValue::kSampleMask:
return SpvBuiltInSampleMask; return SpvBuiltInSampleMask;
case ast::BuiltinValue::kUndefined: case builtin::BuiltinValue::kUndefined:
break; break;
} }
return SpvBuiltInMax; return SpvBuiltInMax;

2
src/tint/writer/spirv/builder.h
View File

@ -213,7 +213,7 @@ class Builder {
/// @param builtin the builtin to convert /// @param builtin the builtin to convert
/// @param storage the address space that this builtin is being used with /// @param storage the address space that this builtin is being used with
/// @returns the SPIR-V builtin or SpvBuiltInMax on error. /// @returns the SPIR-V builtin or SpvBuiltInMax on error.
SpvBuiltIn ConvertBuiltin(ast::BuiltinValue builtin, type::AddressSpace storage); SpvBuiltIn ConvertBuiltin(builtin::BuiltinValue builtin, type::AddressSpace storage);
/// Converts an interpolate attribute to SPIR-V decorations and pushes a /// Converts an interpolate attribute to SPIR-V decorations and pushes a
/// capability if needed. /// capability if needed.

10
src/tint/writer/spirv/builder_entry_point_test.cc
View File

@ -16,11 +16,11 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/tint/ast/builtin_attribute.h" #include "src/tint/ast/builtin_attribute.h"
#include "src/tint/ast/builtin_value.h"
#include "src/tint/ast/location_attribute.h" #include "src/tint/ast/location_attribute.h"
#include "src/tint/ast/return_statement.h" #include "src/tint/ast/return_statement.h"
#include "src/tint/ast/stage_attribute.h" #include "src/tint/ast/stage_attribute.h"
#include "src/tint/ast/variable.h" #include "src/tint/ast/variable.h"
#include "src/tint/builtin/builtin_value.h"
#include "src/tint/program.h" #include "src/tint/program.h"
#include "src/tint/type/address_space.h" #include "src/tint/type/address_space.h"
#include "src/tint/type/f32.h" #include "src/tint/type/f32.h"
@ -44,7 +44,7 @@ TEST_F(BuilderTest, EntryPoint_Parameters) {
// } // }
auto* coord = Param("coord", ty.vec4<f32>(), auto* coord = Param("coord", ty.vec4<f32>(),
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
auto* loc1 = Param("loc1", ty.f32(), auto* loc1 = Param("loc1", ty.f32(),
utils::Vector{ utils::Vector{
@ -212,7 +212,7 @@ TEST_F(BuilderTest, EntryPoint_SharedStruct) {
"Interface", "Interface",
utils::Vector{ utils::Vector{
Member("value", ty.f32(), utils::Vector{Location(1_u)}), Member("value", ty.f32(), utils::Vector{Location(1_u)}),
Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(ast::BuiltinValue::kPosition)}), Member("pos", ty.vec4<f32>(), utils::Vector{Builtin(builtin::BuiltinValue::kPosition)}),
}); });
auto* vert_retval = Call(ty.Of(interface), 42_f, vec4<f32>()); auto* vert_retval = Call(ty.Of(interface), 42_f, vec4<f32>());
@ -228,7 +228,7 @@ TEST_F(BuilderTest, EntryPoint_SharedStruct) {
}, },
utils::Vector{Stage(ast::PipelineStage::kFragment)}, utils::Vector{Stage(ast::PipelineStage::kFragment)},
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
spirv::Builder& b = SanitizeAndBuild(); spirv::Builder& b = SanitizeAndBuild();
@ -322,7 +322,7 @@ OpFunctionEnd
TEST_F(BuilderTest, SampleIndex_SampleRateShadingCapability) { TEST_F(BuilderTest, SampleIndex_SampleRateShadingCapability) {
Func("main", Func("main",
utils::Vector{Param("sample_index", ty.u32(), utils::Vector{Param("sample_index", ty.u32(),
utils::Vector{Builtin(ast::BuiltinValue::kSampleIndex)})}, utils::Vector{Builtin(builtin::BuiltinValue::kSampleIndex)})},
ty.void_(), utils::Empty, ty.void_(), utils::Empty,
utils::Vector{ utils::Vector{
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),

4
src/tint/writer/spirv/builder_function_attribute_test.cc
View File

@ -56,7 +56,7 @@ TEST_P(Attribute_StageTest, Emit) {
utils::Vector<const ast::Statement*, 2> body; utils::Vector<const ast::Statement*, 2> body;
if (params.stage == ast::PipelineStage::kVertex) { if (params.stage == ast::PipelineStage::kVertex) {
ret_type = ty.vec4<f32>(); ret_type = ty.vec4<f32>();
ret_type_attrs.Push(Builtin(ast::BuiltinValue::kPosition)); ret_type_attrs.Push(Builtin(builtin::BuiltinValue::kPosition));
body.Push(Return(Call(ty.vec4<f32>()))); body.Push(Return(Call(ty.vec4<f32>())));
} }
@ -226,7 +226,7 @@ TEST_F(BuilderTest, Decoration_ExecutionMode_FragDepth) {
Stage(ast::PipelineStage::kFragment), Stage(ast::PipelineStage::kFragment),
}, },
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kFragDepth), Builtin(builtin::BuiltinValue::kFragDepth),
}); });
spirv::Builder& b = SanitizeAndBuild(); spirv::Builder& b = SanitizeAndBuild();

35
src/tint/writer/spirv/builder_global_variable_test.cc
View File

@ -251,7 +251,7 @@ OpDecorate %1 DescriptorSet 3
} }
struct BuiltinData { struct BuiltinData {
ast::BuiltinValue builtin; builtin::BuiltinValue builtin;
type::AddressSpace storage; type::AddressSpace storage;
SpvBuiltIn result; SpvBuiltIn result;
}; };
@ -271,32 +271,35 @@ INSTANTIATE_TEST_SUITE_P(
BuilderTest_Type, BuilderTest_Type,
BuiltinDataTest, BuiltinDataTest,
testing::Values( testing::Values(
BuiltinData{ast::BuiltinValue::kUndefined, type::AddressSpace::kNone, SpvBuiltInMax}, BuiltinData{builtin::BuiltinValue::kUndefined, type::AddressSpace::kNone, SpvBuiltInMax},
BuiltinData{ast::BuiltinValue::kPosition, type::AddressSpace::kIn, SpvBuiltInFragCoord}, BuiltinData{builtin::BuiltinValue::kPosition, type::AddressSpace::kIn, SpvBuiltInFragCoord},
BuiltinData{ast::BuiltinValue::kPosition, type::AddressSpace::kOut, SpvBuiltInPosition}, BuiltinData{builtin::BuiltinValue::kPosition, type::AddressSpace::kOut, SpvBuiltInPosition},
BuiltinData{ BuiltinData{
ast::BuiltinValue::kVertexIndex, builtin::BuiltinValue::kVertexIndex,
type::AddressSpace::kIn, type::AddressSpace::kIn,
SpvBuiltInVertexIndex, SpvBuiltInVertexIndex,
}, },
BuiltinData{ast::BuiltinValue::kInstanceIndex, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kInstanceIndex, type::AddressSpace::kIn,
SpvBuiltInInstanceIndex}, SpvBuiltInInstanceIndex},
BuiltinData{ast::BuiltinValue::kFrontFacing, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kFrontFacing, type::AddressSpace::kIn,
SpvBuiltInFrontFacing}, SpvBuiltInFrontFacing},
BuiltinData{ast::BuiltinValue::kFragDepth, type::AddressSpace::kOut, SpvBuiltInFragDepth}, BuiltinData{builtin::BuiltinValue::kFragDepth, type::AddressSpace::kOut,
BuiltinData{ast::BuiltinValue::kLocalInvocationId, type::AddressSpace::kIn, SpvBuiltInFragDepth},
BuiltinData{builtin::BuiltinValue::kLocalInvocationId, type::AddressSpace::kIn,
SpvBuiltInLocalInvocationId}, SpvBuiltInLocalInvocationId},
BuiltinData{ast::BuiltinValue::kLocalInvocationIndex, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kLocalInvocationIndex, type::AddressSpace::kIn,
SpvBuiltInLocalInvocationIndex}, SpvBuiltInLocalInvocationIndex},
BuiltinData{ast::BuiltinValue::kGlobalInvocationId, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kGlobalInvocationId, type::AddressSpace::kIn,
SpvBuiltInGlobalInvocationId}, SpvBuiltInGlobalInvocationId},
BuiltinData{ast::BuiltinValue::kWorkgroupId, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kWorkgroupId, type::AddressSpace::kIn,
SpvBuiltInWorkgroupId}, SpvBuiltInWorkgroupId},
BuiltinData{ast::BuiltinValue::kNumWorkgroups, type::AddressSpace::kIn, BuiltinData{builtin::BuiltinValue::kNumWorkgroups, type::AddressSpace::kIn,
SpvBuiltInNumWorkgroups}, SpvBuiltInNumWorkgroups},
BuiltinData{ast::BuiltinValue::kSampleIndex, type::AddressSpace::kIn, SpvBuiltInSampleId}, BuiltinData{builtin::BuiltinValue::kSampleIndex, type::AddressSpace::kIn,
BuiltinData{ast::BuiltinValue::kSampleMask, type::AddressSpace::kIn, SpvBuiltInSampleMask}, SpvBuiltInSampleId},
BuiltinData{ast::BuiltinValue::kSampleMask, type::AddressSpace::kOut, BuiltinData{builtin::BuiltinValue::kSampleMask, type::AddressSpace::kIn,
SpvBuiltInSampleMask},
BuiltinData{builtin::BuiltinValue::kSampleMask, type::AddressSpace::kOut,
SpvBuiltInSampleMask})); SpvBuiltInSampleMask}));
TEST_F(BuilderTest, GlobalVar_DeclReadOnly) { TEST_F(BuilderTest, GlobalVar_DeclReadOnly) {

2
src/tint/writer/wgsl/generator_impl_function_test.cc
View File

@ -112,7 +112,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_EntryPoint_Parameters) {
auto vec4 = ty.vec4<f32>(); auto vec4 = ty.vec4<f32>();
auto* coord = Param("coord", vec4, auto* coord = Param("coord", vec4,
utils::Vector{ utils::Vector{
Builtin(ast::BuiltinValue::kPosition), Builtin(builtin::BuiltinValue::kPosition),
}); });
auto* loc1 = Param("loc1", ty.f32(), auto* loc1 = Param("loc1", ty.f32(),
utils::Vector{ utils::Vector{

2
src/tint/writer/wgsl/generator_impl_type_test.cc
View File

@ -268,7 +268,7 @@ TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithAttribute) {
TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithEntryPointAttributes) { TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithEntryPointAttributes) {
auto* s = Structure( auto* s = Structure(
"S", utils::Vector{ "S", utils::Vector{
Member("a", ty.u32(), utils::Vector{Builtin(ast::BuiltinValue::kVertexIndex)}), Member("a", ty.u32(), utils::Vector{Builtin(builtin::BuiltinValue::kVertexIndex)}),
Member("b", ty.f32(), utils::Vector{Location(2_a)}), Member("b", ty.f32(), utils::Vector{Location(2_a)}),
}); });