dawn-cmake/src/tint/transform/pad_structs_test.cc

// 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