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

Resolver: Remove texture_storage read access

Browse Source 
The intrinsics that did anything useful with this were deprecated
several releases ago.

Change-Id: I79e3c901b6a78583853a067ec46cfa98e346517c
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/66262
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: James Price <jrprice@google.com>
This commit is contained in:
Ben Clayton
2021-10-14 10:10:45 +00:00
committed by Tint LUCI CQ
parent 14fc622161
commit f3f2d0a218
785 changed files with 3985 additions and 37787 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/resolver/assignment_validation_test.cc
View File

@@ -221,14 +221,14 @@ TEST_F(ResolverAssignmentValidationTest, AssignToConstant_Fail) {
}
TEST_F(ResolverAssignmentValidationTest, AssignNonConstructible_Handle) {
// var a : texture_storage_1d<rgba8unorm, read>;
// var b : texture_storage_1d<rgba8unorm, read>;
// var a : texture_storage_1d<rgba8unorm, write>;
// var b : texture_storage_1d<rgba8unorm, write>;
// a = b;
auto make_type = [&] {
return ty.storage_texture(ast::TextureDimension::k1d,
ast::ImageFormat::kRgba8Unorm,
ast::Access::kRead);
ast::Access::kWrite);
};
Global("a", make_type(), ast::StorageClass::kNone,

91
src/resolver/intrinsic_test.cc
View File

@@ -268,71 +268,6 @@ class ResolverIntrinsicTest_TextureOperation
}
};
using ResolverIntrinsicTest_StorageTextureOperation =
ResolverIntrinsicTest_TextureOperation;
TEST_P(ResolverIntrinsicTest_StorageTextureOperation, TextureLoadRo) {
auto dim = GetParam().dim;
auto type = GetParam().type;
auto format = GetParam().format;
auto* coords_type = GetCoordsType(dim, ty.i32());
auto* texture_type = ty.storage_texture(dim, format, ast::Access::kRead);
ast::ExpressionList call_params;
add_call_param("texture", texture_type, &call_params);
add_call_param("coords", coords_type, &call_params);
if (ast::IsTextureArray(dim)) {
add_call_param("array_index", ty.i32(), &call_params);
}
auto* expr = Call("textureLoad", call_params);
WrapInFunction(expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
ASSERT_NE(TypeOf(expr), nullptr);
ASSERT_TRUE(TypeOf(expr)->Is<sem::Vector>());
if (type == Texture::kF32) {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<sem::F32>());
} else if (type == Texture::kI32) {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<sem::I32>());
} else {
EXPECT_TRUE(TypeOf(expr)->As<sem::Vector>()->type()->Is<sem::U32>());
}
EXPECT_EQ(TypeOf(expr)->As<sem::Vector>()->Width(), 4u);
}
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverIntrinsicTest_StorageTextureOperation,
testing::Values(
TextureTestParams{ast::TextureDimension::k1d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k1d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k1d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k2d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k2d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k2d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k2dArray, Texture::kF32,
ast::ImageFormat::kRgba8Unorm},
TextureTestParams{ast::TextureDimension::k3d, Texture::kF32,
ast::ImageFormat::kR32Float},
TextureTestParams{ast::TextureDimension::k3d, Texture::kI32,
ast::ImageFormat::kR32Sint},
TextureTestParams{ast::TextureDimension::k3d, Texture::kF32,
ast::ImageFormat::kRgba8Unorm}));
using ResolverIntrinsicTest_SampledTextureOperation =
ResolverIntrinsicTest_TextureOperation;
TEST_P(ResolverIntrinsicTest_SampledTextureOperation, TextureLoadSampled) {
@@ -1806,10 +1741,6 @@ const char* expected_texture_overload(
case ValidTextureOverload::kDimensionsDepthCube:
case ValidTextureOverload::kDimensionsDepthCubeArray:
case ValidTextureOverload::kDimensionsDepthMultisampled2d:
case ValidTextureOverload::kDimensionsStorageRO1d:
case ValidTextureOverload::kDimensionsStorageRO2d:
case ValidTextureOverload::kDimensionsStorageRO2dArray:
case ValidTextureOverload::kDimensionsStorageRO3d:
case ValidTextureOverload::kDimensionsStorageWO1d:
case ValidTextureOverload::kDimensionsStorageWO2d:
case ValidTextureOverload::kDimensionsStorageWO2dArray:
@@ -1981,28 +1912,6 @@ const char* expected_texture_overload(
return R"(textureLoad(texture, coords, sample_index))";
case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
return R"(textureLoad(texture, coords, array_index, level))";
case ValidTextureOverload::kLoadStorageRO1dRgba32float:
case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
case ValidTextureOverload::kLoadStorageRO2dRgba8sint:
case ValidTextureOverload::kLoadStorageRO2dRgba16uint:
case ValidTextureOverload::kLoadStorageRO2dRgba16sint:
case ValidTextureOverload::kLoadStorageRO2dRgba16float:
case ValidTextureOverload::kLoadStorageRO2dR32uint:
case ValidTextureOverload::kLoadStorageRO2dR32sint:
case ValidTextureOverload::kLoadStorageRO2dR32float:
case ValidTextureOverload::kLoadStorageRO2dRg32uint:
case ValidTextureOverload::kLoadStorageRO2dRg32sint:
case ValidTextureOverload::kLoadStorageRO2dRg32float:
case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
case ValidTextureOverload::kLoadStorageRO2dRgba32float:
return R"(textureLoad(texture, coords))";
case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
return R"(textureLoad(texture, coords, array_index))";
case ValidTextureOverload::kLoadStorageRO3dRgba32float:
return R"(textureLoad(texture, coords))";
case ValidTextureOverload::kStoreWO1dRgba32float:
case ValidTextureOverload::kStoreWO2dRgba32float:
case ValidTextureOverload::kStoreWO3dRgba32float:

16
src/resolver/resolver.cc
View File

@@ -424,17 +424,15 @@ bool Resolver::ValidateAtomic(const ast::Atomic* a, const sem::Atomic* s) {
bool Resolver::ValidateStorageTexture(const ast::StorageTexture* t) {
switch (t->access()) {
case ast::Access::kUndefined:
AddError("storage textures must have access control", t->source());
return false;
case ast::Access::kReadWrite:
AddError("storage textures only support read-only and write-only access",
t->source());
return false;
case ast::Access::kRead:
case ast::Access::kWrite:
break;
case ast::Access::kUndefined:
AddError("storage texture missing access control", t->source());
return false;
default:
AddError("storage textures currently only support 'write' access control",
t->source());
return false;
}
if (!IsValidStorageTextureDimension(t->dim())) {

93
src/resolver/type_validation_test.cc
View File

@@ -698,10 +698,7 @@ TEST_P(MultisampledTextureDimensionTest, All) {
auto& params = GetParam();
Global(Source{{12, 34}}, "a", ty.multisampled_texture(params.dim, ty.i32()),
ast::StorageClass::kNone, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
if (params.is_valid) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -750,10 +747,7 @@ TEST_P(MultisampledTextureTypeTest, All) {
ty.multisampled_texture(ast::TextureDimension::k2d,
params.type_func(*this)),
ast::StorageClass::kNone, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
if (params.is_valid) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -787,17 +781,15 @@ static constexpr DimensionParams Dimension_cases[] = {
using StorageTextureDimensionTest = ResolverTestWithParam<DimensionParams>;
TEST_P(StorageTextureDimensionTest, All) {
// [[group(0), binding(0)]]
// var a : texture_storage_*<ru32int, read>;
// var a : texture_storage_*<ru32int, write>;
auto& params = GetParam();
auto* st = ty.storage_texture(Source{{12, 34}}, params.dim,
ast::ImageFormat::kR32Uint, ast::Access::kRead);
auto* st =
ty.storage_texture(Source{{12, 34}}, params.dim,
ast::ImageFormat::kR32Uint, ast::Access::kWrite);
Global("a", st, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
if (params.is_valid) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -858,45 +850,33 @@ using StorageTextureFormatTest = ResolverTestWithParam<FormatParams>;
TEST_P(StorageTextureFormatTest, All) {
auto& params = GetParam();
// [[group(0), binding(0)]]
// var a : texture_storage_1d<*, read>;
// var a : texture_storage_1d<*, write>;
// [[group(0), binding(1)]]
// var b : texture_storage_2d<*, read>;
// var b : texture_storage_2d<*, write>;
// [[group(0), binding(2)]]
// var c : texture_storage_2d_array<*, read>;
// var c : texture_storage_2d_array<*, write>;
// [[group(0), binding(3)]]
// var d : texture_storage_3d<*, read>;
// var d : texture_storage_3d<*, write>;
auto* st_a = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d,
params.format, ast::Access::kRead);
params.format, ast::Access::kWrite);
Global("a", st_a, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
auto* st_b = ty.storage_texture(ast::TextureDimension::k2d, params.format,
ast::Access::kRead);
ast::Access::kWrite);
Global("b", st_b, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(1),
});
ast::DecorationList{GroupAndBinding(0, 1)});
auto* st_c = ty.storage_texture(ast::TextureDimension::k2dArray,
params.format, ast::Access::kRead);
params.format, ast::Access::kWrite);
Global("c", st_c, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(2),
});
ast::DecorationList{GroupAndBinding(0, 2)});
auto* st_d = ty.storage_texture(ast::TextureDimension::k3d, params.format,
ast::Access::kRead);
ast::Access::kWrite);
Global("d", st_d, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(3),
});
ast::DecorationList{GroupAndBinding(0, 3)});
if (params.is_valid) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
@@ -923,14 +903,11 @@ TEST_F(StorageTextureAccessTest, MissingAccess_Fail) {
ast::ImageFormat::kR32Uint, ast::Access::kUndefined);
Global("a", st, ast::StorageClass::kNone,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: storage textures must have access control");
"12:34 error: storage texture missing access control");
}
TEST_F(StorageTextureAccessTest, RWAccess_Fail) {
@@ -942,31 +919,28 @@ TEST_F(StorageTextureAccessTest, RWAccess_Fail) {
ast::ImageFormat::kR32Uint, ast::Access::kReadWrite);
Global("a", st, ast::StorageClass::kNone, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: storage textures only support read-only and "
"write-only access");
"12:34 error: storage textures currently only support 'write' "
"access control");
}
TEST_F(StorageTextureAccessTest, ReadOnlyAccess_Pass) {
TEST_F(StorageTextureAccessTest, ReadOnlyAccess_Fail) {
// [[group(0), binding(0)]]
// var a : texture_storage_1d<ru32int, read>;
auto* st = ty.storage_texture(ast::TextureDimension::k1d,
auto* st = ty.storage_texture(Source{{12, 34}}, ast::TextureDimension::k1d,
ast::ImageFormat::kR32Uint, ast::Access::kRead);
Global("a", st, ast::StorageClass::kNone, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"12:34 error: storage textures currently only support 'write' "
"access control");
}
TEST_F(StorageTextureAccessTest, WriteOnlyAccess_Pass) {
@@ -978,10 +952,7 @@ TEST_F(StorageTextureAccessTest, WriteOnlyAccess_Pass) {
ast::Access::kWrite);
Global("a", st, ast::StorageClass::kNone, nullptr,
ast::DecorationList{
create<ast::BindingDecoration>(0),
create<ast::GroupDecoration>(0),
});
ast::DecorationList{GroupAndBinding(0, 0)});
EXPECT_TRUE(r()->Resolve()) << r()->error();
}