encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-07-13 16:45:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert @align to hold an expression.

Browse Source 
With the updated WGSL grammar the `@align` attribute takes an
expression instead of a value. This CL updates the internal data
structures to store an expression instead of an integer value.

The parser still only parses integers, they're just turned into
`IntLiteralExpressions` at the moment.

Bug: tint:1633
Change-Id: If34901798ed6ceaced354bc06ae9b6df875b700e
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/99980
Reviewed-by: Ben Clayton <bclayton@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair 2022-08-23 13:28:44 +00:00 committed by Dawn LUCI CQ
parent b7cf9dd263
commit 4964d9bc20
18 changed files with 180 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,7 +26,7 @@ namespace tint::ast {
StructMemberAlignAttribute::StructMemberAlignAttribute(ProgramID pid,
NodeID nid,
const Source& src,
uint32_t a)
const ast::Expression* a)
: Base(pid, nid, src), align(a) {}
StructMemberAlignAttribute::~StructMemberAlignAttribute() = default;
@ -38,7 +38,8 @@ std::string StructMemberAlignAttribute::Name() const {
const StructMemberAlignAttribute* StructMemberAlignAttribute::Clone(CloneContext* ctx) const {
// Clone arguments outside of create() call to have deterministic ordering
auto src = ctx->Clone(source);
return ctx->dst->create<StructMemberAlignAttribute>(src, align);
auto* align_ = ctx->Clone(align);
return ctx->dst->create<StructMemberAlignAttribute>(src, align_);
}
} // namespace tint::ast

12
src/tint/ast/struct_member_align_attribute.h
View File

@ -19,6 +19,7 @@
#include <string>
#include "src/tint/ast/attribute.h"
#include "src/tint/ast/expression.h"
namespace tint::ast {
@ -29,8 +30,11 @@ class StructMemberAlignAttribute final : public Castable<StructMemberAlignAttrib
/// @param pid the identifier of the program that owns this node
/// @param nid the unique node identifier
/// @param src the source of this node
/// @param align the align value
StructMemberAlignAttribute(ProgramID pid, NodeID nid, const Source& src, uint32_t align);
/// @param align the align value expression
StructMemberAlignAttribute(ProgramID pid,
NodeID nid,
const Source& src,
const ast::Expression* align);
~StructMemberAlignAttribute() override;
/// @returns the WGSL name for the attribute
@ -42,8 +46,8 @@ class StructMemberAlignAttribute final : public Castable<StructMemberAlignAttrib
/// @return the newly cloned node
const StructMemberAlignAttribute* Clone(CloneContext* ctx) const override;
/// The align value
const uint32_t align;
/// The align value expression
const ast::Expression* const align;
};
} // namespace tint::ast

6
src/tint/ast/struct_member_align_attribute_test.cc
View File

@ -22,8 +22,10 @@ namespace {
using StructMemberAlignAttributeTest = TestHelper;
TEST_F(StructMemberAlignAttributeTest, Creation) {
auto* d = create<StructMemberAlignAttribute>(2u);
EXPECT_EQ(2u, d->align);
auto* val = Expr("ident");
auto* d = create<StructMemberAlignAttribute>(val);
EXPECT_EQ(val, d->align);
EXPECT_TRUE(d->align->Is<IdentifierExpression>());
}
} // namespace

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

@ -1811,7 +1811,7 @@ TEST_F(InspectorGetUniformBufferResourceBindingsTest, ContainingArray) {
"foo_type",
utils::Vector{
Member("0i32", ty.i32()),
Member("b", ty.array(ty.u32(), 4_u, /*stride*/ 16), utils::Vector{MemberAlign(16)}),
Member("b", ty.array(ty.u32(), 4_u, /*stride*/ 16), utils::Vector{MemberAlign(16_u)}),
});
AddUniformBuffer("foo_ub", ty.Of(foo_struct_type), 0, 0);
@ -3238,10 +3238,8 @@ TEST_F(InspectorGetWorkgroupStorageSizeTest, StructAlignment) {
// of its last member, rounded up to the alignment of its largest member. So
// here the struct is expected to occupy 1024 bytes of workgroup storage.
const auto* wg_struct_type = MakeStructTypeFromMembers(
"WgStruct",
utils::Vector{
MakeStructMember(0, ty.f32(),
utils::Vector{create<ast::StructMemberAlignAttribute>(1024u)}),
"WgStruct", utils::Vector{
MakeStructMember(0, ty.f32(), utils::Vector{MemberAlign(1024_u)}),
});
AddWorkgroupStorage("wg_struct_var", ty.Of(wg_struct_type));

14
src/tint/program_builder.h
View File

@ -2274,17 +2274,19 @@ class ProgramBuilder {
/// Creates a ast::StructMemberAlignAttribute
/// @param source the source information
/// @param val the align value
/// @param val the align value expression
/// @returns the align attribute pointer
const ast::StructMemberAlignAttribute* MemberAlign(const Source& source, uint32_t val) {
return create<ast::StructMemberAlignAttribute>(source, val);
template <typename EXPR>
const ast::StructMemberAlignAttribute* MemberAlign(const Source& source, EXPR&& val) {
return create<ast::StructMemberAlignAttribute>(source, Expr(std::forward<EXPR>(val)));
}
/// Creates a ast::StructMemberAlignAttribute
/// @param val the align value
/// @param val the align value expression
/// @returns the align attribute pointer
const ast::StructMemberAlignAttribute* MemberAlign(uint32_t val) {
return create<ast::StructMemberAlignAttribute>(source_, val);
template <typename EXPR>
const ast::StructMemberAlignAttribute* MemberAlign(EXPR&& val) {
return create<ast::StructMemberAlignAttribute>(source_, Expr(std::forward<EXPR>(val)));
}
/// Creates the ast::GroupAttribute

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

@ -3874,7 +3874,9 @@ Maybe<const ast::Attribute*> ParserImpl::attribute() {
}
match(Token::Type::kComma);
return create<ast::StructMemberAlignAttribute>(t.source(), val.value);
return create<ast::StructMemberAlignAttribute>(
t.source(), create<ast::IntLiteralExpression>(
val.value, ast::IntLiteralExpression::Suffix::kNone));
});
}

11
src/tint/reader/wgsl/parser_impl_struct_member_attribute_test.cc
View File

@ -102,7 +102,10 @@ TEST_F(ParserImplTest, Attribute_Align) {
ASSERT_TRUE(member_attr->Is<ast::StructMemberAlignAttribute>());
auto* o = member_attr->As<ast::StructMemberAlignAttribute>();
EXPECT_EQ(o->align, 4u);
ASSERT_TRUE(o->align->Is<ast::IntLiteralExpression>());
EXPECT_EQ(o->align->As<ast::IntLiteralExpression>()->value, 4);
EXPECT_EQ(o->align->As<ast::IntLiteralExpression>()->suffix,
ast::IntLiteralExpression::Suffix::kNone);
}
TEST_F(ParserImplTest, Attribute_Align_TrailingComma) {
@ -118,7 +121,11 @@ TEST_F(ParserImplTest, Attribute_Align_TrailingComma) {
ASSERT_TRUE(member_attr->Is<ast::StructMemberAlignAttribute>());
auto* o = member_attr->As<ast::StructMemberAlignAttribute>();
EXPECT_EQ(o->align, 4u);
ASSERT_TRUE(o->align->Is<ast::IntLiteralExpression>());
auto* expr = o->align->As<ast::IntLiteralExpression>();
EXPECT_EQ(expr->value, 4);
EXPECT_EQ(expr->suffix, ast::IntLiteralExpression::Suffix::kNone);
}
TEST_F(ParserImplTest, Attribute_Align_MissingLeftParen) {

20
src/tint/reader/wgsl/parser_impl_struct_member_test.cc
View File

@ -49,7 +49,13 @@ TEST_F(ParserImplTest, StructMember_ParsesWithAlignAttribute) {
EXPECT_TRUE(m->type->Is<ast::I32>());
EXPECT_EQ(m->attributes.Length(), 1u);
EXPECT_TRUE(m->attributes[0]->Is<ast::StructMemberAlignAttribute>());
EXPECT_EQ(m->attributes[0]->As<ast::StructMemberAlignAttribute>()->align, 2u);
auto* attr = m->attributes[0]->As<ast::StructMemberAlignAttribute>();
ASSERT_TRUE(attr->align->Is<ast::IntLiteralExpression>());
auto* expr = attr->align->As<ast::IntLiteralExpression>();
EXPECT_EQ(expr->value, 2);
EXPECT_EQ(expr->suffix, ast::IntLiteralExpression::Suffix::kNone);
EXPECT_EQ(m->source.range, (Source::Range{{1u, 11u}, {1u, 12u}}));
EXPECT_EQ(m->type->source.range, (Source::Range{{1u, 15u}, {1u, 18u}}));
@ -89,10 +95,16 @@ TEST_F(ParserImplTest, StructMember_ParsesWithMultipleattributes) {
EXPECT_EQ(m->symbol, builder.Symbols().Get("a"));
EXPECT_TRUE(m->type->Is<ast::I32>());
EXPECT_EQ(m->attributes.Length(), 2u);
EXPECT_TRUE(m->attributes[0]->Is<ast::StructMemberSizeAttribute>());
ASSERT_TRUE(m->attributes[0]->Is<ast::StructMemberSizeAttribute>());
EXPECT_EQ(m->attributes[0]->As<ast::StructMemberSizeAttribute>()->size, 2u);
EXPECT_TRUE(m->attributes[1]->Is<ast::StructMemberAlignAttribute>());
EXPECT_EQ(m->attributes[1]->As<ast::StructMemberAlignAttribute>()->align, 4u);
ASSERT_TRUE(m->attributes[1]->Is<ast::StructMemberAlignAttribute>());
auto* attr = m->attributes[1]->As<ast::StructMemberAlignAttribute>();
ASSERT_TRUE(attr->align->Is<ast::IntLiteralExpression>());
auto* expr = attr->align->As<ast::IntLiteralExpression>();
EXPECT_EQ(expr->value, 4);
EXPECT_EQ(expr->suffix, ast::IntLiteralExpression::Suffix::kNone);
EXPECT_EQ(m->source.range, (Source::Range{{2u, 11u}, {2u, 12u}}));
EXPECT_EQ(m->type->source.range, (Source::Range{{2u, 15u}, {2u, 18u}}));

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

@ -89,7 +89,7 @@ static utils::Vector<const ast::Attribute*, 2> createAttributes(const Source& so
AttributeKind kind) {
switch (kind) {
case AttributeKind::kAlign:
return {builder.create<ast::StructMemberAlignAttribute>(source, 4u)};
return {builder.MemberAlign(source, 4_u)};
case AttributeKind::kBinding:
return {builder.create<ast::BindingAttribute>(source, 1u)};
case AttributeKind::kBuiltin:
@ -625,12 +625,11 @@ INSTANTIATE_TEST_SUITE_P(ResolverAttributeValidationTest,
TestParams{AttributeKind::kWorkgroup, false},
TestParams{AttributeKind::kBindingAndGroup, false}));
TEST_F(StructMemberAttributeTest, DuplicateAttribute) {
Structure("mystruct",
utils::Vector{
Structure("mystruct", utils::Vector{
Member("a", ty.i32(),
utils::Vector{
create<ast::StructMemberAlignAttribute>(Source{{12, 34}}, 4u),
create<ast::StructMemberAlignAttribute>(Source{{56, 78}}, 8u),
MemberAlign(Source{{12, 34}}, 4_u),
MemberAlign(Source{{56, 78}}, 8_u),
}),
});
EXPECT_FALSE(r()->Resolve());

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

@ -2673,11 +2673,26 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) {
align = 1;
has_offset_attr = true;
} else if (auto* a = attr->As<ast::StructMemberAlignAttribute>()) {
if (a->align <= 0 || !utils::IsPowerOfTwo(a->align)) {
const auto* expr = Expression(a->align);
if (!expr) {
return nullptr;
}
auto* materialized = Materialize(expr);
if (!materialized) {
return nullptr;
}
auto const_value = materialized->ConstantValue();
if (!const_value) {
AddError("'align' must be constant expression", a->align->source);
return nullptr;
}
auto value = const_value->As<AInt>();
if (value <= 0 || !utils::IsPowerOfTwo(value)) {
AddError("align value must be a positive, power-of-two integer", a->source);
return nullptr;
}
align = a->align;
align = const_value->As<u32>();
has_align_attr = true;
} else if (auto* s = attr->As<ast::StructMemberSizeAttribute>()) {
if (s->size < size) {

20
src/tint/resolver/storage_class_layout_validation_test.cc
View File

@ -36,7 +36,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, StorageBuffer_UnalignedMember)
Structure(Source{{12, 34}}, "S",
utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberSize(5)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_u)}),
});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::StorageClass::kStorage, Group(0),
@ -66,7 +66,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, StorageBuffer_UnalignedMember_S
Structure(Source{{12, 34}}, "S",
utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberSize(5)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(4_u)}),
});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::StorageClass::kStorage, Group(0),
@ -142,7 +142,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
utils::Vector{
Member("scalar", ty.f32()),
Member(Source{{56, 78}}, "inner", ty.type_name("Inner"),
utils::Vector{MemberAlign(16)}),
utils::Vector{MemberAlign(16_u)}),
});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::StorageClass::kUniform, Group(0),
@ -201,7 +201,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_UnalignedMember_A
utils::Vector{
Member("scalar", ty.f32()),
Member(Source{{34, 56}}, "inner", ty.type_name("Inner"),
utils::Vector{MemberAlign(16)}),
utils::Vector{MemberAlign(16_u)}),
});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("Outer"), ast::StorageClass::kUniform, Group(0),
@ -227,7 +227,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, UniformBuffer_MembersOffsetNotM
Structure(Source{{12, 34}}, "Inner",
utils::Vector{
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1), MemberSize(5)}),
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1_u), MemberSize(5)}),
});
Structure(Source{{34, 56}}, "Outer",
@ -279,7 +279,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
Member("a", ty.i32()),
Member("b", ty.i32()),
Member("c", ty.i32()),
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1), MemberSize(5)}),
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1_u), MemberSize(5)}),
});
Structure(Source{{34, 56}}, "Outer",
@ -327,13 +327,13 @@ TEST_F(ResolverStorageClassLayoutValidationTest,
Structure(Source{{12, 34}}, "Inner",
utils::Vector{
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1), MemberSize(5)}),
Member("scalar", ty.i32(), utils::Vector{MemberAlign(1_u), MemberSize(5)}),
});
Structure(Source{{34, 56}}, "Outer",
utils::Vector{
Member(Source{{56, 78}}, "inner", ty.type_name("Inner")),
Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16)}),
Member(Source{{78, 90}}, "scalar", ty.i32(), utils::Vector{MemberAlign(16_u)}),
});
GlobalVar(Source{{22, 34}}, "a", ty.type_name("Outer"), ast::StorageClass::kUniform, Group(0),
@ -551,7 +551,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, PushConstant_UnalignedMember) {
Structure(
Source{{12, 34}}, "S",
utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5)}),
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1)})});
Member(Source{{34, 56}}, "b", ty.f32(), utils::Vector{MemberAlign(1_u)})});
GlobalVar(Source{{78, 90}}, "a", ty.type_name("S"), ast::StorageClass::kPushConstant);
ASSERT_FALSE(r()->Resolve());
@ -576,7 +576,7 @@ TEST_F(ResolverStorageClassLayoutValidationTest, PushConstant_Aligned) {
// var<push_constant> a : S;
Enable(ast::Extension::kChromiumExperimentalPushConstant);
Structure("S", utils::Vector{Member("a", ty.f32(), utils::Vector{MemberSize(5)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(4)})});
Member("b", ty.f32(), utils::Vector{MemberAlign(4_u)})});
GlobalVar("a", ty.type_name("S"), ast::StorageClass::kPushConstant);
ASSERT_TRUE(r()->Resolve()) << r()->error();

14
src/tint/resolver/struct_layout_test.cc
View File

@ -498,15 +498,15 @@ TEST_F(ResolverStructLayoutTest, SizeAttributes) {
TEST_F(ResolverStructLayoutTest, AlignAttributes) {
auto* inner = Structure("Inner", utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberAlign(8)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(16)}),
Member("c", ty.f32(), utils::Vector{MemberAlign(4)}),
Member("a", ty.f32(), utils::Vector{MemberAlign(8_u)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(16_u)}),
Member("c", ty.f32(), utils::Vector{MemberAlign(4_u)}),
});
auto* s = Structure("S", utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberAlign(4)}),
Member("b", ty.u32(), utils::Vector{MemberAlign(8)}),
Member("a", ty.f32(), utils::Vector{MemberAlign(4_u)}),
Member("b", ty.u32(), utils::Vector{MemberAlign(8_u)}),
Member("c", ty.Of(inner)),
Member("d", ty.i32(), utils::Vector{MemberAlign(32)}),
Member("d", ty.i32(), utils::Vector{MemberAlign(32_u)}),
});
ASSERT_TRUE(r()->Resolve()) << r()->error();
@ -536,7 +536,7 @@ TEST_F(ResolverStructLayoutTest, AlignAttributes) {
TEST_F(ResolverStructLayoutTest, StructWithLotsOfPadding) {
auto* s = Structure("S", utils::Vector{
Member("a", ty.i32(), utils::Vector{MemberAlign(1024)}),
Member("a", ty.i32(), utils::Vector{MemberAlign(1024_u)}),
});
ASSERT_TRUE(r()->Resolve()) << r()->error();

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

@ -1239,7 +1239,7 @@ TEST_F(ResolverValidationTest, StructMemberDuplicateNamePass) {
TEST_F(ResolverValidationTest, NonPOTStructMemberAlignAttribute) {
Structure("S", utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberAlign(Source{{12, 34}}, 3)}),
Member("a", ty.f32(), utils::Vector{MemberAlign(Source{{12, 34}}, 3_u)}),
});
EXPECT_FALSE(r()->Resolve());
@ -1248,7 +1248,7 @@ TEST_F(ResolverValidationTest, NonPOTStructMemberAlignAttribute) {
TEST_F(ResolverValidationTest, ZeroStructMemberAlignAttribute) {
Structure("S", utils::Vector{
Member("a", ty.f32(), utils::Vector{MemberAlign(Source{{12, 34}}, 0)}),
Member("a", ty.f32(), utils::Vector{MemberAlign(Source{{12, 34}}, 0_u)}),
});
EXPECT_FALSE(r()->Resolve());
@ -1279,7 +1279,7 @@ TEST_F(ResolverValidationTest, OffsetAndSizeAttribute) {
TEST_F(ResolverValidationTest, OffsetAndAlignAttribute) {
Structure("S", utils::Vector{
Member(Source{{12, 34}}, "a", ty.f32(),
utils::Vector{MemberOffset(0), MemberAlign(4)}),
utils::Vector{MemberOffset(0), MemberAlign(4_u)}),
});
EXPECT_FALSE(r()->Resolve());
@ -1291,7 +1291,7 @@ TEST_F(ResolverValidationTest, OffsetAndAlignAttribute) {
TEST_F(ResolverValidationTest, OffsetAndAlignAndSizeAttribute) {
Structure("S", utils::Vector{
Member(Source{{12, 34}}, "a", ty.f32(),
utils::Vector{MemberOffset(0), MemberAlign(4), MemberSize(4)}),
utils::Vector{MemberOffset(0), MemberAlign(4_u), MemberSize(4)}),
});
EXPECT_FALSE(r()->Resolve());

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

@ -13,9 +13,11 @@
// limitations under the License.
#include "gmock/gmock.h"
#include "src/tint/number.h"
#include "src/tint/writer/glsl/test_helper.h"
using ::testing::HasSubstr;
using namespace tint::number_suffixes; // NOLINT
namespace tint::writer::glsl {
namespace {
@ -31,9 +33,9 @@ void TestAlign(ProgramBuilder* ctx) {
// @group(0) @binding(0) var<storage, read_write> nephews : Nephews;
auto* nephews = ctx->Structure(
"Nephews", utils::Vector{
ctx->Member("huey", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256)}),
ctx->Member("dewey", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256)}),
ctx->Member("louie", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256)}),
ctx->Member("huey", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256_u)}),
ctx->Member("dewey", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256_u)}),
ctx->Member("louie", ctx->ty.f32(), utils::Vector{ctx->MemberAlign(256_u)}),
});
ctx->GlobalVar("nephews", ctx->ty.Of(nephews), ast::StorageClass::kStorage, ctx->Binding(0),
ctx->Group(0));

19
src/tint/writer/msl/generator_impl_type_test.cc
View File

@ -252,10 +252,10 @@ TEST_F(MslGeneratorImplTest, EmitType_StructDecl) {
}
TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_NonComposites) {
auto* s =
Structure("S", utils::Vector{
auto* s = Structure(
"S", utils::Vector{
Member("a", ty.i32(), utils::Vector{MemberSize(32)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(128), MemberSize(128)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(128_u), MemberSize(128)}),
Member("c", ty.vec2<f32>()),
Member("d", ty.u32()),
Member("e", ty.vec3<f32>()),
@ -368,9 +368,10 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_NonComposites) {
TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_Structures) {
// inner_x: size(1024), align(512)
auto* inner_x = Structure("inner_x", utils::Vector{
auto* inner_x =
Structure("inner_x", utils::Vector{
Member("a", ty.i32()),
Member("b", ty.f32(), utils::Vector{MemberAlign(512)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(512_u)}),
});
// inner_y: size(516), align(4)
@ -456,7 +457,7 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_ArrayDefaultStride) {
// inner: size(1024), align(512)
auto* inner = Structure("inner", utils::Vector{
Member("a", ty.i32()),
Member("b", ty.f32(), utils::Vector{MemberAlign(512)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(512_u)}),
});
// array_x: size(28), align(4)
@ -588,11 +589,11 @@ TEST_F(MslGeneratorImplTest, EmitType_Struct_Layout_ArrayVec3DefaultStride) {
}
TEST_F(MslGeneratorImplTest, AttemptTintPadSymbolCollision) {
auto* s = Structure(
"S", utils::Vector{
auto* s = Structure("S", utils::Vector{
// uses symbols tint_pad_[0..9] and tint_pad_[20..35]
Member("tint_pad_2", ty.i32(), utils::Vector{MemberSize(32)}),
Member("tint_pad_20", ty.f32(), utils::Vector{MemberAlign(128), MemberSize(128)}),
Member("tint_pad_20", ty.f32(),
utils::Vector{MemberAlign(128_u), MemberSize(128_u)}),
Member("tint_pad_33", ty.vec2<f32>()),
Member("tint_pad_1", ty.u32()),
Member("tint_pad_3", ty.vec3<f32>()),

2
src/tint/writer/spirv/builder_type_test.cc
View File

@ -336,7 +336,7 @@ OpMemberName %1 0 "a"
TEST_F(BuilderTest_Type, GenerateStruct_DecoratedMembers) {
auto* s = Structure("S", utils::Vector{
Member("a", ty.f32()),
Member("b", ty.f32(), utils::Vector{MemberAlign(8)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(8_u)}),
});
spirv::Builder& b = Build();

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

@ -776,7 +776,11 @@ bool GeneratorImpl::EmitAttributes(std::ostream& out,
return true;
},
[&](const ast::StructMemberAlignAttribute* align) {
out << "align(" << align->align << ")";
out << "align(";
if (!EmitExpression(out, align->align)) {
return false;
}
out << ")";
return true;
},
[&](const ast::StrideAttribute* stride) {

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

@ -219,8 +219,8 @@ TEST_F(WgslGeneratorImplTest, EmitType_StructOffsetDecl_WithSymbolCollisions) {
TEST_F(WgslGeneratorImplTest, EmitType_StructAlignDecl) {
auto* s = Structure("S", utils::Vector{
Member("a", ty.i32(), utils::Vector{MemberAlign(8)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(16)}),
Member("a", ty.i32(), utils::Vector{MemberAlign(8_a)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(16_a)}),
});
GeneratorImpl& gen = Build();
@ -256,7 +256,7 @@ TEST_F(WgslGeneratorImplTest, EmitType_StructSizeDecl) {
TEST_F(WgslGeneratorImplTest, EmitType_Struct_WithAttribute) {
auto* s = Structure("S", utils::Vector{
Member("a", ty.i32()),
Member("b", ty.f32(), utils::Vector{MemberAlign(8)}),
Member("b", ty.f32(), utils::Vector{MemberAlign(8_a)}),
});
GeneratorImpl& gen = Build();