blob: 6b1a70f7fb99f06e12808e6832551e2220d17ba9 [file] [log] [blame]
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/tint/transform/pad_structs.h"
#include <memory>
#include <utility>
#include "src/tint/transform/test_helper.h"
namespace tint::transform {
namespace {
using PadStructsTest = TransformTest;
TEST_F(PadStructsTest, EmptyModule) {
auto* src = "";
auto* expect = src;
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, Uniform) {
auto* src = R"(
struct S {
x : i32,
}
@group(0) @binding(0) var<uniform> u : S;
fn main() {
let x = u.x;
}
)";
auto* expect = R"(
struct S {
x : i32,
pad : u32,
pad_1 : u32,
pad_2 : u32,
}
@group(0) @binding(0) var<uniform> u : S;
fn main() {
let x = u.x;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, Size) {
auto* src = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
fn main() {
let x = u.x;
}
)";
auto* expect = R"(
struct S {
x : i32,
pad : u32,
pad_1 : u32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
fn main() {
let x = u.x;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, SizeUniformAndPrivate) {
auto* src = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
var<private> p : S;
fn main() {
p.x = u.x;
}
)";
auto* expect = R"(
struct S {
x : i32,
pad : u32,
pad_1 : u32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
var<private> p : S;
fn main() {
p.x = u.x;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, SizeStorageAndPrivate) {
auto* src = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
var<private> p : S;
fn main() {
p.x = 123;
s.x = p.x;
}
)";
auto* expect = R"(
struct S {
x : i32,
pad : u32,
pad_1 : u32,
y : i32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
var<private> p : S;
fn main() {
p.x = 123;
s.x = p.x;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, SizeUniformAndStorage) {
auto* src = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
@group(0) @binding(1) var<storage, read_write> s : S;
fn main() {
s.x = u.x;
}
)";
auto* expect = R"(
struct S {
x : i32,
pad : u32,
pad_1 : u32,
y : i32,
}
@group(0) @binding(0) var<uniform> u : S;
@group(0) @binding(1) var<storage, read_write> s : S;
fn main() {
s.x = u.x;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, SizePrivateOnly) {
// Structs that are not host-visible should have no explicit padding.
auto* src = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
var<private> p : S;
fn main() {
p.x = 123;
}
)";
auto* expect = R"(
struct S {
@size(12)
x : i32,
y : i32,
}
var<private> p : S;
fn main() {
p.x = 123;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, AlignUniformAndPrivate) {
auto* src = R"(
struct S {
a : i32,
@align(16)
b : i32,
}
@group(0) @binding(0) var<uniform> u : S;
var<private> p : S;
fn main() {
p.a = u.b;
p.b = u.a;
}
)";
auto* expect = R"(
struct S {
a : i32,
pad : u32,
pad_1 : u32,
pad_2 : u32,
b : i32,
pad_3 : u32,
pad_4 : u32,
pad_5 : u32,
}
@group(0) @binding(0) var<uniform> u : S;
var<private> p : S;
fn main() {
p.a = u.b;
p.b = u.a;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, AlignStorageAndPrivate) {
auto* src = R"(
struct S {
a : i32,
@align(16)
b : i32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
var<private> p : S;
fn main() {
p.a = 123;
p.b = 321;
s.a = p.b;
s.b = p.a;
}
)";
auto* expect = R"(
struct S {
a : i32,
pad : u32,
pad_1 : u32,
pad_2 : u32,
b : i32,
pad_3 : u32,
pad_4 : u32,
pad_5 : u32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
var<private> p : S;
fn main() {
p.a = 123;
p.b = 321;
s.a = p.b;
s.b = p.a;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, AlignUniformAndStorage) {
auto* src = R"(
struct S {
a : i32,
@align(16)
b : i32,
}
@group(0) @binding(0) var<uniform> u : S;
@group(0) @binding(1) var<storage, read_write> s : S;
fn main() {
s.a = u.b;
s.b = u.a;
}
)";
auto* expect = R"(
struct S {
a : i32,
pad : u32,
pad_1 : u32,
pad_2 : u32,
b : i32,
pad_3 : u32,
pad_4 : u32,
pad_5 : u32,
}
@group(0) @binding(0) var<uniform> u : S;
@group(0) @binding(1) var<storage, read_write> s : S;
fn main() {
s.a = u.b;
s.b = u.a;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, AlignPrivateOnly) {
// Structs that are not host-visible should have no explicit padding.
auto* src = R"(
struct S {
a : i32,
@align(16)
b : i32,
}
var<private> p : S;
fn main() {
p.a = 123;
p.b = 321;
}
)";
auto* expect = R"(
struct S {
a : i32,
@align(16)
b : i32,
}
var<private> p : S;
fn main() {
p.a = 123;
p.b = 321;
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, LastMemberRuntimeSizeArray) {
// Structs with runtime-sized arrays should not be padded after the
// last member.
auto* src = R"(
struct T {
a : f32,
b : i32,
}
struct S {
a : vec4<f32>,
b : array<T>,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s.b[0] = T(1.0f, 23);
}
)";
auto* expect = R"(
struct T {
a : f32,
b : i32,
}
struct S {
a : vec4<f32>,
b : array<T>,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s.b[0] = T(1.0f, 23);
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, LastMemberFixedSizeArray) {
// Structs without runtime-sized arrays should be padded after the last
// member.
auto* src = R"(
struct T {
a : f32,
b : i32,
}
struct S {
a : vec4<f32>,
b : array<T, 1u>,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s.b[0] = T(1.0f, 23);
}
)";
auto* expect = R"(
struct T {
a : f32,
b : i32,
}
struct S {
a : vec4<f32>,
b : array<T, 1u>,
pad : u32,
pad_1 : u32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s.b[0] = T(1.0f, 23);
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, Initializer) {
// Calls to a initializer of a padded struct must be modified to initialize the padding.
auto* src = R"(
struct S {
a : f32,
@align(8)
b : i32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s = S(1.0f, 2);
}
)";
auto* expect = R"(
struct S {
a : f32,
pad : u32,
b : i32,
pad_1 : u32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s = S(1.0f, 0u, 2, 0u);
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(PadStructsTest, InitializerZeroArgs) {
// Calls to a zero-argument initializer of a padded struct should not be modified.
auto* src = R"(
struct S {
a : f32,
@align(8)
b : i32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s = S();
}
)";
auto* expect = R"(
struct S {
a : f32,
pad : u32,
b : i32,
pad_1 : u32,
}
@group(0) @binding(0) var<storage, read_write> s : S;
fn main() {
s = S();
}
)";
DataMap data;
auto got = Run<PadStructs>(src, data);
EXPECT_EQ(expect, str(got));
}
} // namespace
} // namespace tint::transform