encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-09 21:47:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add ProgramBuilder::Param() helpers and use them

Browse Source 
Fix some SPIR-V tests that were wrongly expecting parameters to be
loaded from memory as a result of them not being const.

Change-Id: Ieab6f1edd4a4ba6efd226fe190e7a49b309048c5
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/47281
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: James Price <jrprice@google.com>
Auto-Submit: James Price <jrprice@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
James Price
2021-04-08 22:15:48 +00:00
committed by Commit Bot service account
parent a12ccb20a0
commit daf1f1c0a8
16 changed files with 154 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/resolver/entry_point_validation_test.cc
View File

@@ -253,7 +253,7 @@ TEST_F(ResolverEntryPointValidationTest, ReturnType_Struct_DuplicateLocation) {
TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Location) {
// [[stage(fragment)]]
// fn main([[location(0)]] param : f32) {}
auto* param = Const("param", ty.f32(), nullptr, {Location(0)});
auto* param = Param("param", ty.f32(), {Location(0)});
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -263,8 +263,8 @@ TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Location) {
TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Builtin) {
// [[stage(fragment)]]
// fn main([[builtin(frag_depth)]] param : f32) {}
auto* param = Const("param", ty.vec4<f32>(), nullptr,
{Builtin(ast::Builtin::kFragDepth)});
auto* param =
Param("param", ty.vec4<f32>(), {Builtin(ast::Builtin::kFragDepth)});
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -274,7 +274,7 @@ TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Builtin) {
TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Missing) {
// [[stage(fragment)]]
// fn main(param : f32) {}
auto* param = Const(Source{{13, 43}}, "param", ty.vec4<f32>(), nullptr);
auto* param = Param(Source{{13, 43}}, "param", ty.vec4<f32>());
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -286,7 +286,7 @@ TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Missing) {
TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Multiple) {
// [[stage(fragment)]]
// fn main([[location(0)]] [[builtin(vertex_index)]] param : u32) {}
auto* param = Const("param", ty.u32(), nullptr,
auto* param = Param("param", ty.u32(),
{Location(Source{{13, 43}}, 0),
Builtin(Source{{14, 52}}, ast::Builtin::kVertexIndex)});
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
@@ -303,7 +303,7 @@ TEST_F(ResolverEntryPointValidationTest, ParameterAttribute_Struct) {
// [[stage(fragment)]]
// fn main([[location(0)]] param : Input) {}
auto* input = Structure("Input", {});
auto* param = Const("param", input, nullptr, {Location(Source{{13, 43}}, 0)});
auto* param = Param("param", input, {Location(Source{{13, 43}}, 0)});
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -324,7 +324,7 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_Valid) {
auto* input = Structure(
"Input", {Member("a", ty.f32(), {Location(0)}),
Member("b", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)})});
auto* param = Const("param", input);
auto* param = Param("param", input);
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -343,7 +343,7 @@ TEST_F(ResolverEntryPointValidationTest,
{Member("a", ty.f32(),
{Location(Source{{13, 43}}, 0),
Builtin(Source{{14, 52}}, ast::Builtin::kSampleIndex)})});
auto* param = Const("param", input);
auto* param = Param("param", input);
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -364,7 +364,7 @@ TEST_F(ResolverEntryPointValidationTest,
auto* input = Structure(
"Input", {Member(Source{{13, 43}}, "a", ty.f32(), {Location(0)}),
Member(Source{{14, 52}}, "b", ty.f32(), {})});
auto* param = Const("param", input);
auto* param = Param("param", input);
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -386,7 +386,7 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_NestedStruct) {
"Inner", {Member(Source{{13, 43}}, "a", ty.f32(), {Location(0)})});
auto* input =
Structure("Input", {Member(Source{{14, 52}}, "a", inner, {Location(0)})});
auto* param = Const("param", input);
auto* param = Param("param", input);
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -408,7 +408,7 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_RuntimeArray) {
"Input",
{Member(Source{{13, 43}}, "a", ty.array<float>(), {Location(0)})},
{create<ast::StructBlockDecoration>()});
auto* param = Const("param", input);
auto* param = Param("param", input);
Func(Source{{12, 34}}, "main", {param}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -423,10 +423,10 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_DuplicateBuiltins) {
// [[stage(fragment)]]
// fn main([[builtin(sample_index)]] param_a : u32,
// [[builtin(sample_index)]] param_b : u32) {}
auto* param_a = Const("param_a", ty.u32(), nullptr,
{Builtin(ast::Builtin::kSampleIndex)});
auto* param_b = Const("param_b", ty.u32(), nullptr,
{Builtin(ast::Builtin::kSampleIndex)});
auto* param_a =
Param("param_a", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)});
auto* param_b =
Param("param_b", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)});
Func(Source{{12, 34}}, "main", {param_a, param_b}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -450,8 +450,8 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_DuplicateBuiltins) {
"InputA", {Member("a", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)})});
auto* input_b = Structure(
"InputB", {Member("a", ty.u32(), {Builtin(ast::Builtin::kSampleIndex)})});
auto* param_a = Const("param_a", input_a);
auto* param_b = Const("param_b", input_b);
auto* param_a = Param("param_a", input_a);
auto* param_b = Param("param_b", input_b);
Func(Source{{12, 34}}, "main", {param_a, param_b}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -466,8 +466,8 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_DuplicateLocation) {
// [[stage(fragment)]]
// fn main([[location(1)]] param_a : f32,
// [[location(1)]] param_b : f32) {}
auto* param_a = Const("param_a", ty.u32(), nullptr, {Location(1)});
auto* param_b = Const("param_b", ty.u32(), nullptr, {Location(1)});
auto* param_a = Param("param_a", ty.u32(), {Location(1)});
auto* param_b = Param("param_b", ty.u32(), {Location(1)});
Func(Source{{12, 34}}, "main", {param_a, param_b}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});
@@ -488,8 +488,8 @@ TEST_F(ResolverEntryPointValidationTest, Parameter_Struct_DuplicateLocation) {
// fn main(param_a : InputA, param_b : InputB) {}
auto* input_a = Structure("InputA", {Member("a", ty.f32(), {Location(1)})});
auto* input_b = Structure("InputB", {Member("a", ty.f32(), {Location(1)})});
auto* param_a = Const("param_a", input_a);
auto* param_b = Const("param_b", input_b);
auto* param_a = Param("param_a", input_a);
auto* param_b = Param("param_b", input_b);
Func(Source{{12, 34}}, "main", {param_a, param_b}, ty.void_(), {},
{Stage(ast::PipelineStage::kFragment)});

4
src/resolver/function_validation_test.cc
View File

@@ -248,7 +248,7 @@ TEST_F(ResolverFunctionValidationTest, FunctionVarInitWithParam) {
// var baz : f32 = bar;
// }
auto* bar = Var("bar", ty.f32(), ast::StorageClass::kFunction);
auto* bar = Param("bar", ty.f32());
auto* baz = Var("baz", ty.f32(), ast::StorageClass::kFunction, Expr("bar"));
Func("foo", ast::VariableList{bar}, ty.void_(), ast::StatementList{Decl(baz)},
@@ -262,7 +262,7 @@ TEST_F(ResolverFunctionValidationTest, FunctionConstInitWithParam) {
// let baz : f32 = bar;
// }
auto* bar = Var("bar", ty.f32(), ast::StorageClass::kFunction);
auto* bar = Param("bar", ty.f32());
auto* baz = Const("baz", ty.f32(), Expr("bar"));
Func("foo", ast::VariableList{bar}, ty.void_(), ast::StatementList{Decl(baz)},

14
src/resolver/struct_pipeline_stage_use_test.cc
View File

@@ -42,7 +42,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsNonEntryPointParam) {
auto* s = Structure(
"S", {Member("a", ty.f32(), {create<ast::LocationDecoration>(0)})});
Func("foo", {Const("param", s)}, ty.void_(), {}, {});
Func("foo", {Param("param", s)}, ty.void_(), {}, {});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -68,7 +68,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsVertexShaderParam) {
auto* s = Structure(
"S", {Member("a", ty.f32(), {create<ast::LocationDecoration>(0)})});
Func("main", {Const("param", s)}, ty.void_(), {},
Func("main", {Param("param", s)}, ty.void_(), {},
{create<ast::StageDecoration>(ast::PipelineStage::kVertex)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -99,7 +99,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsFragmentShaderParam) {
auto* s = Structure(
"S", {Member("a", ty.f32(), {create<ast::LocationDecoration>(0)})});
Func("main", {Const("param", s)}, ty.void_(), {},
Func("main", {Param("param", s)}, ty.void_(), {},
{create<ast::StageDecoration>(ast::PipelineStage::kFragment)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -132,7 +132,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsComputeShaderParam) {
{create<ast::BuiltinDecoration>(
ast::Builtin::kLocalInvocationIndex)})});
Func("main", {Const("param", s)}, ty.void_(), {},
Func("main", {Param("param", s)}, ty.void_(), {},
{create<ast::StageDecoration>(ast::PipelineStage::kCompute)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -148,10 +148,10 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedMultipleStages) {
auto* s = Structure(
"S", {Member("a", ty.f32(), {create<ast::LocationDecoration>(0)})});
Func("vert_main", {Const("param", s)}, s, {Return(Construct(s, Expr(0.f)))},
Func("vert_main", {Param("param", s)}, s, {Return(Construct(s, Expr(0.f)))},
{create<ast::StageDecoration>(ast::PipelineStage::kVertex)});
Func("frag_main", {Const("param", s)}, ty.void_(), {},
Func("frag_main", {Param("param", s)}, ty.void_(), {},
{create<ast::StageDecoration>(ast::PipelineStage::kFragment)});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@@ -170,7 +170,7 @@ TEST_F(ResolverPipelineStageUseTest, StructUsedAsShaderParamViaAlias) {
"S", {Member("a", ty.f32(), {create<ast::LocationDecoration>(0)})});
auto* s_alias = ty.alias("S_alias", s);
Func("main", {Const("param", s_alias)}, ty.void_(), {},
Func("main", {Param("param", s_alias)}, ty.void_(), {},
{create<ast::StageDecoration>(ast::PipelineStage::kFragment)});
ASSERT_TRUE(r()->Resolve()) << r()->error();

2
src/resolver/struct_storage_class_use_test.cc
View File

@@ -39,7 +39,7 @@ TEST_F(ResolverStorageClassUseTest, UnreachableStruct) {
TEST_F(ResolverStorageClassUseTest, StructReachableFromParameter) {
auto* s = Structure("S", {Member("a", ty.f32())});
Func("f", {Var("param", s, ast::StorageClass::kNone)}, ty.void_(), {}, {});
Func("f", {Param("param", s)}, ty.void_(), {}, {});
ASSERT_TRUE(r()->Resolve()) << r()->error();

3
src/resolver/type_validation_test.cc
View File

@@ -388,8 +388,7 @@ TEST_F(ResolverTypeValidationTest, RuntimeArrayAsParameter_Fail) {
// fn func(a : array<u32>) {}
// [[stage(vertex)]] fn main() {}
auto* param =
Var(Source{{12, 34}}, "a", ty.array<i32>(), ast::StorageClass::kNone);
auto* param = Param(Source{{12, 34}}, "a", ty.array<i32>());
Func("func", ast::VariableList{param}, ty.void_(),
ast::StatementList{