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

Fix intrinsic tests so arguments match an overload

Browse Source 
Change-Id: I8c5464e3198c6a3b154f5f3433466955e203efee
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/40502
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
This commit is contained in:
Ben Clayton 2021-02-08 21:10:11 +00:00 committed by Commit Bot service account
parent 21692def05
commit a51aa1f805
5 changed files with 157 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
src/type_determiner_test.cc
View File

@ -1725,8 +1725,11 @@ using ImportData_DataPackingTest = TypeDeterminerTestWithParam<IntrinsicData>;
TEST_P(ImportData_DataPackingTest, InferType) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident);
bool pack4 = param.intrinsic == IntrinsicType::kPack4x8Snorm ||
param.intrinsic == IntrinsicType::kPack4x8Unorm;
auto* call = pack4 ? Call(param.name, vec4<f32>(1.f, 2.f, 3.f, 4.f))
: Call(param.name, vec2<f32>(1.f, 2.f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1748,8 +1751,7 @@ using ImportData_SingleParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
TEST_P(ImportData_SingleParamTest, Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.f);
auto* call = Call(param.name, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1761,8 +1763,7 @@ TEST_P(ImportData_SingleParamTest, Scalar) {
TEST_P(ImportData_SingleParamTest, Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f));
auto* call = Call(param.name, vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1801,7 +1802,6 @@ INSTANTIATE_TEST_SUITE_P(
IntrinsicData{"inverseSqrt", IntrinsicType::kInverseSqrt},
IntrinsicData{"log", IntrinsicType::kLog},
IntrinsicData{"log2", IntrinsicType::kLog2},
IntrinsicData{"normalize", IntrinsicType::kNormalize},
IntrinsicData{"round", IntrinsicType::kRound},
IntrinsicData{"sign", IntrinsicType::kSign},
IntrinsicData{"sin", IntrinsicType::kSin},
@ -1811,13 +1811,34 @@ INSTANTIATE_TEST_SUITE_P(
IntrinsicData{"tanh", IntrinsicType::kTanh},
IntrinsicData{"trunc", IntrinsicType::kTrunc}));
TEST_F(IntrinsicDataTest, Normalize_Vector) {
auto* call = Call("normalize", vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
ASSERT_NE(TypeOf(call), nullptr);
EXPECT_TRUE(TypeOf(call)->is_float_vector());
EXPECT_EQ(TypeOf(call)->As<type::Vector>()->size(), 3u);
}
TEST_F(IntrinsicDataTest, Normalize_Error_NoParams) {
auto* call = Call("normalize");
WrapInFunction(call);
EXPECT_FALSE(td()->Determine());
EXPECT_EQ(td()->error(),
"missing parameter 0 required for type determination in builtin "
"normalize");
}
using ImportData_SingleParam_FloatOrInt_Test =
TypeDeterminerTestWithParam<IntrinsicData>;
TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.f);
auto* call = Call(param.name, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1829,8 +1850,7 @@ TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Scalar) {
TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f));
auto* call = Call(param.name, vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1843,8 +1863,7 @@ TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Vector) {
TEST_P(ImportData_SingleParam_FloatOrInt_Test, Sint_Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, -1);
auto* call = Call(param.name, -1);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1864,8 +1883,7 @@ TEST_P(ImportData_SingleParam_FloatOrInt_Test, Sint_Vector) {
ast::ExpressionList params;
params.push_back(vec3<i32>(vals));
auto* ident = Expr(param.name);
auto* call = Call(ident, params);
auto* call = Call(param.name, params);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1881,8 +1899,7 @@ TEST_P(ImportData_SingleParam_FloatOrInt_Test, Uint_Scalar) {
ast::ExpressionList params;
params.push_back(Expr(1u));
auto* ident = Expr(param.name);
auto* call = Call(ident, params);
auto* call = Call(param.name, params);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1894,8 +1911,7 @@ TEST_P(ImportData_SingleParam_FloatOrInt_Test, Uint_Scalar) {
TEST_P(ImportData_SingleParam_FloatOrInt_Test, Uint_Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<u32>(1u, 1u, 3u));
auto* call = Call(param.name, vec3<u32>(1u, 1u, 3u));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1924,9 +1940,7 @@ INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
IntrinsicType::kAbs}));
TEST_F(TypeDeterminerTest, ImportData_Length_Scalar) {
auto* ident = Expr("length");
auto* call = Call(ident, 1.f);
auto* call = Call("length", 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1939,9 +1953,7 @@ TEST_F(TypeDeterminerTest, ImportData_Length_FloatVector) {
ast::ExpressionList params;
params.push_back(vec3<f32>(1.0f, 1.0f, 3.0f));
auto* ident = Expr("length");
auto* call = Call(ident, params);
auto* call = Call("length", params);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1954,8 +1966,7 @@ using ImportData_TwoParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
TEST_P(ImportData_TwoParamTest, Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.f, 1.f);
auto* call = Call(param.name, 1.f, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1967,9 +1978,8 @@ TEST_P(ImportData_TwoParamTest, Scalar) {
TEST_P(ImportData_TwoParamTest, Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call =
Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
auto* call = Call(param.name, vec3<f32>(1.0f, 1.0f, 3.0f),
vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -1999,9 +2009,7 @@ INSTANTIATE_TEST_SUITE_P(
IntrinsicData{"reflect", IntrinsicType::kReflect}));
TEST_F(TypeDeterminerTest, ImportData_Distance_Scalar) {
auto* ident = Expr("distance");
auto* call = Call(ident, 1.f, 1.f);
auto* call = Call("distance", 1.f, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2011,10 +2019,8 @@ TEST_F(TypeDeterminerTest, ImportData_Distance_Scalar) {
}
TEST_F(TypeDeterminerTest, ImportData_Distance_Vector) {
auto* ident = Expr("distance");
auto* call =
Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
auto* call = Call("distance", vec3<f32>(1.0f, 1.0f, 3.0f),
vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2024,10 +2030,8 @@ TEST_F(TypeDeterminerTest, ImportData_Distance_Vector) {
}
TEST_F(TypeDeterminerTest, ImportData_Cross) {
auto* ident = Expr("cross");
auto* call =
Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
Call("cross", vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2038,9 +2042,7 @@ TEST_F(TypeDeterminerTest, ImportData_Cross) {
}
TEST_F(TypeDeterminerTest, ImportData_Cross_AutoType) {
auto* ident = Expr("cross");
auto* call = Call(ident);
auto* call = Call("cross");
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2054,8 +2056,7 @@ using ImportData_ThreeParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
TEST_P(ImportData_ThreeParamTest, Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.f, 1.f, 1.f);
auto* call = Call(param.name, 1.f, 1.f, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2067,8 +2068,7 @@ TEST_P(ImportData_ThreeParamTest, Scalar) {
TEST_P(ImportData_ThreeParamTest, Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f),
auto* call = Call(param.name, vec3<f32>(1.0f, 1.0f, 3.0f),
vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
@ -2104,8 +2104,7 @@ using ImportData_ThreeParam_FloatOrInt_Test =
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.f, 1.f, 1.f);
auto* call = Call(param.name, 1.f, 1.f, 1.f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2117,8 +2116,7 @@ TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Scalar) {
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<f32>(1.0f, 1.0f, 3.0f),
auto* call = Call(param.name, vec3<f32>(1.0f, 1.0f, 3.0f),
vec3<f32>(1.0f, 1.0f, 3.0f), vec3<f32>(1.0f, 1.0f, 3.0f));
WrapInFunction(call);
@ -2132,8 +2130,7 @@ TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Vector) {
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1, 1, 1);
auto* call = Call(param.name, 1, 1, 1);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2145,9 +2142,8 @@ TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Scalar) {
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call =
Call(ident, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3));
auto* call = Call(param.name, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3),
vec3<i32>(1, 1, 3));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2160,8 +2156,7 @@ TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Vector) {
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Uint_Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1u, 1u, 1u);
auto* call = Call(param.name, 1u, 1u, 1u);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2173,8 +2168,7 @@ TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Uint_Scalar) {
TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Uint_Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u),
auto* call = Call(param.name, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u),
vec3<u32>(1u, 1u, 3u));
WrapInFunction(call);
@ -2208,8 +2202,7 @@ using ImportData_Int_SingleParamTest =
TEST_P(ImportData_Int_SingleParamTest, Scalar) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1);
auto* call = Call(param.name, 1);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2221,8 +2214,7 @@ TEST_P(ImportData_Int_SingleParamTest, Scalar) {
TEST_P(ImportData_Int_SingleParamTest, Vector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<i32>(1, 1, 3));
auto* call = Call(param.name, vec3<i32>(1, 1, 3));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2256,8 +2248,7 @@ using ImportData_FloatOrInt_TwoParamTest =
TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Signed) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1, 1);
auto* call = Call(param.name, 1, 1);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2269,8 +2260,7 @@ TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Signed) {
TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Unsigned) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1u, 1u);
auto* call = Call(param.name, 1u, 1u);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2282,8 +2272,7 @@ TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Unsigned) {
TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Float) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, 1.0f, 1.0f);
auto* call = Call(param.name, 1.0f, 1.0f);
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2295,8 +2284,7 @@ TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Float) {
TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Signed) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3));
auto* call = Call(param.name, vec3<i32>(1, 1, 3), vec3<i32>(1, 1, 3));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2309,8 +2297,7 @@ TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Signed) {
TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Unsigned) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u));
auto* call = Call(param.name, vec3<u32>(1u, 1u, 3u), vec3<u32>(1u, 1u, 3u));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2323,8 +2310,8 @@ TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Unsigned) {
TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Float) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* call = Call(ident, vec3<f32>(1.f, 1.f, 3.f), vec3<f32>(1.f, 1.f, 3.f));
auto* call =
Call(param.name, vec3<f32>(1.f, 1.f, 3.f), vec3<f32>(1.f, 1.f, 3.f));
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2356,9 +2343,7 @@ INSTANTIATE_TEST_SUITE_P(
TEST_F(TypeDeterminerTest, ImportData_GLSL_Determinant) {
Global("var", ast::StorageClass::kFunction, ty.mat3x3<f32>());
auto* ident = Expr("determinant");
auto* call = Call(ident, "var");
auto* call = Call("determinant", "var");
WrapInFunction(call);
EXPECT_TRUE(td()->Determine()) << td()->error();
@ -2800,8 +2785,7 @@ TEST_P(TypeDeterminerTextureIntrinsicTest, Call) {
param.buildTextureVariable(this);
param.buildSamplerVariable(this);
auto* ident = Expr(param.function);
auto* call = Call(ident, param.args(this));
auto* call = Call(param.function, param.args(this));
WrapInFunction(call);
ASSERT_TRUE(td()->Determine()) << td()->error();

6
src/validator/validator_builtins_test.cc
View File

@ -303,12 +303,8 @@ TEST_F(ValidatorBuiltinsTest, Determinant_TooFewParams) {
TEST_F(ValidatorBuiltinsTest, Frexp_Scalar) {
auto* a = Var("a", ast::StorageClass::kWorkgroup, ty.i32());
auto* b =
Const("b", ast::StorageClass::kWorkgroup,
ty.pointer<int>(ast::StorageClass::kWorkgroup), Expr("a"), {});
RegisterVariable(a);
RegisterVariable(b);
auto* builtin = Call("frexp", 1.0f, Expr("b"));
auto* builtin = Call("frexp", 1.0f, Expr("a"));
WrapInFunction(builtin);
ValidatorImpl& v = Build();

44
src/writer/hlsl/generator_impl_import_test.cc
View File

@ -76,8 +76,6 @@ INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData{"length", "length"},
HlslImportData{"log", "log"},
HlslImportData{"log2", "log2"},
HlslImportData{"normalize",
"normalize"},
HlslImportData{"round", "round"},
HlslImportData{"sign", "sign"},
HlslImportData{"sin", "sin"},
@ -103,6 +101,48 @@ INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData_SingleIntParamTest,
testing::Values(HlslImportData{"abs", "abs"}));
using HlslImportData_SingleVectorParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_SingleVectorParamTest, FloatVector) {
auto param = GetParam();
auto* ident = Expr(param.name);
auto* expr = Call(ident, vec3<f32>(1.f, 2.f, 3.f));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitCall(pre, out, expr)) << gen.error();
EXPECT_EQ(result(),
std::string(param.hlsl_name) + "(float3(1.0f, 2.0f, 3.0f))");
}
INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
HlslImportData_SingleVectorParamTest,
testing::Values(HlslImportData{"abs", "abs"},
HlslImportData{"acos", "acos"},
HlslImportData{"asin", "asin"},
HlslImportData{"atan", "atan"},
HlslImportData{"cos", "cos"},
HlslImportData{"cosh", "cosh"},
HlslImportData{"ceil", "ceil"},
HlslImportData{"exp", "exp"},
HlslImportData{"exp2", "exp2"},
HlslImportData{"floor", "floor"},
HlslImportData{"fract", "frac"},
HlslImportData{"inverseSqrt", "rsqrt"},
HlslImportData{"length", "length"},
HlslImportData{"log", "log"},
HlslImportData{"log2", "log2"},
HlslImportData{"normalize",
"normalize"},
HlslImportData{"round", "round"},
HlslImportData{"sign", "sign"},
HlslImportData{"sin", "sin"},
HlslImportData{"sinh", "sinh"},
HlslImportData{"sqrt", "sqrt"},
HlslImportData{"tan", "tan"},
HlslImportData{"tanh", "tanh"},
HlslImportData{"trunc", "trunc"}));
using HlslImportData_DualParamTest = TestParamHelper<HlslImportData>;
TEST_P(HlslImportData_DualParamTest, FloatScalar) {
auto param = GetParam();

49
src/writer/hlsl/generator_impl_intrinsic_test.cc
View File

@ -94,12 +94,10 @@ ast::CallExpression* GenerateCall(IntrinsicType intrinsic,
case IntrinsicType::kIsInf:
case IntrinsicType::kIsNan:
case IntrinsicType::kIsNormal:
case IntrinsicType::kLdexp:
case IntrinsicType::kLength:
case IntrinsicType::kLog:
case IntrinsicType::kLog2:
case IntrinsicType::kNormalize:
case IntrinsicType::kReflect:
case IntrinsicType::kRound:
case IntrinsicType::kSin:
case IntrinsicType::kSinh:
@ -108,48 +106,52 @@ ast::CallExpression* GenerateCall(IntrinsicType intrinsic,
case IntrinsicType::kTanh:
case IntrinsicType::kTrunc:
case IntrinsicType::kSign:
return builder->Call(str.str(), "f1");
return builder->Call(str.str(), "f2");
case IntrinsicType::kLdexp:
return builder->Call(str.str(), "f2", "u2");
case IntrinsicType::kAtan2:
case IntrinsicType::kCross:
case IntrinsicType::kDot:
case IntrinsicType::kDistance:
case IntrinsicType::kPow:
case IntrinsicType::kReflect:
case IntrinsicType::kStep:
return builder->Call(str.str(), "f1", "f2");
return builder->Call(str.str(), "f2", "f2");
case IntrinsicType::kCross:
return builder->Call(str.str(), "f3", "f3");
case IntrinsicType::kFma:
case IntrinsicType::kMix:
case IntrinsicType::kFaceForward:
case IntrinsicType::kSmoothStep:
return builder->Call(str.str(), "f1", "f2", "f3");
return builder->Call(str.str(), "f2", "f2", "f2");
case IntrinsicType::kAll:
case IntrinsicType::kAny:
return builder->Call(str.str(), "b1");
return builder->Call(str.str(), "b2");
case IntrinsicType::kAbs:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1");
return builder->Call(str.str(), "f2");
} else {
return builder->Call(str.str(), "u1");
return builder->Call(str.str(), "u2");
}
case IntrinsicType::kCountOneBits:
case IntrinsicType::kReverseBits:
return builder->Call(str.str(), "u1");
return builder->Call(str.str(), "u2");
case IntrinsicType::kMax:
case IntrinsicType::kMin:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1", "f2");
return builder->Call(str.str(), "f2", "f2");
} else {
return builder->Call(str.str(), "u1", "u2");
return builder->Call(str.str(), "u2", "u2");
}
case IntrinsicType::kClamp:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1", "f2", "f3");
return builder->Call(str.str(), "f2", "f2", "f2");
} else {
return builder->Call(str.str(), "u1", "u2", "u3");
return builder->Call(str.str(), "u2", "u2", "u2");
}
case IntrinsicType::kSelect:
return builder->Call(str.str(), "f1", "f2", "b1");
return builder->Call(str.str(), "f2", "f2", "b2");
case IntrinsicType::kDeterminant:
return builder->Call(str.str(), "m1");
return builder->Call(str.str(), "m2x2");
default:
break;
}
@ -163,14 +165,11 @@ TEST_P(HlslIntrinsicTest, Emit) {
ASSERT_NE(nullptr, call) << "Unhandled intrinsic";
WrapInFunction(call);
Global("f1", ast::StorageClass::kFunction, ty.vec2<float>());
Global("f2", ast::StorageClass::kFunction, ty.vec2<float>());
Global("f3", ast::StorageClass::kFunction, ty.vec2<float>());
Global("u1", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("f3", ast::StorageClass::kFunction, ty.vec3<float>());
Global("u2", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("u3", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("b1", ast::StorageClass::kFunction, ty.vec2<bool>());
Global("m1", ast::StorageClass::kFunction, ty.mat2x2<float>());
Global("b2", ast::StorageClass::kFunction, ty.vec2<bool>());
Global("m2x2", ast::StorageClass::kFunction, ty.mat2x2<float>());
GeneratorImpl& gen = Build();
@ -305,7 +304,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Pack4x8Unorm) {
TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Snorm) {
auto* call = Call("pack2x16snorm", "p1");
Global("p1", ast::StorageClass::kPrivate, ty.vec4<f32>());
Global("p1", ast::StorageClass::kPrivate, ty.vec2<f32>());
WrapInFunction(call);
GeneratorImpl& gen = Build();
@ -318,7 +317,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Snorm) {
TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Unorm) {
auto* call = Call("pack2x16unorm", "p1");
Global("p1", ast::StorageClass::kPrivate, ty.vec4<f32>());
Global("p1", ast::StorageClass::kPrivate, ty.vec2<f32>());
WrapInFunction(call);
GeneratorImpl& gen = Build();
@ -331,7 +330,7 @@ TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16Unorm) {
TEST_F(HlslGeneratorImplTest_Intrinsic, Pack2x16float) {
auto* call = Call("pack2x16float", "p1");
Global("p1", ast::StorageClass::kPrivate, ty.vec4<f32>());
Global("p1", ast::StorageClass::kPrivate, ty.vec2<f32>());
WrapInFunction(call);
GeneratorImpl& gen = Build();

50
src/writer/msl/generator_impl_intrinsic_test.cc
View File

@ -93,14 +93,10 @@ ast::CallExpression* GenerateCall(IntrinsicType intrinsic,
case IntrinsicType::kIsInf:
case IntrinsicType::kIsNan:
case IntrinsicType::kIsNormal:
case IntrinsicType::kLdexp:
case IntrinsicType::kLength:
case IntrinsicType::kLog:
case IntrinsicType::kLog2:
case IntrinsicType::kNormalize:
case IntrinsicType::kPack4x8Snorm:
case IntrinsicType::kPack4x8Unorm:
case IntrinsicType::kReflect:
case IntrinsicType::kRound:
case IntrinsicType::kSin:
case IntrinsicType::kSinh:
@ -109,50 +105,57 @@ ast::CallExpression* GenerateCall(IntrinsicType intrinsic,
case IntrinsicType::kTanh:
case IntrinsicType::kTrunc:
case IntrinsicType::kSign:
return builder->Call(str.str(), "f1");
return builder->Call(str.str(), "f2");
case IntrinsicType::kLdexp:
return builder->Call(str.str(), "f2", "u2");
case IntrinsicType::kAtan2:
case IntrinsicType::kCross:
case IntrinsicType::kDot:
case IntrinsicType::kDistance:
case IntrinsicType::kPow:
case IntrinsicType::kReflect:
case IntrinsicType::kStep:
return builder->Call(str.str(), "f1", "f2");
return builder->Call(str.str(), "f2", "f2");
case IntrinsicType::kCross:
return builder->Call(str.str(), "f3", "f3");
case IntrinsicType::kFma:
case IntrinsicType::kMix:
case IntrinsicType::kFaceForward:
case IntrinsicType::kSmoothStep:
return builder->Call(str.str(), "f1", "f2", "f3");
return builder->Call(str.str(), "f2", "f2", "f2");
case IntrinsicType::kAll:
case IntrinsicType::kAny:
return builder->Call(str.str(), "b1");
return builder->Call(str.str(), "b2");
case IntrinsicType::kAbs:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1");
return builder->Call(str.str(), "f2");
} else {
return builder->Call(str.str(), "u1");
return builder->Call(str.str(), "u2");
}
case IntrinsicType::kCountOneBits:
case IntrinsicType::kReverseBits:
return builder->Call(str.str(), "u1");
return builder->Call(str.str(), "u2");
case IntrinsicType::kMax:
case IntrinsicType::kMin:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1", "f2");
return builder->Call(str.str(), "f2", "f2");
} else {
return builder->Call(str.str(), "u1", "u2");
return builder->Call(str.str(), "u2", "u2");
}
case IntrinsicType::kClamp:
if (type == ParamType::kF32) {
return builder->Call(str.str(), "f1", "f2", "f3");
return builder->Call(str.str(), "f2", "f2", "f2");
} else {
return builder->Call(str.str(), "u1", "u2", "u3");
return builder->Call(str.str(), "u2", "u2", "u2");
}
case IntrinsicType::kSelect:
return builder->Call(str.str(), "f1", "f2", "b1");
return builder->Call(str.str(), "f2", "f2", "b2");
case IntrinsicType::kDeterminant:
return builder->Call(str.str(), "m1");
return builder->Call(str.str(), "m2x2");
case IntrinsicType::kPack2x16Snorm:
case IntrinsicType::kPack2x16Unorm:
return builder->Call(str.str(), "f2");
case IntrinsicType::kPack4x8Snorm:
case IntrinsicType::kPack4x8Unorm:
return builder->Call(str.str(), "f4");
default:
break;
@ -168,15 +171,12 @@ TEST_P(MslIntrinsicTest, Emit) {
ASSERT_NE(nullptr, call) << "Unhandled intrinsic";
WrapInFunction(call);
Global("f1", ast::StorageClass::kFunction, ty.vec2<float>());
Global("f2", ast::StorageClass::kFunction, ty.vec2<float>());
Global("f3", ast::StorageClass::kFunction, ty.vec2<float>());
Global("f4", ast::StorageClass::kFunction, ty.vec2<float>());
Global("u1", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("f3", ast::StorageClass::kFunction, ty.vec3<float>());
Global("f4", ast::StorageClass::kFunction, ty.vec4<float>());
Global("u2", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("u3", ast::StorageClass::kFunction, ty.vec2<unsigned int>());
Global("b1", ast::StorageClass::kFunction, ty.vec2<bool>());
Global("m1", ast::StorageClass::kFunction, ty.mat2x2<float>());
Global("b2", ast::StorageClass::kFunction, ty.vec2<bool>());
Global("m2x2", ast::StorageClass::kFunction, ty.mat2x2<float>());
GeneratorImpl& gen = Build();