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

tint: const eval of binary add

Browse Source 
Bug: tint:1581
Change-Id: Ie34ee52bdd4a4c5d45a5f6c0d8d923cc690c8b2c
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/98021
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
This commit is contained in:
Antonio Maiorano 2022-08-04 19:48:27 +00:00 committed by Dawn LUCI CQ
parent b8893b4c2f
commit 7e9f571814
85 changed files with 754 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/tint/intrinsics.def
View File

@ -886,11 +886,11 @@ op ! <N: num> (vec<N, bool>) -> vec<N, bool>
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Binary Operators // // Binary Operators //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
op + <T: fiu32_f16>(T, T) -> T @const op + <T: fia_fiu32_f16>(T, T) -> T
op + <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
op + <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
op + <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> @const op + <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
op + <T: f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> @const op + <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
op - <T: fiu32_f16>(T, T) -> T op - <T: fiu32_f16>(T, T) -> T
op - <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> op - <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>

92
src/tint/resolver/const_eval.cc
View File

@ -458,7 +458,7 @@ const Constant* CreateComposite(ProgramBuilder& builder,
} }
/// TransformElements constructs a new constant by applying the transformation function 'f' on each /// TransformElements constructs a new constant by applying the transformation function 'f' on each
/// of the most deeply nested elements of 'cs'. /// of the most deeply nested elements of 'cs'. Assumes that all constants are the same type.
template <typename F, typename... CONSTANTS> template <typename F, typename... CONSTANTS>
const Constant* TransformElements(ProgramBuilder& builder, F&& f, CONSTANTS&&... cs) { const Constant* TransformElements(ProgramBuilder& builder, F&& f, CONSTANTS&&... cs) {
uint32_t n = 0; uint32_t n = 0;
@ -470,11 +470,54 @@ const Constant* TransformElements(ProgramBuilder& builder, F&& f, CONSTANTS&&...
utils::Vector<const sem::Constant*, 8> els; utils::Vector<const sem::Constant*, 8> els;
els.Reserve(n); els.Reserve(n);
for (uint32_t i = 0; i < n; i++) { for (uint32_t i = 0; i < n; i++) {
els.Push(TransformElements(builder, f, cs->Index(i)...)); els.Push(TransformElements(builder, std::forward<F>(f), cs->Index(i)...));
} }
return CreateComposite(builder, ty, std::move(els)); return CreateComposite(builder, ty, std::move(els));
} }
/// TransformBinaryElements constructs a new constant by applying the transformation function 'f' on
/// each of the most deeply nested elements of both `c0` and `c1`. Unlike TransformElements, this
/// function handles the constants being of different types, e.g. vector-scalar, scalar-vector.
template <typename F>
const Constant* TransformBinaryElements(ProgramBuilder& builder,
F&& f,
const sem::Constant* c0,
const sem::Constant* c1) {
uint32_t n0 = 0, n1 = 0;
sem::Type::ElementOf(c0->Type(), &n0);
sem::Type::ElementOf(c1->Type(), &n1);
uint32_t max_n = std::max(n0, n1);
// If arity of both constants is 1, invoke callback
if (max_n == 1u) {
return f(c0, c1);
}
utils::Vector<const sem::Constant*, 8> els;
els.Reserve(max_n);
for (uint32_t i = 0; i < max_n; i++) {
auto nested_or_self = [&](auto& c, uint32_t num_elems) {
if (num_elems == 1) {
return c;
}
return c->Index(i);
};
els.Push(TransformBinaryElements(builder, std::forward<F>(f), nested_or_self(c0, n0),
nested_or_self(c1, n1)));
}
// Use larger type
auto* ty = n0 > n1 ? c0->Type() : c1->Type();
return CreateComposite(builder, ty, std::move(els));
}
/// CombineSource returns the combined `Source`s of each expression in `exprs`.
Source CombineSource(utils::VectorRef<const sem::Expression*> exprs) {
Source result = exprs[0]->Declaration()->source;
for (size_t i = 1; i < exprs.Length(); ++i) {
result = result.Combine(result, exprs[i]->Declaration()->source);
}
return result;
}
} // namespace } // namespace
ConstEval::ConstEval(ProgramBuilder& b) : builder(b) {} ConstEval::ConstEval(ProgramBuilder& b) : builder(b) {}
@ -722,6 +765,51 @@ ConstEval::ConstantResult ConstEval::OpMinus(const sem::Type*,
return TransformElements(builder, transform, args[0]->ConstantValue()); return TransformElements(builder, transform, args[0]->ConstantValue());
} }
ConstEval::ConstantResult ConstEval::OpPlus(const sem::Type* ty,
utils::VectorRef<const sem::Expression*> args) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
auto create = [&](auto i, auto j) -> const Constant* {
using NumberT = decltype(i);
using T = UnwrapNumber<NumberT>;
auto add_values = [](T lhs, T rhs) {
if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
// Ensure no UB for signed overflow
using UT = std::make_unsigned_t<T>;
return static_cast<T>(static_cast<UT>(lhs) + static_cast<UT>(rhs));
} else {
return lhs + rhs;
}
};
NumberT result;
if constexpr (std::is_same_v<NumberT, AInt> || std::is_same_v<NumberT, AFloat>) {
// Check for over/underflow for abstract values
if (auto r = CheckedAdd(i, j)) {
result = r->value;
} else {
AddError("'" + std::to_string(add_values(i.value, j.value)) +
"' cannot be represented as '" +
ty->FriendlyName(builder.Symbols()) + "'",
CombineSource(args));
return nullptr;
}
} else {
result = add_values(i.value, j.value);
}
return CreateElement(builder, c0->Type(), result);
};
return Dispatch_fia_fiu32_f16(create, c0, c1);
};
auto r = TransformBinaryElements(builder, transform, args[0]->ConstantValue(),
args[1]->ConstantValue());
if (builder.Diagnostics().contains_errors()) {
return utils::Failure;
}
return r;
}
ConstEval::ConstantResult ConstEval::atan2(const sem::Type*, ConstEval::ConstantResult ConstEval::atan2(const sem::Type*,
utils::VectorRef<const sem::Expression*> args) { utils::VectorRef<const sem::Expression*> args) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) { auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {

10
src/tint/resolver/const_eval.h
View File

@ -177,6 +177,16 @@ class ConstEval {
/// @return the result value, or null if the value cannot be calculated /// @return the result value, or null if the value cannot be calculated
ConstantResult OpMinus(const sem::Type* ty, utils::VectorRef<const sem::Expression*> args); ConstantResult OpMinus(const sem::Type* ty, utils::VectorRef<const sem::Expression*> args);
////////////////////////////////////////////////////////////////////////////
// Binary Operators
////////////////////////////////////////////////////////////////////////////
/// Plus operator '+'
/// @param ty the expression type
/// @param args the input arguments
/// @return the result value, or null if the value cannot be calculated
ConstantResult OpPlus(const sem::Type* ty, utils::VectorRef<const sem::Expression*> args);
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Builtins // Builtins
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////

151
src/tint/resolver/const_eval_test.cc
View File

@ -43,15 +43,26 @@ const auto k3PiOver4 = T(UnwrapNumber<T>(2.356194490192344928846));
template <typename T> template <typename T>
constexpr auto Negate(const Number<T>& v) { constexpr auto Negate(const Number<T>& v) {
if constexpr (std::is_integral_v<T>) {
if constexpr (std::is_signed_v<T>) {
// For signed integrals, avoid C++ UB by not negating the smallest negative number. In // For signed integrals, avoid C++ UB by not negating the smallest negative number. In
// WGSL, this operation is well defined to return the same value, see: // WGSL, this operation is well defined to return the same value, see:
// https://gpuweb.github.io/gpuweb/wgsl/#arithmetic-expr. // https://gpuweb.github.io/gpuweb/wgsl/#arithmetic-expr.
if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
if (v == std::numeric_limits<T>::min()) { if (v == std::numeric_limits<T>::min()) {
return v; return v;
} }
}
return -v; return -v;
} else {
// Allow negating unsigned values
using ST = std::make_signed_t<T>;
auto as_signed = Number<ST>{static_cast<ST>(v)};
return Number<T>{static_cast<T>(Negate(as_signed))};
}
} else {
// float case
return -v;
}
} }
template <typename T> template <typename T>
@ -65,7 +76,7 @@ auto Abs(const Number<T>& v) {
// Concats any number of std::vectors // Concats any number of std::vectors
template <typename Vec, typename... Vecs> template <typename Vec, typename... Vecs>
auto Concat(Vec&& v1, Vecs&&... vs) { [[nodiscard]] auto Concat(Vec&& v1, Vecs&&... vs) {
auto total_size = v1.size() + (vs.size() + ...); auto total_size = v1.size() + (vs.size() + ...);
v1.reserve(total_size); v1.reserve(total_size);
(std::move(vs.begin(), vs.end(), std::back_inserter(v1)), ...); (std::move(vs.begin(), vs.end(), std::back_inserter(v1)), ...);
@ -3115,6 +3126,140 @@ TEST_F(ResolverConstEvalTest, UnaryNegateLowestAbstract) {
} // namespace unary_op } // namespace unary_op
////////////////////////////////////////////////////////////////////////////////////////////////////
// Binary op
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace binary_op {
template <typename T>
struct Values {
T lhs;
T rhs;
T expect;
bool is_overflow;
};
struct Case {
std::variant<Values<AInt>, Values<AFloat>, Values<u32>, Values<i32>, Values<f32>, Values<f16>>
values;
};
static std::ostream& operator<<(std::ostream& o, const Case& c) {
std::visit([&](auto&& v) { o << v.lhs << " " << v.rhs; }, c.values);
return o;
}
template <typename T>
Case C(T lhs, T rhs, T expect, bool is_overflow = false) {
return Case{Values<T>{lhs, rhs, expect, is_overflow}};
}
using ResolverConstEvalBinaryOpTest = ResolverTestWithParam<std::tuple<ast::BinaryOp, Case>>;
TEST_P(ResolverConstEvalBinaryOpTest, Test) {
Enable(ast::Extension::kF16);
auto op = std::get<0>(GetParam());
auto c = std::get<1>(GetParam());
std::visit(
[&](auto&& values) {
using T = decltype(values.expect);
if constexpr (std::is_same_v<T, AInt> || std::is_same_v<T, AFloat>) {
if (values.is_overflow) {
return;
}
}
auto* expr = create<ast::BinaryExpression>(op, Expr(values.lhs), Expr(values.rhs));
GlobalConst("C", nullptr, expr);
EXPECT_TRUE(r()->Resolve()) << r()->error();
auto* sem = Sem().Get(expr);
const sem::Constant* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());
EXPECT_EQ(value->As<T>(), values.expect);
if constexpr (IsInteger<UnwrapNumber<T>>) {
// Check that the constant's integer doesn't contain unexpected data in the MSBs
// that are outside of the bit-width of T.
EXPECT_EQ(value->As<AInt>(), AInt(values.expect));
}
},
c.values);
}
template <typename T>
std::vector<Case> OpAddIntCases() {
static_assert(IsInteger<UnwrapNumber<T>>);
return {
C(T{0}, T{0}, T{0}),
C(T{1}, T{2}, T{3}),
C(T::Lowest(), T{1}, T{T::Lowest() + 1}),
C(T::Highest(), Negate(T{1}), T{T::Highest() - 1}),
C(T::Lowest(), T::Highest(), Negate(T{1})),
C(T::Highest(), T{1}, T::Lowest(), true),
C(T::Lowest(), Negate(T{1}), T::Highest(), true),
};
}
template <typename T>
std::vector<Case> OpAddFloatCases() {
static_assert(IsFloatingPoint<UnwrapNumber<T>>);
return {
C(T{0}, T{0}, T{0}),
C(T{1}, T{2}, T{3}),
C(T::Lowest(), T{1}, T{T::Lowest() + 1}),
C(T::Highest(), Negate(T{1}), T{T::Highest() - 1}),
C(T::Lowest(), T::Highest(), T{0}),
C(T::Highest(), T::Highest(), T::Inf(), true),
C(T::Lowest(), Negate(T::Highest()), -T::Inf(), true),
};
}
INSTANTIATE_TEST_SUITE_P(Add,
ResolverConstEvalBinaryOpTest,
testing::Combine(testing::Values(ast::BinaryOp::kAdd),
testing::ValuesIn(Concat( //
OpAddIntCases<AInt>(),
OpAddIntCases<i32>(),
OpAddIntCases<u32>(),
OpAddFloatCases<AFloat>(),
OpAddFloatCases<f32>(),
OpAddFloatCases<f16>() //
))));
TEST_F(ResolverConstEvalTest, BinaryAbstractAddOverflow_AInt) {
GlobalConst("c", nullptr, Add(Expr(Source{{1, 1}}, AInt::Highest()), 1_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"1:1 error: '-9223372036854775808' cannot be represented as 'abstract-int'");
}
TEST_F(ResolverConstEvalTest, BinaryAbstractAddUnderflow_AInt) {
GlobalConst("c", nullptr, Add(Expr(Source{{1, 1}}, AInt::Lowest()), -1_a));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(),
"1:1 error: '9223372036854775807' cannot be represented as 'abstract-int'");
}
TEST_F(ResolverConstEvalTest, BinaryAbstractAddOverflow_AFloat) {
GlobalConst("c", nullptr, Add(Expr(Source{{1, 1}}, AFloat::Highest()), AFloat::Highest()));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "1:1 error: 'inf' cannot be represented as 'abstract-float'");
}
TEST_F(ResolverConstEvalTest, BinaryAbstractAddUnderflow_AFloat) {
GlobalConst("c", nullptr, Add(Expr(Source{{1, 1}}, AFloat::Lowest()), AFloat::Lowest()));
EXPECT_FALSE(r()->Resolve());
EXPECT_EQ(r()->error(), "1:1 error: '-inf' cannot be represented as 'abstract-float'");
}
} // namespace binary_op
////////////////////////////////////////////////////////////////////////////////////////////////////
// Builtin
////////////////////////////////////////////////////////////////////////////////////////////////////
namespace builtin { namespace builtin {
template <typename T> template <typename T>

30
src/tint/resolver/intrinsic_table.inl
View File

@ -11040,60 +11040,60 @@ constexpr OverloadInfo kOverloads[] = {
/* num parameters */ 2, /* num parameters */ 2,
/* num template types */ 1, /* num template types */ 1,
/* num template numbers */ 0, /* num template numbers */ 0,
/* template types */ &kTemplateTypes[14], /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10], /* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[749], /* parameters */ &kParameters[749],
/* return matcher indices */ &kMatcherIndices[1], /* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr, /* const eval */ &ConstEval::OpPlus,
}, },
{ {
/* [243] */ /* [243] */
/* num parameters */ 2, /* num parameters */ 2,
/* num template types */ 1, /* num template types */ 1,
/* num template numbers */ 1, /* num template numbers */ 1,
/* template types */ &kTemplateTypes[14], /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6], /* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[747], /* parameters */ &kParameters[747],
/* return matcher indices */ &kMatcherIndices[30], /* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr, /* const eval */ &ConstEval::OpPlus,
}, },
{ {
/* [244] */ /* [244] */
/* num parameters */ 2, /* num parameters */ 2,
/* num template types */ 1, /* num template types */ 1,
/* num template numbers */ 1, /* num template numbers */ 1,
/* template types */ &kTemplateTypes[14], /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6], /* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[745], /* parameters */ &kParameters[745],
/* return matcher indices */ &kMatcherIndices[30], /* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr, /* const eval */ &ConstEval::OpPlus,
}, },
{ {
/* [245] */ /* [245] */
/* num parameters */ 2, /* num parameters */ 2,
/* num template types */ 1, /* num template types */ 1,
/* num template numbers */ 1, /* num template numbers */ 1,
/* template types */ &kTemplateTypes[14], /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6], /* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[743], /* parameters */ &kParameters[743],
/* return matcher indices */ &kMatcherIndices[30], /* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr, /* const eval */ &ConstEval::OpPlus,
}, },
{ {
/* [246] */ /* [246] */
/* num parameters */ 2, /* num parameters */ 2,
/* num template types */ 1, /* num template types */ 1,
/* num template numbers */ 2, /* num template numbers */ 2,
/* template types */ &kTemplateTypes[11], /* template types */ &kTemplateTypes[12],
/* template numbers */ &kTemplateNumbers[6], /* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[741], /* parameters */ &kParameters[741],
/* return matcher indices */ &kMatcherIndices[10], /* return matcher indices */ &kMatcherIndices[10],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr, /* const eval */ &ConstEval::OpPlus,
}, },
{ {
/* [247] */ /* [247] */
@ -14578,11 +14578,11 @@ constexpr uint8_t kUnaryOperatorMinus = 2;
constexpr IntrinsicInfo kBinaryOperators[] = { constexpr IntrinsicInfo kBinaryOperators[] = {
{ {
/* [0] */ /* [0] */
/* op +<T : fiu32_f16>(T, T) -> T */ /* op +<T : fia_fiu32_f16>(T, T) -> T */
/* op +<T : fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */ /* op +<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* op +<T : fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */ /* op +<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
/* op +<T : fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */ /* op +<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
/* op +<T : f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */ /* op +<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */
/* num overloads */ 5, /* num overloads */ 5,
/* overloads */ &kOverloads[242], /* overloads */ &kOverloads[242],
}, },

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

@ -886,20 +886,21 @@ INSTANTIATE_TEST_SUITE_P(AFloat_AInt,
IntrinsicTableAbstractBinaryTest, IntrinsicTableAbstractBinaryTest,
testing::Values( // clang-format off testing::Values( // clang-format off
// result | param lhs | param rhs | arg lhs | arg rhs // result | param lhs | param rhs | arg lhs | arg rhs
Case::Create<f32, f32, f32, AFloat, AFloat>(), Case::Create<AFloat, AFloat, AFloat, AFloat, AFloat>(),
Case::Create<f32, f32, f32, AFloat, AInt>(), Case::Create<AFloat, AFloat, AFloat, AFloat, AInt>(),
Case::Create<f32, f32, f32, AInt, AFloat>(), Case::Create<AFloat, AFloat, AFloat, AInt, AFloat>(),
Case::Create<i32, i32, i32, AInt, AInt>() Case::Create<AInt, AInt, AInt, AInt, AInt>()
)); // clang-format on )); // clang-format on
INSTANTIATE_TEST_SUITE_P(VecAFloat_VecAInt, INSTANTIATE_TEST_SUITE_P(
VecAFloat_VecAInt,
IntrinsicTableAbstractBinaryTest, IntrinsicTableAbstractBinaryTest,
testing::Values( // clang-format off testing::Values( // clang-format off
// result | param lhs | param rhs | arg lhs | arg rhs // result | param lhs | param rhs | arg lhs | arg rhs
Case::Create<f32V, f32V, f32V, AFloatV, AFloatV>(), Case::Create<AFloatV, AFloatV, AFloatV, AFloatV, AFloatV>(),
Case::Create<f32V, f32V, f32V, AFloatV, AIntV>(), Case::Create<AFloatV, AFloatV, AFloatV, AFloatV, AIntV>(),
Case::Create<f32V, f32V, f32V, AIntV, AFloatV>(), Case::Create<AFloatV, AFloatV, AFloatV, AIntV, AFloatV>(),
Case::Create<i32V, i32V, i32V, AIntV, AIntV>() Case::Create<AIntV, AIntV, AIntV, AIntV, AIntV>()
)); // clang-format on )); // clang-format on
INSTANTIATE_TEST_SUITE_P(AFloat_f32, INSTANTIATE_TEST_SUITE_P(AFloat_f32,

10
src/tint/writer/glsl/generator_impl_member_accessor_test.cc
View File

@ -405,8 +405,11 @@ TEST_F(GlslGeneratorImplTest_MemberAccessor,
}); });
SetupFunction(utils::Vector{ SetupFunction(utils::Vector{
Decl(Var("a", nullptr, Expr(2_i))),
Decl(Var("b", nullptr, Expr(4_i))),
Decl(Var("c", nullptr, Expr(3_i))),
Decl(Var("x", nullptr, ast::StorageClass::kNone, Decl(Var("x", nullptr, ast::StorageClass::kNone,
IndexAccessor(MemberAccessor("data", "a"), Sub(Add(2_i, 4_i), 3_i)))), IndexAccessor(MemberAccessor("data", "a"), Sub(Add("a", "b"), "c")))),
}); });
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
@ -426,7 +429,10 @@ layout(binding = 0, std430) buffer Data_1 {
int a[5]; int a[5];
} data; } data;
void tint_symbol() { void tint_symbol() {
int x = data.a[((2 + 4) - 3)]; int a = 2;
int b = 4;
int c = 3;
int x = data.a[((a + b) - c)];
} }
void main() { void main() {

10
src/tint/writer/hlsl/generator_impl_member_accessor_test.cc
View File

@ -418,8 +418,11 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
}); });
SetupFunction(utils::Vector{ SetupFunction(utils::Vector{
Decl(Var("a", nullptr, Expr(2_i))),
Decl(Var("b", nullptr, Expr(4_i))),
Decl(Var("c", nullptr, Expr(3_i))),
Decl(Var("x", nullptr, ast::StorageClass::kNone, Decl(Var("x", nullptr, ast::StorageClass::kNone,
IndexAccessor(MemberAccessor("data", "a"), Sub(Add(2_i, Expr(4_i)), Expr(3_i))))), IndexAccessor(MemberAccessor("data", "a"), Sub(Add("a", "b"), "c")))),
}); });
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
@ -429,7 +432,10 @@ TEST_F(HlslGeneratorImplTest_MemberAccessor,
R"(RWByteAddressBuffer data : register(u0, space1); R"(RWByteAddressBuffer data : register(u0, space1);
void main() { void main() {
int x = asint(data.Load((4u + (4u * uint(((2 + 4) - 3)))))); int a = 2;
int b = 4;
int c = 3;
int x = asint(data.Load((4u + (4u * uint(((a + b) - c))))));
return; return;
} }
)"; )";

36
src/tint/writer/spirv/builder_accessor_expression_test.cc
View File

@ -162,10 +162,10 @@ OpReturn
TEST_F(BuilderTest, Const_IndexAccessor_Vector2) { TEST_F(BuilderTest, Const_IndexAccessor_Vector2) {
// let ary : vec3<i32>(1, 2, 3); // let ary : vec3<i32>(1, 2, 3);
// var x = ary[1i + 2i]; // var x = ary[1i + 1i];
auto* ary = Let("ary", nullptr, vec3<i32>(1_i, 2_i, 3_i)); auto* ary = Let("ary", nullptr, vec3<i32>(1_i, 2_i, 3_i));
auto* x = Var("x", nullptr, IndexAccessor(ary, Add(1_i, 2_i))); auto* x = Var("x", nullptr, IndexAccessor(ary, Add(1_i, 1_i)));
WrapInFunction(ary, x); WrapInFunction(ary, x);
spirv::Builder& b = SanitizeAndBuild(); spirv::Builder& b = SanitizeAndBuild();
@ -180,14 +180,14 @@ TEST_F(BuilderTest, Const_IndexAccessor_Vector2) {
%8 = OpConstant %6 2 %8 = OpConstant %6 2
%9 = OpConstant %6 3 %9 = OpConstant %6 3
%10 = OpConstantComposite %5 %7 %8 %9 %10 = OpConstantComposite %5 %7 %8 %9
%14 = OpTypePointer Function %6 %13 = OpTypePointer Function %6
%15 = OpConstantNull %6 %14 = OpConstantNull %6
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), R"(%13 = OpVariable %14 Function %15 EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), R"(%12 = OpVariable %13 Function %14
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%11 = OpIAdd %6 %7 %8 EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
%12 = OpVectorExtractDynamic %6 %10 %11 R"(%11 = OpCompositeExtract %6 %10 2
OpStore %13 %12 OpStore %12 %11
OpReturn OpReturn
)"); )");
@ -196,10 +196,10 @@ OpReturn
TEST_F(BuilderTest, Runtime_IndexAccessor_Vector2) { TEST_F(BuilderTest, Runtime_IndexAccessor_Vector2) {
// var ary : vec3<f32>; // var ary : vec3<f32>;
// var x = ary[1i + 2i]; // var x = ary[1i + 1i];
auto* ary = Var("ary", ty.vec3<f32>()); auto* ary = Var("ary", ty.vec3<f32>());
auto* x = Var("x", nullptr, IndexAccessor(ary, Add(1_i, 2_i))); auto* x = Var("x", nullptr, IndexAccessor(ary, Add(1_i, 1_i)));
WrapInFunction(ary, x); WrapInFunction(ary, x);
spirv::Builder& b = SanitizeAndBuild(); spirv::Builder& b = SanitizeAndBuild();
@ -213,18 +213,16 @@ TEST_F(BuilderTest, Runtime_IndexAccessor_Vector2) {
%6 = OpTypePointer Function %7 %6 = OpTypePointer Function %7
%9 = OpConstantNull %7 %9 = OpConstantNull %7
%10 = OpTypeInt 32 1 %10 = OpTypeInt 32 1
%11 = OpConstant %10 1 %11 = OpConstant %10 2
%12 = OpConstant %10 2 %12 = OpTypePointer Function %8
%14 = OpTypePointer Function %8 %16 = OpConstantNull %8
%18 = OpConstantNull %8
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), R"(%5 = OpVariable %6 Function %9 EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), R"(%5 = OpVariable %6 Function %9
%17 = OpVariable %14 Function %18 %15 = OpVariable %12 Function %16
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%13 = OpIAdd %10 %11 %12 EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(%13 = OpAccessChain %12 %5 %11
%15 = OpAccessChain %14 %5 %13 %14 = OpLoad %8 %13
%16 = OpLoad %8 %15 OpStore %15 %14
OpStore %17 %16
OpReturn OpReturn
)"); )");

298
src/tint/writer/spirv/builder_binary_expression_test.cc
View File

@ -1219,30 +1219,48 @@ namespace BinaryArithVectorScalar {
enum class Type { f32, f16, i32, u32 }; enum class Type { f32, f16, i32, u32 };
static const ast::Expression* MakeVectorExpr(ProgramBuilder* builder, Type type) { static const ast::Expression* MakeVectorExpr(ProgramBuilder* builder, Type type) {
auto name = builder->Symbols().New();
switch (type) { switch (type) {
case Type::f32: case Type::f32:
return builder->vec3<f32>(1_f, 1_f, 1_f); builder->GlobalVar(name, builder->ty.vec3<f32>(), builder->vec3<f32>(1_f, 1_f, 1_f),
ast::StorageClass::kPrivate);
break;
case Type::f16: case Type::f16:
return builder->vec3<f16>(1_h, 1_h, 1_h); builder->GlobalVar(name, builder->ty.vec3<f16>(), builder->vec3<f16>(1_h, 1_h, 1_h),
ast::StorageClass::kPrivate);
break;
case Type::i32: case Type::i32:
return builder->vec3<i32>(1_i, 1_i, 1_i); builder->GlobalVar(name, builder->ty.vec3<i32>(), builder->vec3<i32>(1_i, 1_i, 1_i),
ast::StorageClass::kPrivate);
break;
case Type::u32: case Type::u32:
return builder->vec3<u32>(1_u, 1_u, 1_u); builder->GlobalVar(name, builder->ty.vec3<u32>(), builder->vec3<u32>(1_u, 1_u, 1_u),
ast::StorageClass::kPrivate);
break;
} }
return nullptr; return builder->Expr(name);
} }
static const ast::Expression* MakeScalarExpr(ProgramBuilder* builder, Type type) { static const ast::Expression* MakeScalarExpr(ProgramBuilder* builder, Type type) {
auto name = builder->Symbols().New();
switch (type) { switch (type) {
case Type::f32: case Type::f32:
return builder->Expr(1_f); builder->GlobalVar(name, builder->ty.f32(), builder->Expr(1_f),
ast::StorageClass::kPrivate);
break;
case Type::f16: case Type::f16:
return builder->Expr(1_h); builder->GlobalVar(name, builder->ty.f16(), builder->Expr(1_h),
ast::StorageClass::kPrivate);
break;
case Type::i32: case Type::i32:
return builder->Expr(1_i); builder->GlobalVar(name, builder->ty.i32(), builder->Expr(1_i),
ast::StorageClass::kPrivate);
break;
case Type::u32: case Type::u32:
return builder->Expr(1_u); builder->GlobalVar(name, builder->ty.u32(), builder->Expr(1_u),
ast::StorageClass::kPrivate);
break;
} }
return nullptr; return builder->Expr(name);
} }
static std::string OpTypeDecl(Type type) { static std::string OpTypeDecl(Type type) {
switch (type) { switch (type) {
@ -1310,26 +1328,33 @@ TEST_P(BinaryArithVectorScalarTest, VectorScalar) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %11 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %11 LocalSize 1 1 1
OpName %3 "test_function" OpName %5 "tint_symbol"
%2 = OpTypeVoid OpName %7 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %11 "test_function"
%6 = )" + op_type_decl + R"( %2 = )" + op_type_decl + R"(
%5 = OpTypeVector %6 3 %1 = OpTypeVector %2 3
%7 = OpConstant %6 )" + constant_value + %3 = OpConstant %2 )" + constant_value +
R"( R"(
%8 = OpConstantComposite %5 %7 %7 %7 %4 = OpConstantComposite %1 %3 %3 %3
%11 = OpTypePointer Function %5 %6 = OpTypePointer Private %1
%12 = OpConstantNull %5 %5 = OpVariable %6 Private %4
%3 = OpFunction %2 None %1 %8 = OpTypePointer Private %2
%4 = OpLabel %7 = OpVariable %8 Private %3
%10 = OpVariable %11 Function %12 %10 = OpTypeVoid
%13 = OpCompositeConstruct %5 %7 %7 %7 %9 = OpTypeFunction %10
%9 = )" + param.name + R"( %5 %8 %13 %17 = OpTypePointer Function %1
%18 = OpConstantNull %1
%11 = OpFunction %10 None %9
%12 = OpLabel
%16 = OpVariable %17 Function %18
%13 = OpLoad %1 %5
%14 = OpLoad %2 %7
%19 = OpCompositeConstruct %1 %14 %14 %14
%15 = )" + param.name + R"( %1 %13 %19
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");
@ -1355,26 +1380,33 @@ TEST_P(BinaryArithVectorScalarTest, ScalarVector) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %11 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %11 LocalSize 1 1 1
OpName %3 "test_function" OpName %3 "tint_symbol"
%2 = OpTypeVoid OpName %7 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %11 "test_function"
%5 = )" + op_type_decl + R"( %1 = )" + op_type_decl + R"(
%6 = OpConstant %5 )" + constant_value + %2 = OpConstant %1 )" + constant_value +
R"( R"(
%7 = OpTypeVector %5 3 %4 = OpTypePointer Private %1
%8 = OpConstantComposite %7 %6 %6 %6 %3 = OpVariable %4 Private %2
%11 = OpTypePointer Function %7 %5 = OpTypeVector %1 3
%12 = OpConstantNull %7 %6 = OpConstantComposite %5 %2 %2 %2
%3 = OpFunction %2 None %1 %8 = OpTypePointer Private %5
%4 = OpLabel %7 = OpVariable %8 Private %6
%10 = OpVariable %11 Function %12 %10 = OpTypeVoid
%13 = OpCompositeConstruct %7 %6 %6 %6 %9 = OpTypeFunction %10
%9 = )" + param.name + R"( %7 %13 %8 %17 = OpTypePointer Function %5
%18 = OpConstantNull %5
%11 = OpFunction %10 None %9
%12 = OpLabel
%16 = OpVariable %17 Function %18
%13 = OpLoad %1 %3
%14 = OpLoad %5 %7
%19 = OpCompositeConstruct %5 %13 %13 %13
%15 = )" + param.name + R"( %5 %19 %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");
@ -1428,22 +1460,29 @@ TEST_P(BinaryArithVectorScalarMultiplyTest, VectorScalar) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %11 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %11 LocalSize 1 1 1
OpName %3 "test_function" OpName %5 "tint_symbol"
%2 = OpTypeVoid OpName %7 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %11 "test_function"
%6 = )" + op_type_decl + R"( %2 = )" + op_type_decl + R"(
%5 = OpTypeVector %6 3 %1 = OpTypeVector %2 3
%7 = OpConstant %6 )" + constant_value + %3 = OpConstant %2 )" + constant_value +
R"( R"(
%8 = OpConstantComposite %5 %7 %7 %7 %4 = OpConstantComposite %1 %3 %3 %3
%3 = OpFunction %2 None %1 %6 = OpTypePointer Private %1
%4 = OpLabel %5 = OpVariable %6 Private %4
%9 = OpVectorTimesScalar %5 %8 %7 %8 = OpTypePointer Private %2
%7 = OpVariable %8 Private %3
%10 = OpTypeVoid
%9 = OpTypeFunction %10
%11 = OpFunction %10 None %9
%12 = OpLabel
%13 = OpLoad %1 %5
%14 = OpLoad %2 %7
%15 = OpVectorTimesScalar %1 %13 %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");
@ -1469,22 +1508,29 @@ TEST_P(BinaryArithVectorScalarMultiplyTest, ScalarVector) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %11 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %11 LocalSize 1 1 1
OpName %3 "test_function" OpName %3 "tint_symbol"
%2 = OpTypeVoid OpName %7 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %11 "test_function"
%5 = )" + op_type_decl + R"( %1 = )" + op_type_decl + R"(
%6 = OpConstant %5 )" + constant_value + %2 = OpConstant %1 )" + constant_value +
R"( R"(
%7 = OpTypeVector %5 3 %4 = OpTypePointer Private %1
%8 = OpConstantComposite %7 %6 %6 %6 %3 = OpVariable %4 Private %2
%3 = OpFunction %2 None %1 %5 = OpTypeVector %1 3
%4 = OpLabel %6 = OpConstantComposite %5 %2 %2 %2
%9 = OpVectorTimesScalar %7 %8 %6 %8 = OpTypePointer Private %5
%7 = OpVariable %8 Private %6
%10 = OpTypeVoid
%9 = OpTypeFunction %10
%11 = OpFunction %10 None %9
%12 = OpLabel
%13 = OpLoad %1 %3
%14 = OpLoad %5 %7
%15 = OpVectorTimesScalar %5 %14 %13
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");
@ -1502,22 +1548,31 @@ namespace BinaryArithMatrixMatrix {
enum class Type { f32, f16 }; enum class Type { f32, f16 };
static const ast::Expression* MakeMat3x4Expr(ProgramBuilder* builder, Type type) { static const ast::Expression* MakeMat3x4Expr(ProgramBuilder* builder, Type type) {
auto name = builder->Symbols().New();
switch (type) { switch (type) {
case Type::f32: case Type::f32:
return builder->mat3x4<f32>(); builder->GlobalVar(name, builder->ty.mat3x4<f32>(), builder->mat3x4<f32>(),
ast::StorageClass::kPrivate);
break;
case Type::f16: case Type::f16:
return builder->mat3x4<f16>(); builder->GlobalVar(name, builder->ty.mat3x4<f16>(), builder->mat3x4<f16>(),
ast::StorageClass::kPrivate);
break;
} }
return nullptr; return builder->Expr(name);
} }
static const ast::Expression* MakeMat4x3Expr(ProgramBuilder* builder, Type type) { static const ast::Expression* MakeMat4x3Expr(ProgramBuilder* builder, Type type) {
auto name = builder->Symbols().New();
switch (type) { switch (type) {
case Type::f32: case Type::f32:
return builder->mat4x3<f32>(); builder->GlobalVar(name, builder->ty.mat4x3<f32>(), builder->mat4x3<f32>(),
ast::StorageClass::kPrivate);
break;
case Type::f16: case Type::f16:
return builder->mat4x3<f16>(); builder->GlobalVar(name, builder->ty.mat4x3<f16>(), builder->mat4x3<f16>(),
ast::StorageClass::kPrivate);
} }
return nullptr; return builder->Expr(name);
} }
static std::string OpTypeDecl(Type type) { static std::string OpTypeDecl(Type type) {
switch (type) { switch (type) {
@ -1567,30 +1622,36 @@ TEST_P(BinaryArithMatrixMatrix, AddOrSubtract) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %10 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %10 LocalSize 1 1 1
OpName %3 "test_function" OpName %5 "tint_symbol"
%2 = OpTypeVoid OpName %7 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %10 "test_function"
%7 = )" + op_type_decl + R"( %3 = )" + op_type_decl + R"(
%6 = OpTypeVector %7 4 %2 = OpTypeVector %3 4
%5 = OpTypeMatrix %6 3 %1 = OpTypeMatrix %2 3
%8 = OpConstantNull %5 %4 = OpConstantNull %1
%3 = OpFunction %2 None %1 %6 = OpTypePointer Private %1
%4 = OpLabel %5 = OpVariable %6 Private %4
%10 = OpCompositeExtract %6 %8 0 %7 = OpVariable %6 Private %4
%11 = OpCompositeExtract %6 %8 0 %9 = OpTypeVoid
%12 = )" + param.name + R"( %6 %10 %11 %8 = OpTypeFunction %9
%13 = OpCompositeExtract %6 %8 1 %10 = OpFunction %9 None %8
%14 = OpCompositeExtract %6 %8 1 %11 = OpLabel
%15 = )" + param.name + R"( %6 %13 %14 %12 = OpLoad %1 %5
%16 = OpCompositeExtract %6 %8 2 %13 = OpLoad %1 %7
%17 = OpCompositeExtract %6 %8 2 %15 = OpCompositeExtract %2 %12 0
%18 = )" + param.name + R"( %6 %16 %17 %16 = OpCompositeExtract %2 %13 0
%19 = OpCompositeConstruct %5 %12 %15 %18 %17 = )" + param.name + R"( %2 %15 %16
%18 = OpCompositeExtract %2 %12 1
%19 = OpCompositeExtract %2 %13 1
%20 = )" + param.name + R"( %2 %18 %19
%21 = OpCompositeExtract %2 %12 2
%22 = OpCompositeExtract %2 %13 2
%23 = )" + param.name + R"( %2 %21 %22
%24 = OpCompositeConstruct %1 %17 %20 %23
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");
@ -1624,25 +1685,32 @@ TEST_P(BinaryArithMatrixMatrixMultiply, Multiply) {
spirv::Builder& b = Build(); spirv::Builder& b = Build();
ASSERT_TRUE(b.Build()) << b.error(); ASSERT_TRUE(b.Build()) << b.error();
EXPECT_EQ(DumpBuilder(b), capability_decl + R"( EXPECT_EQ(DumpBuilder(b), capability_decl + R"(
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 "test_function" OpEntryPoint GLCompute %14 "test_function"
OpExecutionMode %3 LocalSize 1 1 1 OpExecutionMode %14 LocalSize 1 1 1
OpName %3 "test_function" OpName %5 "tint_symbol"
%2 = OpTypeVoid OpName %10 "tint_symbol_1"
%1 = OpTypeFunction %2 OpName %14 "test_function"
%7 = )" + op_type_decl + R"( %3 = )" + op_type_decl + R"(
%6 = OpTypeVector %7 4 %2 = OpTypeVector %3 4
%5 = OpTypeMatrix %6 3 %1 = OpTypeMatrix %2 3
%8 = OpConstantNull %5 %4 = OpConstantNull %1
%10 = OpTypeVector %7 3 %6 = OpTypePointer Private %1
%9 = OpTypeMatrix %10 4 %5 = OpVariable %6 Private %4
%11 = OpConstantNull %9 %8 = OpTypeVector %3 3
%13 = OpTypeMatrix %6 4 %7 = OpTypeMatrix %8 4
%3 = OpFunction %2 None %1 %9 = OpConstantNull %7
%4 = OpLabel %11 = OpTypePointer Private %7
%12 = OpMatrixTimesMatrix %13 %8 %11 %10 = OpVariable %11 Private %9
%13 = OpTypeVoid
%12 = OpTypeFunction %13
%19 = OpTypeMatrix %2 4
%14 = OpFunction %13 None %12
%15 = OpLabel
%16 = OpLoad %1 %5
%17 = OpLoad %7 %10
%18 = OpMatrixTimesMatrix %19 %16 %17
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
)"); )");

22
src/tint/writer/spirv/builder_function_variable_test.cc
View File

@ -73,32 +73,34 @@ TEST_F(BuilderTest, FunctionVar_WithConstantConstructor) {
} }
TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructor) { TEST_F(BuilderTest, FunctionVar_WithNonConstantConstructor) {
auto* init = vec2<f32>(1_f, Add(3_f, 3_f)); auto* a = Let("a", nullptr, Expr(3_f));
auto* init = vec2<f32>(1_f, Add(Expr("a"), 3_f));
auto* v = Var("var", ty.vec2<f32>(), ast::StorageClass::kNone, init); auto* v = Var("var", ty.vec2<f32>(), ast::StorageClass::kNone, init);
WrapInFunction(v); WrapInFunction(a, v);
spirv::Builder& b = Build(); spirv::Builder& b = Build();
b.push_function(Function{}); b.push_function(Function{});
EXPECT_TRUE(b.GenerateFunctionVariable(a)) << b.error();
EXPECT_TRUE(b.GenerateFunctionVariable(v)) << b.error(); EXPECT_TRUE(b.GenerateFunctionVariable(v)) << b.error();
ASSERT_FALSE(b.has_error()) << b.error(); ASSERT_FALSE(b.has_error()) << b.error();
EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %7 "var" EXPECT_EQ(DumpInstructions(b.debug()), R"(OpName %7 "var"
)"); )");
EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
%1 = OpTypeVector %2 2 %2 = OpConstant %1 3
%3 = OpConstant %2 1 %3 = OpTypeVector %1 2
%4 = OpConstant %2 3 %4 = OpConstant %1 1
%8 = OpTypePointer Function %1 %8 = OpTypePointer Function %3
%9 = OpConstantNull %1 %9 = OpConstantNull %3
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), EXPECT_EQ(DumpInstructions(b.functions()[0].variables()),
R"(%7 = OpVariable %8 Function %9 R"(%7 = OpVariable %8 Function %9
)"); )");
EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
R"(%5 = OpFAdd %2 %4 %4 R"(%5 = OpFAdd %1 %2 %2
%6 = OpCompositeConstruct %1 %3 %5 %6 = OpCompositeConstruct %3 %4 %5
OpStore %7 %6 OpStore %7 %6
)"); )");
} }

2
test/tint/expressions/binary/add/scalar-scalar/f16.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float16_t r = (float16_t(1.0h) + float16_t(2.0h)); const float16_t r = float16_t(3.0h);
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/f16.wgsl.expected.glsl
View File

@ -2,7 +2,7 @@
#extension GL_AMD_gpu_shader_half_float : require #extension GL_AMD_gpu_shader_half_float : require
void f() { void f() {
float16_t r = (1.0hf + 2.0hf); float16_t r = 3.0hf;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/expressions/binary/add/scalar-scalar/f32.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float r = (1.0f + 2.0f); const float r = 3.0f;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/f32.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const float r = (1.0f + 2.0f); const float r = 3.0f;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/f32.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es #version 310 es
void f() { void f() {
float r = (1.0f + 2.0f); float r = 3.0f;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/expressions/binary/add/scalar-scalar/i32.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const int r = (1 + 2); const int r = 3;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/i32.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const int r = (1 + 2); const int r = 3;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/i32.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es #version 310 es
void f() { void f() {
int r = (1 + 2); int r = 3;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/expressions/binary/add/scalar-scalar/u32.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const uint r = (1u + 2u); const uint r = 3u;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/u32.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void f() { void f() {
const uint r = (1u + 2u); const uint r = 3u;
return; return;
} }

2
test/tint/expressions/binary/add/scalar-scalar/u32.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es #version 310 es
void f() { void f() {
uint r = (1u + 2u); uint r = 3u;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/expressions/literals/intmin.wgsl.expected.dxc.hlsl
View File

@ -6,6 +6,6 @@ void unused_entry_point() {
int add_int_min_explicit() { int add_int_min_explicit() {
int a = -2147483648; int a = -2147483648;
int b = (a + 1); int b = (a + 1);
int c = (-2147483648 + 1); int c = -2147483647;
return c; return c;
} }

2
test/tint/expressions/literals/intmin.wgsl.expected.fxc.hlsl
View File

@ -6,6 +6,6 @@ void unused_entry_point() {
int add_int_min_explicit() { int add_int_min_explicit() {
int a = -2147483648; int a = -2147483648;
int b = (a + 1); int b = (a + 1);
int c = (-2147483648 + 1); int c = -2147483647;
return c; return c;
} }

2
test/tint/expressions/literals/intmin.wgsl.expected.glsl
View File

@ -7,7 +7,7 @@ void unused_entry_point() {
int add_int_min_explicit() { int add_int_min_explicit() {
int a = -2147483648; int a = -2147483648;
int b = (a + 1); int b = (a + 1);
int c = (-2147483648 + 1); int c = -2147483647;
return c; return c;
} }

2
test/tint/expressions/literals/intmin.wgsl.expected.msl
View File

@ -4,7 +4,7 @@ using namespace metal;
int add_int_min_explicit() { int add_int_min_explicit() {
int a = (-2147483647 - 1); int a = (-2147483647 - 1);
int b = as_type<int>((as_type<uint>(a) + as_type<uint>(1))); int b = as_type<int>((as_type<uint>(a) + as_type<uint>(1)));
int c = as_type<int>((as_type<uint>((-2147483647 - 1)) + as_type<uint>(1))); int c = -2147483647;
return c; return c;
} }

4
test/tint/expressions/literals/intmin.wgsl.expected.spvasm
View File

@ -20,6 +20,7 @@
%_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_int = OpTypePointer Function %int
%12 = OpConstantNull %int %12 = OpConstantNull %int
%int_1 = OpConstant %int 1 %int_1 = OpConstant %int 1
%int_n2147483647 = OpConstant %int -2147483647
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
@ -33,8 +34,7 @@
%13 = OpLoad %int %a %13 = OpLoad %int %a
%15 = OpIAdd %int %13 %int_1 %15 = OpIAdd %int %13 %int_1
OpStore %b %15 OpStore %b %15
%17 = OpIAdd %int %int_n2147483648 %int_1 OpStore %c %int_n2147483647
OpStore %c %17
%19 = OpLoad %int %c %19 = OpLoad %int %c
OpReturnValue %19 OpReturnValue %19
OpFunctionEnd OpFunctionEnd

6
test/tint/expressions/splat/expression/f16.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
vector<float16_t, 2> v2 = vector<float16_t, 2>(((float16_t(1.0h) + float16_t(2.0h))).xx); vector<float16_t, 2> v2 = (float16_t(3.0h)).xx;
vector<float16_t, 3> v3 = vector<float16_t, 3>(((float16_t(1.0h) + float16_t(2.0h))).xxx); vector<float16_t, 3> v3 = (float16_t(3.0h)).xxx;
vector<float16_t, 4> v4 = vector<float16_t, 4>(((float16_t(1.0h) + float16_t(2.0h))).xxxx); vector<float16_t, 4> v4 = (float16_t(3.0h)).xxxx;
} }

6
test/tint/expressions/splat/expression/f16.wgsl.expected.glsl
View File

@ -6,8 +6,8 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
f16vec2 v2 = f16vec2((1.0hf + 2.0hf)); f16vec2 v2 = f16vec2(3.0hf);
f16vec3 v3 = f16vec3((1.0hf + 2.0hf)); f16vec3 v3 = f16vec3(3.0hf);
f16vec4 v4 = f16vec4((1.0hf + 2.0hf)); f16vec4 v4 = f16vec4(3.0hf);
} }

6
test/tint/expressions/splat/expression/f16.wgsl.expected.msl
View File

@ -2,8 +2,8 @@
using namespace metal; using namespace metal;
void f() { void f() {
half2 v2 = half2((1.0h + 2.0h)); half2 v2 = half2(3.0h);
half3 v3 = half3((1.0h + 2.0h)); half3 v3 = half3(3.0h);
half4 v4 = half4((1.0h + 2.0h)); half4 v4 = half4(3.0h);
} }

32
test/tint/expressions/splat/expression/f16.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 28 ; Bound: 24
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpCapability Float16 OpCapability Float16
@ -20,33 +20,29 @@
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%half = OpTypeFloat 16 %half = OpTypeFloat 16
%v2half = OpTypeVector %half 2 %v2half = OpTypeVector %half 2
%half_0x1p_0 = OpConstant %half 0x1p+0 %half_0x1_8p_1 = OpConstant %half 0x1.8p+1
%half_0x1p_1 = OpConstant %half 0x1p+1 %10 = OpConstantComposite %v2half %half_0x1_8p_1 %half_0x1_8p_1
%_ptr_Function_v2half = OpTypePointer Function %v2half %_ptr_Function_v2half = OpTypePointer Function %v2half
%15 = OpConstantNull %v2half %13 = OpConstantNull %v2half
%v3half = OpTypeVector %half 3 %v3half = OpTypeVector %half 3
%15 = OpConstantComposite %v3half %half_0x1_8p_1 %half_0x1_8p_1 %half_0x1_8p_1
%_ptr_Function_v3half = OpTypePointer Function %v3half %_ptr_Function_v3half = OpTypePointer Function %v3half
%21 = OpConstantNull %v3half %18 = OpConstantNull %v3half
%v4half = OpTypeVector %half 4 %v4half = OpTypeVector %half 4
%20 = OpConstantComposite %v4half %half_0x1_8p_1 %half_0x1_8p_1 %half_0x1_8p_1 %half_0x1_8p_1
%_ptr_Function_v4half = OpTypePointer Function %v4half %_ptr_Function_v4half = OpTypePointer Function %v4half
%27 = OpConstantNull %v4half %23 = OpConstantNull %v4half
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v2 = OpVariable %_ptr_Function_v2half Function %15 %v2 = OpVariable %_ptr_Function_v2half Function %13
%v3 = OpVariable %_ptr_Function_v3half Function %21 %v3 = OpVariable %_ptr_Function_v3half Function %18
%v4 = OpVariable %_ptr_Function_v4half Function %27 %v4 = OpVariable %_ptr_Function_v4half Function %23
%11 = OpFAdd %half %half_0x1p_0 %half_0x1p_1 OpStore %v2 %10
%12 = OpCompositeConstruct %v2half %11 %11 OpStore %v3 %15
OpStore %v2 %12 OpStore %v4 %20
%17 = OpFAdd %half %half_0x1p_0 %half_0x1p_1
%18 = OpCompositeConstruct %v3half %17 %17 %17
OpStore %v3 %18
%23 = OpFAdd %half %half_0x1p_0 %half_0x1p_1
%24 = OpCompositeConstruct %v4half %23 %23 %23 %23
OpStore %v4 %24
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

6
test/tint/expressions/splat/expression/f32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
float2 v2 = float2(((1.0f + 2.0f)).xx); float2 v2 = (3.0f).xx;
float3 v3 = float3(((1.0f + 2.0f)).xxx); float3 v3 = (3.0f).xxx;
float4 v4 = float4(((1.0f + 2.0f)).xxxx); float4 v4 = (3.0f).xxxx;
} }

6
test/tint/expressions/splat/expression/f32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
float2 v2 = float2(((1.0f + 2.0f)).xx); float2 v2 = (3.0f).xx;
float3 v3 = float3(((1.0f + 2.0f)).xxx); float3 v3 = (3.0f).xxx;
float4 v4 = float4(((1.0f + 2.0f)).xxxx); float4 v4 = (3.0f).xxxx;
} }

6
test/tint/expressions/splat/expression/f32.wgsl.expected.glsl
View File

@ -5,8 +5,8 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
vec2 v2 = vec2((1.0f + 2.0f)); vec2 v2 = vec2(3.0f);
vec3 v3 = vec3((1.0f + 2.0f)); vec3 v3 = vec3(3.0f);
vec4 v4 = vec4((1.0f + 2.0f)); vec4 v4 = vec4(3.0f);
} }

6
test/tint/expressions/splat/expression/f32.wgsl.expected.msl
View File

@ -2,8 +2,8 @@
using namespace metal; using namespace metal;
void f() { void f() {
float2 v2 = float2((1.0f + 2.0f)); float2 v2 = float2(3.0f);
float3 v3 = float3((1.0f + 2.0f)); float3 v3 = float3(3.0f);
float4 v4 = float4((1.0f + 2.0f)); float4 v4 = float4(3.0f);
} }

32
test/tint/expressions/splat/expression/f32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 28 ; Bound: 24
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,33 +16,29 @@
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%float = OpTypeFloat 32 %float = OpTypeFloat 32
%v2float = OpTypeVector %float 2 %v2float = OpTypeVector %float 2
%float_1 = OpConstant %float 1 %float_3 = OpConstant %float 3
%float_2 = OpConstant %float 2 %10 = OpConstantComposite %v2float %float_3 %float_3
%_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Function_v2float = OpTypePointer Function %v2float
%15 = OpConstantNull %v2float %13 = OpConstantNull %v2float
%v3float = OpTypeVector %float 3 %v3float = OpTypeVector %float 3
%15 = OpConstantComposite %v3float %float_3 %float_3 %float_3
%_ptr_Function_v3float = OpTypePointer Function %v3float %_ptr_Function_v3float = OpTypePointer Function %v3float
%21 = OpConstantNull %v3float %18 = OpConstantNull %v3float
%v4float = OpTypeVector %float 4 %v4float = OpTypeVector %float 4
%20 = OpConstantComposite %v4float %float_3 %float_3 %float_3 %float_3
%_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float
%27 = OpConstantNull %v4float %23 = OpConstantNull %v4float
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v2 = OpVariable %_ptr_Function_v2float Function %15 %v2 = OpVariable %_ptr_Function_v2float Function %13
%v3 = OpVariable %_ptr_Function_v3float Function %21 %v3 = OpVariable %_ptr_Function_v3float Function %18
%v4 = OpVariable %_ptr_Function_v4float Function %27 %v4 = OpVariable %_ptr_Function_v4float Function %23
%11 = OpFAdd %float %float_1 %float_2 OpStore %v2 %10
%12 = OpCompositeConstruct %v2float %11 %11 OpStore %v3 %15
OpStore %v2 %12 OpStore %v4 %20
%17 = OpFAdd %float %float_1 %float_2
%18 = OpCompositeConstruct %v3float %17 %17 %17
OpStore %v3 %18
%23 = OpFAdd %float %float_1 %float_2
%24 = OpCompositeConstruct %v4float %23 %23 %23 %23
OpStore %v4 %24
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

6
test/tint/expressions/splat/expression/i32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
int2 v2 = int2(((1 + 2)).xx); int2 v2 = (3).xx;
int3 v3 = int3(((1 + 2)).xxx); int3 v3 = (3).xxx;
int4 v4 = int4(((1 + 2)).xxxx); int4 v4 = (3).xxxx;
} }

6
test/tint/expressions/splat/expression/i32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
int2 v2 = int2(((1 + 2)).xx); int2 v2 = (3).xx;
int3 v3 = int3(((1 + 2)).xxx); int3 v3 = (3).xxx;
int4 v4 = int4(((1 + 2)).xxxx); int4 v4 = (3).xxxx;
} }

6
test/tint/expressions/splat/expression/i32.wgsl.expected.glsl
View File

@ -5,8 +5,8 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
ivec2 v2 = ivec2((1 + 2)); ivec2 v2 = ivec2(3);
ivec3 v3 = ivec3((1 + 2)); ivec3 v3 = ivec3(3);
ivec4 v4 = ivec4((1 + 2)); ivec4 v4 = ivec4(3);
} }

6
test/tint/expressions/splat/expression/i32.wgsl.expected.msl
View File

@ -2,8 +2,8 @@
using namespace metal; using namespace metal;
void f() { void f() {
int2 v2 = int2(as_type<int>((as_type<uint>(1) + as_type<uint>(2)))); int2 v2 = int2(3);
int3 v3 = int3(as_type<int>((as_type<uint>(1) + as_type<uint>(2)))); int3 v3 = int3(3);
int4 v4 = int4(as_type<int>((as_type<uint>(1) + as_type<uint>(2)))); int4 v4 = int4(3);
} }

32
test/tint/expressions/splat/expression/i32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 28 ; Bound: 24
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,33 +16,29 @@
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%int = OpTypeInt 32 1 %int = OpTypeInt 32 1
%v2int = OpTypeVector %int 2 %v2int = OpTypeVector %int 2
%int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3
%int_2 = OpConstant %int 2 %10 = OpConstantComposite %v2int %int_3 %int_3
%_ptr_Function_v2int = OpTypePointer Function %v2int %_ptr_Function_v2int = OpTypePointer Function %v2int
%15 = OpConstantNull %v2int %13 = OpConstantNull %v2int
%v3int = OpTypeVector %int 3 %v3int = OpTypeVector %int 3
%15 = OpConstantComposite %v3int %int_3 %int_3 %int_3
%_ptr_Function_v3int = OpTypePointer Function %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int
%21 = OpConstantNull %v3int %18 = OpConstantNull %v3int
%v4int = OpTypeVector %int 4 %v4int = OpTypeVector %int 4
%20 = OpConstantComposite %v4int %int_3 %int_3 %int_3 %int_3
%_ptr_Function_v4int = OpTypePointer Function %v4int %_ptr_Function_v4int = OpTypePointer Function %v4int
%27 = OpConstantNull %v4int %23 = OpConstantNull %v4int
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v2 = OpVariable %_ptr_Function_v2int Function %15 %v2 = OpVariable %_ptr_Function_v2int Function %13
%v3 = OpVariable %_ptr_Function_v3int Function %21 %v3 = OpVariable %_ptr_Function_v3int Function %18
%v4 = OpVariable %_ptr_Function_v4int Function %27 %v4 = OpVariable %_ptr_Function_v4int Function %23
%11 = OpIAdd %int %int_1 %int_2 OpStore %v2 %10
%12 = OpCompositeConstruct %v2int %11 %11 OpStore %v3 %15
OpStore %v2 %12 OpStore %v4 %20
%17 = OpIAdd %int %int_1 %int_2
%18 = OpCompositeConstruct %v3int %17 %17 %17
OpStore %v3 %18
%23 = OpIAdd %int %int_1 %int_2
%24 = OpCompositeConstruct %v4int %23 %23 %23 %23
OpStore %v4 %24
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

6
test/tint/expressions/splat/expression/u32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
uint2 v2 = uint2(((1u + 2u)).xx); uint2 v2 = (3u).xx;
uint3 v3 = uint3(((1u + 2u)).xxx); uint3 v3 = (3u).xxx;
uint4 v4 = uint4(((1u + 2u)).xxxx); uint4 v4 = (3u).xxxx;
} }

6
test/tint/expressions/splat/expression/u32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
uint2 v2 = uint2(((1u + 2u)).xx); uint2 v2 = (3u).xx;
uint3 v3 = uint3(((1u + 2u)).xxx); uint3 v3 = (3u).xxx;
uint4 v4 = uint4(((1u + 2u)).xxxx); uint4 v4 = (3u).xxxx;
} }

6
test/tint/expressions/splat/expression/u32.wgsl.expected.glsl
View File

@ -5,8 +5,8 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
uvec2 v2 = uvec2((1u + 2u)); uvec2 v2 = uvec2(3u);
uvec3 v3 = uvec3((1u + 2u)); uvec3 v3 = uvec3(3u);
uvec4 v4 = uvec4((1u + 2u)); uvec4 v4 = uvec4(3u);
} }

6
test/tint/expressions/splat/expression/u32.wgsl.expected.msl
View File

@ -2,8 +2,8 @@
using namespace metal; using namespace metal;
void f() { void f() {
uint2 v2 = uint2((1u + 2u)); uint2 v2 = uint2(3u);
uint3 v3 = uint3((1u + 2u)); uint3 v3 = uint3(3u);
uint4 v4 = uint4((1u + 2u)); uint4 v4 = uint4(3u);
} }

32
test/tint/expressions/splat/expression/u32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 28 ; Bound: 24
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,33 +16,29 @@
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%uint = OpTypeInt 32 0 %uint = OpTypeInt 32 0
%v2uint = OpTypeVector %uint 2 %v2uint = OpTypeVector %uint 2
%uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3
%uint_2 = OpConstant %uint 2 %10 = OpConstantComposite %v2uint %uint_3 %uint_3
%_ptr_Function_v2uint = OpTypePointer Function %v2uint %_ptr_Function_v2uint = OpTypePointer Function %v2uint
%15 = OpConstantNull %v2uint %13 = OpConstantNull %v2uint
%v3uint = OpTypeVector %uint 3 %v3uint = OpTypeVector %uint 3
%15 = OpConstantComposite %v3uint %uint_3 %uint_3 %uint_3
%_ptr_Function_v3uint = OpTypePointer Function %v3uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint
%21 = OpConstantNull %v3uint %18 = OpConstantNull %v3uint
%v4uint = OpTypeVector %uint 4 %v4uint = OpTypeVector %uint 4
%20 = OpConstantComposite %v4uint %uint_3 %uint_3 %uint_3 %uint_3
%_ptr_Function_v4uint = OpTypePointer Function %v4uint %_ptr_Function_v4uint = OpTypePointer Function %v4uint
%27 = OpConstantNull %v4uint %23 = OpConstantNull %v4uint
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v2 = OpVariable %_ptr_Function_v2uint Function %15 %v2 = OpVariable %_ptr_Function_v2uint Function %13
%v3 = OpVariable %_ptr_Function_v3uint Function %21 %v3 = OpVariable %_ptr_Function_v3uint Function %18
%v4 = OpVariable %_ptr_Function_v4uint Function %27 %v4 = OpVariable %_ptr_Function_v4uint Function %23
%11 = OpIAdd %uint %uint_1 %uint_2 OpStore %v2 %10
%12 = OpCompositeConstruct %v2uint %11 %11 OpStore %v3 %15
OpStore %v2 %12 OpStore %v4 %20
%17 = OpIAdd %uint %uint_1 %uint_2
%18 = OpCompositeConstruct %v3uint %17 %17 %17
OpStore %v3 %18
%23 = OpIAdd %uint %uint_1 %uint_2
%24 = OpCompositeConstruct %v4uint %23 %23 %23 %23
OpStore %v4 %24
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/expressions/splat/var/f16.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
float16_t v = (float16_t(1.0h) + float16_t(2.0h)); float16_t v = float16_t(3.0h);
vector<float16_t, 2> v2 = vector<float16_t, 2>((v).xx); vector<float16_t, 2> v2 = vector<float16_t, 2>((v).xx);
vector<float16_t, 3> v3 = vector<float16_t, 3>((v).xxx); vector<float16_t, 3> v3 = vector<float16_t, 3>((v).xxx);
vector<float16_t, 4> v4 = vector<float16_t, 4>((v).xxxx); vector<float16_t, 4> v4 = vector<float16_t, 4>((v).xxxx);

2
test/tint/expressions/splat/var/f16.wgsl.expected.glsl
View File

@ -6,7 +6,7 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
float16_t v = (1.0hf + 2.0hf); float16_t v = 3.0hf;
f16vec2 v2 = f16vec2(v); f16vec2 v2 = f16vec2(v);
f16vec3 v3 = f16vec3(v); f16vec3 v3 = f16vec3(v);
f16vec4 v4 = f16vec4(v); f16vec4 v4 = f16vec4(v);

2
test/tint/expressions/splat/var/f16.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal; using namespace metal;
void f() { void f() {
half v = (1.0h + 2.0h); half v = 3.0h;
half2 v2 = half2(v); half2 v2 = half2(v);
half3 v3 = half3(v); half3 v3 = half3(v);
half4 v4 = half4(v); half4 v4 = half4(v);

42
test/tint/expressions/splat/var/f16.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 32 ; Bound: 30
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpCapability Float16 OpCapability Float16
@ -20,39 +20,37 @@
%void = OpTypeVoid %void = OpTypeVoid
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%half = OpTypeFloat 16 %half = OpTypeFloat 16
%half_0x1p_0 = OpConstant %half 0x1p+0 %half_0x1_8p_1 = OpConstant %half 0x1.8p+1
%half_0x1p_1 = OpConstant %half 0x1p+1
%_ptr_Function_half = OpTypePointer Function %half %_ptr_Function_half = OpTypePointer Function %half
%13 = OpConstantNull %half %11 = OpConstantNull %half
%v2half = OpTypeVector %half 2 %v2half = OpTypeVector %half 2
%_ptr_Function_v2half = OpTypePointer Function %v2half %_ptr_Function_v2half = OpTypePointer Function %v2half
%19 = OpConstantNull %v2half %17 = OpConstantNull %v2half
%v3half = OpTypeVector %half 3 %v3half = OpTypeVector %half 3
%_ptr_Function_v3half = OpTypePointer Function %v3half %_ptr_Function_v3half = OpTypePointer Function %v3half
%25 = OpConstantNull %v3half %23 = OpConstantNull %v3half
%v4half = OpTypeVector %half 4 %v4half = OpTypeVector %half 4
%_ptr_Function_v4half = OpTypePointer Function %v4half %_ptr_Function_v4half = OpTypePointer Function %v4half
%31 = OpConstantNull %v4half %29 = OpConstantNull %v4half
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v = OpVariable %_ptr_Function_half Function %13 %v = OpVariable %_ptr_Function_half Function %11
%v2 = OpVariable %_ptr_Function_v2half Function %19 %v2 = OpVariable %_ptr_Function_v2half Function %17
%v3 = OpVariable %_ptr_Function_v3half Function %25 %v3 = OpVariable %_ptr_Function_v3half Function %23
%v4 = OpVariable %_ptr_Function_v4half Function %31 %v4 = OpVariable %_ptr_Function_v4half Function %29
%10 = OpFAdd %half %half_0x1p_0 %half_0x1p_1 OpStore %v %half_0x1_8p_1
OpStore %v %10 %13 = OpLoad %half %v
%15 = OpLoad %half %v %14 = OpCompositeConstruct %v2half %13 %13
%16 = OpCompositeConstruct %v2half %15 %15 OpStore %v2 %14
OpStore %v2 %16 %19 = OpLoad %half %v
%21 = OpLoad %half %v %20 = OpCompositeConstruct %v3half %19 %19 %19
%22 = OpCompositeConstruct %v3half %21 %21 %21 OpStore %v3 %20
OpStore %v3 %22 %25 = OpLoad %half %v
%27 = OpLoad %half %v %26 = OpCompositeConstruct %v4half %25 %25 %25 %25
%28 = OpCompositeConstruct %v4half %27 %27 %27 %27 OpStore %v4 %26
OpStore %v4 %28
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/expressions/splat/var/f32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
float v = (1.0f + 2.0f); float v = 3.0f;
float2 v2 = float2((v).xx); float2 v2 = float2((v).xx);
float3 v3 = float3((v).xxx); float3 v3 = float3((v).xxx);
float4 v4 = float4((v).xxxx); float4 v4 = float4((v).xxxx);

2
test/tint/expressions/splat/var/f32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
float v = (1.0f + 2.0f); float v = 3.0f;
float2 v2 = float2((v).xx); float2 v2 = float2((v).xx);
float3 v3 = float3((v).xxx); float3 v3 = float3((v).xxx);
float4 v4 = float4((v).xxxx); float4 v4 = float4((v).xxxx);

2
test/tint/expressions/splat/var/f32.wgsl.expected.glsl
View File

@ -5,7 +5,7 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
float v = (1.0f + 2.0f); float v = 3.0f;
vec2 v2 = vec2(v); vec2 v2 = vec2(v);
vec3 v3 = vec3(v); vec3 v3 = vec3(v);
vec4 v4 = vec4(v); vec4 v4 = vec4(v);

2
test/tint/expressions/splat/var/f32.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal; using namespace metal;
void f() { void f() {
float v = (1.0f + 2.0f); float v = 3.0f;
float2 v2 = float2(v); float2 v2 = float2(v);
float3 v3 = float3(v); float3 v3 = float3(v);
float4 v4 = float4(v); float4 v4 = float4(v);

42
test/tint/expressions/splat/var/f32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 32 ; Bound: 30
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,39 +16,37 @@
%void = OpTypeVoid %void = OpTypeVoid
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%float = OpTypeFloat 32 %float = OpTypeFloat 32
%float_1 = OpConstant %float 1 %float_3 = OpConstant %float 3
%float_2 = OpConstant %float 2
%_ptr_Function_float = OpTypePointer Function %float %_ptr_Function_float = OpTypePointer Function %float
%13 = OpConstantNull %float %11 = OpConstantNull %float
%v2float = OpTypeVector %float 2 %v2float = OpTypeVector %float 2
%_ptr_Function_v2float = OpTypePointer Function %v2float %_ptr_Function_v2float = OpTypePointer Function %v2float
%19 = OpConstantNull %v2float %17 = OpConstantNull %v2float
%v3float = OpTypeVector %float 3 %v3float = OpTypeVector %float 3
%_ptr_Function_v3float = OpTypePointer Function %v3float %_ptr_Function_v3float = OpTypePointer Function %v3float
%25 = OpConstantNull %v3float %23 = OpConstantNull %v3float
%v4float = OpTypeVector %float 4 %v4float = OpTypeVector %float 4
%_ptr_Function_v4float = OpTypePointer Function %v4float %_ptr_Function_v4float = OpTypePointer Function %v4float
%31 = OpConstantNull %v4float %29 = OpConstantNull %v4float
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v = OpVariable %_ptr_Function_float Function %13 %v = OpVariable %_ptr_Function_float Function %11
%v2 = OpVariable %_ptr_Function_v2float Function %19 %v2 = OpVariable %_ptr_Function_v2float Function %17
%v3 = OpVariable %_ptr_Function_v3float Function %25 %v3 = OpVariable %_ptr_Function_v3float Function %23
%v4 = OpVariable %_ptr_Function_v4float Function %31 %v4 = OpVariable %_ptr_Function_v4float Function %29
%10 = OpFAdd %float %float_1 %float_2 OpStore %v %float_3
OpStore %v %10 %13 = OpLoad %float %v
%15 = OpLoad %float %v %14 = OpCompositeConstruct %v2float %13 %13
%16 = OpCompositeConstruct %v2float %15 %15 OpStore %v2 %14
OpStore %v2 %16 %19 = OpLoad %float %v
%21 = OpLoad %float %v %20 = OpCompositeConstruct %v3float %19 %19 %19
%22 = OpCompositeConstruct %v3float %21 %21 %21 OpStore %v3 %20
OpStore %v3 %22 %25 = OpLoad %float %v
%27 = OpLoad %float %v %26 = OpCompositeConstruct %v4float %25 %25 %25 %25
%28 = OpCompositeConstruct %v4float %27 %27 %27 %27 OpStore %v4 %26
OpStore %v4 %28
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/expressions/splat/var/i32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
int v = (1 + 2); int v = 3;
int2 v2 = int2((v).xx); int2 v2 = int2((v).xx);
int3 v3 = int3((v).xxx); int3 v3 = int3((v).xxx);
int4 v4 = int4((v).xxxx); int4 v4 = int4((v).xxxx);

2
test/tint/expressions/splat/var/i32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
int v = (1 + 2); int v = 3;
int2 v2 = int2((v).xx); int2 v2 = int2((v).xx);
int3 v3 = int3((v).xxx); int3 v3 = int3((v).xxx);
int4 v4 = int4((v).xxxx); int4 v4 = int4((v).xxxx);

2
test/tint/expressions/splat/var/i32.wgsl.expected.glsl
View File

@ -5,7 +5,7 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
int v = (1 + 2); int v = 3;
ivec2 v2 = ivec2(v); ivec2 v2 = ivec2(v);
ivec3 v3 = ivec3(v); ivec3 v3 = ivec3(v);
ivec4 v4 = ivec4(v); ivec4 v4 = ivec4(v);

2
test/tint/expressions/splat/var/i32.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal; using namespace metal;
void f() { void f() {
int v = as_type<int>((as_type<uint>(1) + as_type<uint>(2))); int v = 3;
int2 v2 = int2(v); int2 v2 = int2(v);
int3 v3 = int3(v); int3 v3 = int3(v);
int4 v4 = int4(v); int4 v4 = int4(v);

42
test/tint/expressions/splat/var/i32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 32 ; Bound: 30
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,39 +16,37 @@
%void = OpTypeVoid %void = OpTypeVoid
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%int = OpTypeInt 32 1 %int = OpTypeInt 32 1
%int_1 = OpConstant %int 1 %int_3 = OpConstant %int 3
%int_2 = OpConstant %int 2
%_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_int = OpTypePointer Function %int
%13 = OpConstantNull %int %11 = OpConstantNull %int
%v2int = OpTypeVector %int 2 %v2int = OpTypeVector %int 2
%_ptr_Function_v2int = OpTypePointer Function %v2int %_ptr_Function_v2int = OpTypePointer Function %v2int
%19 = OpConstantNull %v2int %17 = OpConstantNull %v2int
%v3int = OpTypeVector %int 3 %v3int = OpTypeVector %int 3
%_ptr_Function_v3int = OpTypePointer Function %v3int %_ptr_Function_v3int = OpTypePointer Function %v3int
%25 = OpConstantNull %v3int %23 = OpConstantNull %v3int
%v4int = OpTypeVector %int 4 %v4int = OpTypeVector %int 4
%_ptr_Function_v4int = OpTypePointer Function %v4int %_ptr_Function_v4int = OpTypePointer Function %v4int
%31 = OpConstantNull %v4int %29 = OpConstantNull %v4int
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v = OpVariable %_ptr_Function_int Function %13 %v = OpVariable %_ptr_Function_int Function %11
%v2 = OpVariable %_ptr_Function_v2int Function %19 %v2 = OpVariable %_ptr_Function_v2int Function %17
%v3 = OpVariable %_ptr_Function_v3int Function %25 %v3 = OpVariable %_ptr_Function_v3int Function %23
%v4 = OpVariable %_ptr_Function_v4int Function %31 %v4 = OpVariable %_ptr_Function_v4int Function %29
%10 = OpIAdd %int %int_1 %int_2 OpStore %v %int_3
OpStore %v %10 %13 = OpLoad %int %v
%15 = OpLoad %int %v %14 = OpCompositeConstruct %v2int %13 %13
%16 = OpCompositeConstruct %v2int %15 %15 OpStore %v2 %14
OpStore %v2 %16 %19 = OpLoad %int %v
%21 = OpLoad %int %v %20 = OpCompositeConstruct %v3int %19 %19 %19
%22 = OpCompositeConstruct %v3int %21 %21 %21 OpStore %v3 %20
OpStore %v3 %22 %25 = OpLoad %int %v
%27 = OpLoad %int %v %26 = OpCompositeConstruct %v4int %25 %25 %25 %25
%28 = OpCompositeConstruct %v4int %27 %27 %27 %27 OpStore %v4 %26
OpStore %v4 %28
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/expressions/splat/var/u32.wgsl.expected.dxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
uint v = (1u + 2u); uint v = 3u;
uint2 v2 = uint2((v).xx); uint2 v2 = uint2((v).xx);
uint3 v3 = uint3((v).xxx); uint3 v3 = uint3((v).xxx);
uint4 v4 = uint4((v).xxxx); uint4 v4 = uint4((v).xxxx);

2
test/tint/expressions/splat/var/u32.wgsl.expected.fxc.hlsl
View File

@ -4,7 +4,7 @@ void unused_entry_point() {
} }
void f() { void f() {
uint v = (1u + 2u); uint v = 3u;
uint2 v2 = uint2((v).xx); uint2 v2 = uint2((v).xx);
uint3 v3 = uint3((v).xxx); uint3 v3 = uint3((v).xxx);
uint4 v4 = uint4((v).xxxx); uint4 v4 = uint4((v).xxxx);

2
test/tint/expressions/splat/var/u32.wgsl.expected.glsl
View File

@ -5,7 +5,7 @@ void unused_entry_point() {
return; return;
} }
void f() { void f() {
uint v = (1u + 2u); uint v = 3u;
uvec2 v2 = uvec2(v); uvec2 v2 = uvec2(v);
uvec3 v3 = uvec3(v); uvec3 v3 = uvec3(v);
uvec4 v4 = uvec4(v); uvec4 v4 = uvec4(v);

2
test/tint/expressions/splat/var/u32.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal; using namespace metal;
void f() { void f() {
uint v = (1u + 2u); uint v = 3u;
uint2 v2 = uint2(v); uint2 v2 = uint2(v);
uint3 v3 = uint3(v); uint3 v3 = uint3(v);
uint4 v4 = uint4(v); uint4 v4 = uint4(v);

42
test/tint/expressions/splat/var/u32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 32 ; Bound: 30
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,39 +16,37 @@
%void = OpTypeVoid %void = OpTypeVoid
%1 = OpTypeFunction %void %1 = OpTypeFunction %void
%uint = OpTypeInt 32 0 %uint = OpTypeInt 32 0
%uint_1 = OpConstant %uint 1 %uint_3 = OpConstant %uint 3
%uint_2 = OpConstant %uint 2
%_ptr_Function_uint = OpTypePointer Function %uint %_ptr_Function_uint = OpTypePointer Function %uint
%13 = OpConstantNull %uint %11 = OpConstantNull %uint
%v2uint = OpTypeVector %uint 2 %v2uint = OpTypeVector %uint 2
%_ptr_Function_v2uint = OpTypePointer Function %v2uint %_ptr_Function_v2uint = OpTypePointer Function %v2uint
%19 = OpConstantNull %v2uint %17 = OpConstantNull %v2uint
%v3uint = OpTypeVector %uint 3 %v3uint = OpTypeVector %uint 3
%_ptr_Function_v3uint = OpTypePointer Function %v3uint %_ptr_Function_v3uint = OpTypePointer Function %v3uint
%25 = OpConstantNull %v3uint %23 = OpConstantNull %v3uint
%v4uint = OpTypeVector %uint 4 %v4uint = OpTypeVector %uint 4
%_ptr_Function_v4uint = OpTypePointer Function %v4uint %_ptr_Function_v4uint = OpTypePointer Function %v4uint
%31 = OpConstantNull %v4uint %29 = OpConstantNull %v4uint
%unused_entry_point = OpFunction %void None %1 %unused_entry_point = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%f = OpFunction %void None %1 %f = OpFunction %void None %1
%6 = OpLabel %6 = OpLabel
%v = OpVariable %_ptr_Function_uint Function %13 %v = OpVariable %_ptr_Function_uint Function %11
%v2 = OpVariable %_ptr_Function_v2uint Function %19 %v2 = OpVariable %_ptr_Function_v2uint Function %17
%v3 = OpVariable %_ptr_Function_v3uint Function %25 %v3 = OpVariable %_ptr_Function_v3uint Function %23
%v4 = OpVariable %_ptr_Function_v4uint Function %31 %v4 = OpVariable %_ptr_Function_v4uint Function %29
%10 = OpIAdd %uint %uint_1 %uint_2 OpStore %v %uint_3
OpStore %v %10 %13 = OpLoad %uint %v
%15 = OpLoad %uint %v %14 = OpCompositeConstruct %v2uint %13 %13
%16 = OpCompositeConstruct %v2uint %15 %15 OpStore %v2 %14
OpStore %v2 %16 %19 = OpLoad %uint %v
%21 = OpLoad %uint %v %20 = OpCompositeConstruct %v3uint %19 %19 %19
%22 = OpCompositeConstruct %v3uint %21 %21 %21 OpStore %v3 %20
OpStore %v3 %22 %25 = OpLoad %uint %v
%27 = OpLoad %uint %v %26 = OpCompositeConstruct %v4uint %25 %25 %25 %25
%28 = OpCompositeConstruct %v4uint %27 %27 %27 %27 OpStore %v4 %26
OpStore %v4 %28
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/ptr_ref/store/global/i32.spvasm.expected.dxc.hlsl
View File

@ -2,7 +2,7 @@ static int I = 0;
void main_1() { void main_1() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
return; return;
} }

2
test/tint/ptr_ref/store/global/i32.spvasm.expected.fxc.hlsl
View File

@ -2,7 +2,7 @@ static int I = 0;
void main_1() { void main_1() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
return; return;
} }

2
test/tint/ptr_ref/store/global/i32.spvasm.expected.glsl
View File

@ -3,7 +3,7 @@
int I = 0; int I = 0;
void main_1() { void main_1() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
return; return;
} }

2
test/tint/ptr_ref/store/global/i32.spvasm.expected.msl
View File

@ -4,7 +4,7 @@ using namespace metal;
void main_1() { void main_1() {
thread int tint_symbol_1 = 0; thread int tint_symbol_1 = 0;
tint_symbol_1 = 123; tint_symbol_1 = 123;
tint_symbol_1 = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(100) + as_type<uint>(20)))) + as_type<uint>(3))); tint_symbol_1 = 123;
return; return;
} }

13
test/tint/ptr_ref/store/global/i32.spvasm.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 18 ; Bound: 13
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -17,19 +17,14 @@
%void = OpTypeVoid %void = OpTypeVoid
%5 = OpTypeFunction %void %5 = OpTypeFunction %void
%int_123 = OpConstant %int 123 %int_123 = OpConstant %int 123
%int_100 = OpConstant %int 100
%int_20 = OpConstant %int 20
%int_3 = OpConstant %int 3
%main_1 = OpFunction %void None %5 %main_1 = OpFunction %void None %5
%8 = OpLabel %8 = OpLabel
OpStore %I %int_123 OpStore %I %int_123
%12 = OpIAdd %int %int_100 %int_20 OpStore %I %int_123
%14 = OpIAdd %int %12 %int_3
OpStore %I %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%main = OpFunction %void None %5 %main = OpFunction %void None %5
%16 = OpLabel %11 = OpLabel
%17 = OpFunctionCall %void %main_1 %12 = OpFunctionCall %void %main_1
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/ptr_ref/store/global/i32.wgsl.expected.dxc.hlsl
View File

@ -3,6 +3,6 @@ static int I = 0;
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
return; return;
} }

2
test/tint/ptr_ref/store/global/i32.wgsl.expected.fxc.hlsl
View File

@ -3,6 +3,6 @@ static int I = 0;
[numthreads(1, 1, 1)] [numthreads(1, 1, 1)]
void main() { void main() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
return; return;
} }

2
test/tint/ptr_ref/store/global/i32.wgsl.expected.glsl
View File

@ -3,7 +3,7 @@
int I = 0; int I = 0;
void tint_symbol() { void tint_symbol() {
I = 123; I = 123;
I = ((100 + 20) + 3); I = 123;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/ptr_ref/store/global/i32.wgsl.expected.msl
View File

@ -4,7 +4,7 @@ using namespace metal;
kernel void tint_symbol() { kernel void tint_symbol() {
thread int tint_symbol_1 = 0; thread int tint_symbol_1 = 0;
tint_symbol_1 = 123; tint_symbol_1 = 123;
tint_symbol_1 = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(100) + as_type<uint>(20)))) + as_type<uint>(3))); tint_symbol_1 = 123;
return; return;
} }

9
test/tint/ptr_ref/store/global/i32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 15 ; Bound: 10
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,14 +16,9 @@
%void = OpTypeVoid %void = OpTypeVoid
%5 = OpTypeFunction %void %5 = OpTypeFunction %void
%int_123 = OpConstant %int 123 %int_123 = OpConstant %int 123
%int_100 = OpConstant %int 100
%int_20 = OpConstant %int 20
%int_3 = OpConstant %int 3
%main = OpFunction %void None %5 %main = OpFunction %void None %5
%8 = OpLabel %8 = OpLabel
OpStore %I %int_123 OpStore %I %int_123
%12 = OpIAdd %int %int_100 %int_20 OpStore %I %int_123
%14 = OpIAdd %int %12 %int_3
OpStore %I %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/ptr_ref/store/local/i32.spvasm.expected.dxc.hlsl
View File

@ -2,7 +2,7 @@ void main_1() {
int i = 0; int i = 0;
i = 123; i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
return; return;
} }

2
test/tint/ptr_ref/store/local/i32.spvasm.expected.fxc.hlsl
View File

@ -2,7 +2,7 @@ void main_1() {
int i = 0; int i = 0;
i = 123; i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
return; return;
} }

2
test/tint/ptr_ref/store/local/i32.spvasm.expected.glsl
View File

@ -4,7 +4,7 @@ void main_1() {
int i = 0; int i = 0;
i = 123; i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
return; return;
} }

2
test/tint/ptr_ref/store/local/i32.spvasm.expected.msl
View File

@ -5,7 +5,7 @@ void main_1() {
int i = 0; int i = 0;
i = 123; i = 123;
i = 123; i = 123;
i = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(100) + as_type<uint>(20)))) + as_type<uint>(3))); i = 123;
return; return;
} }

13
test/tint/ptr_ref/store/local/i32.spvasm.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 18 ; Bound: 13
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -16,22 +16,17 @@
%6 = OpConstantNull %int %6 = OpConstantNull %int
%_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_int = OpTypePointer Function %int
%int_123 = OpConstant %int 123 %int_123 = OpConstant %int 123
%int_100 = OpConstant %int 100
%int_20 = OpConstant %int 20
%int_3 = OpConstant %int 3
%main_1 = OpFunction %void None %1 %main_1 = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
%i = OpVariable %_ptr_Function_int Function %6 %i = OpVariable %_ptr_Function_int Function %6
OpStore %i %6 OpStore %i %6
OpStore %i %int_123 OpStore %i %int_123
OpStore %i %int_123 OpStore %i %int_123
%12 = OpIAdd %int %int_100 %int_20 OpStore %i %int_123
%14 = OpIAdd %int %12 %int_3
OpStore %i %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd
%main = OpFunction %void None %1 %main = OpFunction %void None %1
%16 = OpLabel %11 = OpLabel
%17 = OpFunctionCall %void %main_1 %12 = OpFunctionCall %void %main_1
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd

2
test/tint/ptr_ref/store/local/i32.wgsl.expected.dxc.hlsl
View File

@ -2,6 +2,6 @@
void main() { void main() {
int i = 123; int i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
return; return;
} }

2
test/tint/ptr_ref/store/local/i32.wgsl.expected.fxc.hlsl
View File

@ -2,6 +2,6 @@
void main() { void main() {
int i = 123; int i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
return; return;
} }

2
test/tint/ptr_ref/store/local/i32.wgsl.expected.glsl
View File

@ -3,7 +3,7 @@
void tint_symbol() { void tint_symbol() {
int i = 123; int i = 123;
i = 123; i = 123;
i = ((100 + 20) + 3); i = 123;
} }
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

2
test/tint/ptr_ref/store/local/i32.wgsl.expected.msl
View File

@ -4,7 +4,7 @@ using namespace metal;
kernel void tint_symbol() { kernel void tint_symbol() {
int i = 123; int i = 123;
i = 123; i = 123;
i = as_type<int>((as_type<uint>(as_type<int>((as_type<uint>(100) + as_type<uint>(20)))) + as_type<uint>(3))); i = 123;
return; return;
} }

9
test/tint/ptr_ref/store/local/i32.wgsl.expected.spvasm
View File

@ -1,7 +1,7 @@
; SPIR-V ; SPIR-V
; Version: 1.3 ; Version: 1.3
; Generator: Google Tint Compiler; 0 ; Generator: Google Tint Compiler; 0
; Bound: 15 ; Bound: 10
; Schema: 0 ; Schema: 0
OpCapability Shader OpCapability Shader
OpMemoryModel Logical GLSL450 OpMemoryModel Logical GLSL450
@ -15,16 +15,11 @@
%int_123 = OpConstant %int 123 %int_123 = OpConstant %int 123
%_ptr_Function_int = OpTypePointer Function %int %_ptr_Function_int = OpTypePointer Function %int
%9 = OpConstantNull %int %9 = OpConstantNull %int
%int_100 = OpConstant %int 100
%int_20 = OpConstant %int 20
%int_3 = OpConstant %int 3
%main = OpFunction %void None %1 %main = OpFunction %void None %1
%4 = OpLabel %4 = OpLabel
%i = OpVariable %_ptr_Function_int Function %9 %i = OpVariable %_ptr_Function_int Function %9
OpStore %i %int_123 OpStore %i %int_123
OpStore %i %int_123 OpStore %i %int_123
%12 = OpIAdd %int %int_100 %int_20 OpStore %i %int_123
%14 = OpIAdd %int %12 %int_3
OpStore %i %14
OpReturn OpReturn
OpFunctionEnd OpFunctionEnd