encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

tint: const eval of reflect builtin 

Bug: tint:1581
Change-Id: Ife4409ca897a5754fe6b76c650d26fd66ef5880f
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/111901
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Antonio Maiorano <amaiorano@google.com>
This commit is contained in:
Antonio Maiorano 2022-11-28 15:13:16 +00:00 committed by Dawn LUCI CQ
parent 6239f58064
commit ee7d6db047
75 changed files with 1937 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/tint/intrinsics.def
View File

@ -518,7 +518,7 @@ fn pow<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
@const fn quantizeToF16<N: num>(vec<N, f32>) -> vec<N, f32>
@const fn radians<T: fa_f32_f16>(T) -> T
@const fn radians<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
fn reflect<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
@const fn reflect<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
fn refract<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
@const fn reverseBits<T: iu32>(T) -> T
@const fn reverseBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T>

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

@ -1189,6 +1189,26 @@ ConstEval::Result ConstEval::Length(const Source& source,
return Dispatch_fa_f32_f16(SqrtFunc(source, ty), d.Get());
}
ConstEval::Result ConstEval::Mul(const Source& source,
const sem::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
return Dispatch_fia_fiu32_f16(MulFunc(source, c0->Type()), c0, c1);
};
return TransformBinaryElements(builder, ty, transform, v1, v2);
}
ConstEval::Result ConstEval::Sub(const Source& source,
const sem::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
return Dispatch_fia_fiu32_f16(SubFunc(source, c0->Type()), c0, c1);
};
return TransformBinaryElements(builder, ty, transform, v1, v2);
}
auto ConstEval::Det2Func(const Source& source, const sem::Type* elem_ty) {
return [=](auto a, auto b, auto c, auto d) -> ImplResult {
if (auto r = Det2(source, a, b, c, d)) {
@ -1481,21 +1501,13 @@ ConstEval::Result ConstEval::OpPlus(const sem::Type* ty,
ConstEval::Result ConstEval::OpMinus(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
return Dispatch_fia_fiu32_f16(SubFunc(source, c0->Type()), c0, c1);
};
return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
return Sub(source, ty, args[0], args[1]);
}
ConstEval::Result ConstEval::OpMultiply(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto transform = [&](const sem::Constant* c0, const sem::Constant* c1) {
return Dispatch_fia_fiu32_f16(MulFunc(source, c0->Type()), c0, c1);
};
return TransformBinaryElements(builder, ty, transform, args[0], args[1]);
return Mul(source, ty, args[0], args[1]);
}
ConstEval::Result ConstEval::OpMultiplyMatVec(const sem::Type* ty,
@ -2213,7 +2225,7 @@ ConstEval::Result ConstEval::degrees(const sem::Type* ty,
ConstEval::Result ConstEval::determinant(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto calculate = [&]() -> ImplResult {
auto calculate = [&]() -> ConstEval::Result {
auto* m = args[0];
auto* mat_ty = m->Type()->As<sem::Matrix>();
auto me = [&](size_t r, size_t c) { return m->Index(c)->Index(r); };
@ -2899,6 +2911,49 @@ ConstEval::Result ConstEval::radians(const sem::Type* ty,
return TransformElements(builder, ty, transform, args[0]);
}
ConstEval::Result ConstEval::reflect(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {
auto calculate = [&]() -> ConstEval::Result {
// For the incident vector e1 and surface orientation e2, returns the reflection direction
// e1 - 2 * dot(e2, e1) * e2.
auto* e1 = args[0];
auto* e2 = args[1];
auto* vec_ty = ty->As<sem::Vector>();
auto* el_ty = vec_ty->type();
// dot(e2, e1)
auto dot_e2_e1 = Dot(source, e2, e1);
if (!dot_e2_e1) {
return utils::Failure;
}
// 2 * dot(e2, e1)
auto mul2 = [&](auto v) -> ImplResult {
using NumberT = decltype(v);
return CreateElement(builder, source, el_ty, NumberT{NumberT{2} * v});
};
auto dot_e2_e1_2 = Dispatch_fa_f32_f16(mul2, dot_e2_e1.Get());
if (!dot_e2_e1_2) {
return utils::Failure;
}
// 2 * dot(e2, e1) * e2
auto dot_e2_e1_2_e2 = Mul(source, ty, dot_e2_e1_2.Get(), e2);
if (!dot_e2_e1_2_e2) {
return utils::Failure;
}
// e1 - 2 * dot(e2, e1) * e2
return Sub(source, ty, e1, dot_e2_e1_2_e2.Get());
};
auto r = calculate();
if (!r) {
AddNote("when calculating reflect", source);
}
return r;
}
ConstEval::Result ConstEval::reverseBits(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source) {

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

@ -791,6 +791,15 @@ class ConstEval {
utils::VectorRef<const sem::Constant*> args,
const Source& source);
/// reflect builtin
/// @param ty the expression type
/// @param args the input arguments
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result reflect(const sem::Type* ty,
utils::VectorRef<const sem::Constant*> args,
const Source& source);
/// reverseBits builtin
/// @param ty the expression type
/// @param args the input arguments
@ -1261,13 +1270,35 @@ class ConstEval {
/// @returns the dot product
Result Dot(const Source& source, const sem::Constant* v1, const sem::Constant* v2);
/// Return sthe length of c0
/// Returns the length of c0
/// @param source the source location
/// @param ty the return type
/// @param c0 the constant to calculate the length of
/// @returns the length of c0
Result Length(const Source& source, const sem::Type* ty, const sem::Constant* c0);
/// Returns the product of v1 and v2
/// @param source the source location
/// @param ty the return type
/// @param v1 lhs value
/// @param v2 rhs value
/// @returns the product of v1 and v2
Result Mul(const Source& source,
const sem::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2);
/// Returns the difference between v2 and v1
/// @param source the source location
/// @param ty the return type
/// @param v1 lhs value
/// @param v2 rhs value
/// @returns the difference between v2 and v1
Result Sub(const Source& source,
const sem::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2);
ProgramBuilder& builder;
};

55
src/tint/resolver/const_eval_builtin_test.cc
View File

@ -1934,6 +1934,61 @@ INSTANTIATE_TEST_SUITE_P( //
testing::ValuesIn(Concat(ReverseBitsCases<i32>(), //
ReverseBitsCases<u32>()))));
template <typename T>
std::vector<Case> ReflectCases() {
auto pos_y = Vec(T(0), T(1), T(0));
auto neg_y = Vec(T(0), -T(1), T(0));
auto pos_large_y = Vec(T(0), T(10000), T(0));
auto neg_large_y = Vec(T(0), -T(10000), T(0));
auto cos_45 = T(0.70710678118654752440084436210485);
auto pos_xyz = Vec(cos_45, cos_45, cos_45);
auto r = std::vector<Case>{
C({Vec(T(1), -T(1), T(0)), pos_y}, Vec(T(1), T(1), T(0))),
C({Vec(T(24), -T(42), T(0)), pos_y}, Vec(T(24), T(42), T(0))),
// Flipping reflection vector doesn't change the result
C({Vec(T(1), -T(1), T(0)), neg_y}, Vec(T(1), T(1), T(0))),
C({Vec(T(24), -T(42), T(0)), neg_y}, Vec(T(24), T(42), T(0))),
// Parallel input and reflection vectors: result is negation of input
C({pos_y, pos_y}, neg_y),
C({neg_y, pos_y}, pos_y),
C({pos_large_y, pos_y}, neg_large_y),
C({neg_large_y, pos_y}, pos_large_y),
// Input axis vectors reflected by normalized(vec(1,1,1)) vector.
C({Vec(T(1), T(0), T(0)), pos_xyz}, Vec(T(0), -T(1), -T(1))).FloatComp(0.02),
C({Vec(T(0), T(1), T(0)), pos_xyz}, Vec(-T(1), T(0), -T(1))).FloatComp(0.02),
C({Vec(T(0), T(0), T(1)), pos_xyz}, Vec(-T(1), -T(1), T(0))).FloatComp(0.02),
C({Vec(-T(1), T(0), T(0)), pos_xyz}, Vec(T(0), T(1), T(1))).FloatComp(0.02),
C({Vec(T(0), -T(1), T(0)), pos_xyz}, Vec(T(1), T(0), T(1))).FloatComp(0.02),
C({Vec(T(0), T(0), -T(1)), pos_xyz}, Vec(T(1), T(1), T(0))).FloatComp(0.02),
};
auto error_msg = [](auto a, const char* op, auto b) {
return "12:34 error: " + OverflowErrorMessage(a, op, b) + R"(
12:34 note: when calculating reflect)";
};
ConcatInto( //
r, std::vector<Case>{
// Overflow the dot product operation
E({Vec(T::Highest(), T::Highest(), T(0)), Vec(T(1), T(1), T(0))},
error_msg(T::Highest(), "+", T::Highest())),
E({Vec(T::Lowest(), T::Lowest(), T(0)), Vec(T(1), T(1), T(0))},
error_msg(T::Lowest(), "+", T::Lowest())),
});
return r;
}
INSTANTIATE_TEST_SUITE_P( //
Reflect,
ResolverConstEvalBuiltinTest,
testing::Combine(testing::Values(sem::BuiltinType::kReflect),
testing::ValuesIn(
// ReflectCases<f32>())));
Concat(ReflectCases<AFloat>(), //
ReflectCases<f32>(), //
ReflectCases<f16>()))));
template <typename T>
std::vector<Case> RadiansCases() {
return std::vector<Case>{

20
src/tint/resolver/const_eval_test.h
View File

@ -105,34 +105,34 @@ inline void CheckConstant(const sem::Constant* got_constant,
auto got = std::get<T>(got_scalar);
if constexpr (std::is_same_v<bool, T>) {
EXPECT_EQ(got, expected);
EXPECT_EQ(got, expected) << "index: " << i;
} else if constexpr (IsFloatingPoint<T>) {
if (std::isnan(expected)) {
EXPECT_TRUE(std::isnan(got));
EXPECT_TRUE(std::isnan(got)) << "index: " << i;
} else {
if (flags.pos_or_neg) {
got = Abs(got);
}
if (flags.float_compare) {
if (flags.float_compare_epsilon) {
EXPECT_NEAR(got, expected, *flags.float_compare_epsilon);
EXPECT_NEAR(got, expected, *flags.float_compare_epsilon)
<< "index: " << i;
} else {
EXPECT_FLOAT_EQ(got, expected);
EXPECT_FLOAT_EQ(got, expected) << "index: " << i;
}
} else {
EXPECT_EQ(got, expected);
EXPECT_EQ(got, expected) << "index: " << i;
}
}
} else {
if (flags.pos_or_neg) {
auto got_abs = Abs(got);
EXPECT_EQ(got_abs, expected);
} else {
EXPECT_EQ(got, expected);
got = Abs(got);
}
EXPECT_EQ(got, expected) << "index: " << i;
// 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(AInt(got), AInt(expected));
EXPECT_EQ(AInt(got), AInt(expected)) << "index: " << i;
}
},
expected_scalar);

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

@ -13698,12 +13698,12 @@ constexpr OverloadInfo kOverloads[] = {
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[26],
/* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[4],
/* parameters */ &kParameters[626],
/* return matcher indices */ &kMatcherIndices[30],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
/* const eval */ &ConstEval::reflect,
},
{
/* [449] */
@ -14415,7 +14415,7 @@ constexpr IntrinsicInfo kBuiltins[] = {
},
{
/* [63] */
/* fn reflect<N : num, T : f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* fn reflect<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 1,
/* overloads */ &kOverloads[448],
},

2
test/tint/builtins/gen/literal/reflect/05357e.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_05357e() {
float4 res = reflect((1.0f).xxxx, (1.0f).xxxx);
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {

2
test/tint/builtins/gen/literal/reflect/05357e.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_05357e() {
float4 res = reflect((1.0f).xxxx, (1.0f).xxxx);
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/05357e.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es
void reflect_05357e() {
vec4 res = reflect(vec4(1.0f), vec4(1.0f));
vec4 res = vec4(-7.0f);
}
vec4 vertex_main() {
@ -21,7 +21,7 @@ void main() {
precision mediump float;
void reflect_05357e() {
vec4 res = reflect(vec4(1.0f), vec4(1.0f));
vec4 res = vec4(-7.0f);
}
void fragment_main() {
@ -35,7 +35,7 @@ void main() {
#version 310 es
void reflect_05357e() {
vec4 res = reflect(vec4(1.0f), vec4(1.0f));
vec4 res = vec4(-7.0f);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/05357e.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_05357e() {
float4 res = reflect(float4(1.0f), float4(1.0f));
float4 res = float4(-7.0f);
}
struct tint_symbol {

33
test/tint/builtins/gen/literal/reflect/05357e.wgsl.expected.spvasm
View File

@ -1,10 +1,9 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 32
; Bound: 31
; Schema: 0
OpCapability Shader
%14 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -31,36 +30,36 @@
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%float_1 = OpConstant %float 1
%16 = OpConstantComposite %v4float %float_1 %float_1 %float_1 %float_1
%float_n7 = OpConstant %float -7
%14 = OpConstantComposite %v4float %float_n7 %float_n7 %float_n7 %float_n7
%_ptr_Function_v4float = OpTypePointer Function %v4float
%19 = OpTypeFunction %v4float
%17 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_05357e = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v4float Function %5
%13 = OpExtInst %v4float %14 Reflect %16 %16
OpStore %res %13
OpStore %res %14
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_05357e
%vertex_main_inner = OpFunction %v4float None %17
%19 = OpLabel
%20 = OpFunctionCall %void %reflect_05357e
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
%22 = OpLabel
%23 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %23
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%27 = OpLabel
%28 = OpFunctionCall %void %reflect_05357e
%26 = OpLabel
%27 = OpFunctionCall %void %reflect_05357e
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%30 = OpLabel
%31 = OpFunctionCall %void %reflect_05357e
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_05357e
OpReturn
OpFunctionEnd

2
test/tint/builtins/gen/literal/reflect/310de5.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_310de5() {
vector<float16_t, 4> res = reflect((float16_t(1.0h)).xxxx, (float16_t(1.0h)).xxxx);
vector<float16_t, 4> res = (float16_t(-7.0h)).xxxx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/310de5.wgsl.expected.glsl
View File

@ -2,7 +2,7 @@
#extension GL_AMD_gpu_shader_half_float : require
void reflect_310de5() {
f16vec4 res = reflect(f16vec4(1.0hf), f16vec4(1.0hf));
f16vec4 res = f16vec4(-7.0hf);
}
vec4 vertex_main() {
@ -23,7 +23,7 @@ void main() {
precision mediump float;
void reflect_310de5() {
f16vec4 res = reflect(f16vec4(1.0hf), f16vec4(1.0hf));
f16vec4 res = f16vec4(-7.0hf);
}
void fragment_main() {
@ -38,7 +38,7 @@ void main() {
#extension GL_AMD_gpu_shader_half_float : require
void reflect_310de5() {
f16vec4 res = reflect(f16vec4(1.0hf), f16vec4(1.0hf));
f16vec4 res = f16vec4(-7.0hf);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/310de5.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_310de5() {
half4 res = reflect(half4(1.0h), half4(1.0h));
half4 res = half4(-7.0h);
}
struct tint_symbol {

36
test/tint/builtins/gen/literal/reflect/310de5.wgsl.expected.spvasm
View File

@ -1,14 +1,13 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 36
; Bound: 34
; Schema: 0
OpCapability Shader
OpCapability Float16
OpCapability UniformAndStorageBuffer16BitAccess
OpCapability StorageBuffer16BitAccess
OpCapability StorageInputOutput16
%16 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -37,38 +36,37 @@
%9 = OpTypeFunction %void
%half = OpTypeFloat 16
%v4half = OpTypeVector %half 4
%half_0x1p_0 = OpConstant %half 0x1p+0
%18 = OpConstantComposite %v4half %half_0x1p_0 %half_0x1p_0 %half_0x1p_0 %half_0x1p_0
%half_n0x1_cp_2 = OpConstant %half -0x1.cp+2
%16 = OpConstantComposite %v4half %half_n0x1_cp_2 %half_n0x1_cp_2 %half_n0x1_cp_2 %half_n0x1_cp_2
%_ptr_Function_v4half = OpTypePointer Function %v4half
%21 = OpConstantNull %v4half
%22 = OpTypeFunction %v4float
%19 = OpConstantNull %v4half
%20 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_310de5 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v4half Function %21
%13 = OpExtInst %v4half %16 Reflect %18 %18
OpStore %res %13
%res = OpVariable %_ptr_Function_v4half Function %19
OpStore %res %16
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %22
%24 = OpLabel
%25 = OpFunctionCall %void %reflect_310de5
%vertex_main_inner = OpFunction %v4float None %20
%22 = OpLabel
%23 = OpFunctionCall %void %reflect_310de5
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%27 = OpLabel
%28 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %28
%25 = OpLabel
%26 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %26
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_310de5
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_310de5
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%34 = OpLabel
%35 = OpFunctionCall %void %reflect_310de5
%32 = OpLabel
%33 = OpFunctionCall %void %reflect_310de5
OpReturn
OpFunctionEnd

2
test/tint/builtins/gen/literal/reflect/61ca21.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_61ca21() {
vector<float16_t, 3> res = reflect((float16_t(1.0h)).xxx, (float16_t(1.0h)).xxx);
vector<float16_t, 3> res = (float16_t(-5.0h)).xxx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/61ca21.wgsl.expected.glsl
View File

@ -2,7 +2,7 @@
#extension GL_AMD_gpu_shader_half_float : require
void reflect_61ca21() {
f16vec3 res = reflect(f16vec3(1.0hf), f16vec3(1.0hf));
f16vec3 res = f16vec3(-5.0hf);
}
vec4 vertex_main() {
@ -23,7 +23,7 @@ void main() {
precision mediump float;
void reflect_61ca21() {
f16vec3 res = reflect(f16vec3(1.0hf), f16vec3(1.0hf));
f16vec3 res = f16vec3(-5.0hf);
}
void fragment_main() {
@ -38,7 +38,7 @@ void main() {
#extension GL_AMD_gpu_shader_half_float : require
void reflect_61ca21() {
f16vec3 res = reflect(f16vec3(1.0hf), f16vec3(1.0hf));
f16vec3 res = f16vec3(-5.0hf);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/61ca21.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_61ca21() {
half3 res = reflect(half3(1.0h), half3(1.0h));
half3 res = half3(-5.0h);
}
struct tint_symbol {

36
test/tint/builtins/gen/literal/reflect/61ca21.wgsl.expected.spvasm
View File

@ -1,14 +1,13 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 36
; Bound: 34
; Schema: 0
OpCapability Shader
OpCapability Float16
OpCapability UniformAndStorageBuffer16BitAccess
OpCapability StorageBuffer16BitAccess
OpCapability StorageInputOutput16
%16 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -37,38 +36,37 @@
%9 = OpTypeFunction %void
%half = OpTypeFloat 16
%v3half = OpTypeVector %half 3
%half_0x1p_0 = OpConstant %half 0x1p+0
%18 = OpConstantComposite %v3half %half_0x1p_0 %half_0x1p_0 %half_0x1p_0
%half_n0x1_4p_2 = OpConstant %half -0x1.4p+2
%16 = OpConstantComposite %v3half %half_n0x1_4p_2 %half_n0x1_4p_2 %half_n0x1_4p_2
%_ptr_Function_v3half = OpTypePointer Function %v3half
%21 = OpConstantNull %v3half
%22 = OpTypeFunction %v4float
%19 = OpConstantNull %v3half
%20 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_61ca21 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v3half Function %21
%13 = OpExtInst %v3half %16 Reflect %18 %18
OpStore %res %13
%res = OpVariable %_ptr_Function_v3half Function %19
OpStore %res %16
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %22
%24 = OpLabel
%25 = OpFunctionCall %void %reflect_61ca21
%vertex_main_inner = OpFunction %v4float None %20
%22 = OpLabel
%23 = OpFunctionCall %void %reflect_61ca21
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%27 = OpLabel
%28 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %28
%25 = OpLabel
%26 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %26
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_61ca21
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_61ca21
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%34 = OpLabel
%35 = OpFunctionCall %void %reflect_61ca21
%32 = OpLabel
%33 = OpFunctionCall %void %reflect_61ca21
OpReturn
OpFunctionEnd

43
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl Normal file
View File

@ -0,0 +1,43 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<3, fa>, vec<3, fa>) -> vec<3, fa>
fn reflect_a8baf2() {
var res = reflect(vec3(1.), vec3(1.));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_a8baf2();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_a8baf2();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_a8baf2();
}

30
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_a8baf2() {
float3 res = (-5.0f).xxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_a8baf2();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_a8baf2();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_a8baf2();
return;
}

30
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_a8baf2() {
float3 res = (-5.0f).xxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_a8baf2();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_a8baf2();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_a8baf2();
return;
}

49
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
vec4 vertex_main() {
reflect_a8baf2();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
void fragment_main() {
reflect_a8baf2();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
void compute_main() {
reflect_a8baf2();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_a8baf2() {
float3 res = float3(-5.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_a8baf2();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_a8baf2();
return;
}
kernel void compute_main() {
reflect_a8baf2();
return;
}

67
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,67 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 33
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_a8baf2 "reflect_a8baf2"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v3float = OpTypeVector %float 3
%float_n5 = OpConstant %float -5
%15 = OpConstantComposite %v3float %float_n5 %float_n5 %float_n5
%_ptr_Function_v3float = OpTypePointer Function %v3float
%18 = OpConstantNull %v3float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_a8baf2 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v3float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_a8baf2
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_a8baf2
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_a8baf2
OpReturn
OpFunctionEnd

19
test/tint/builtins/gen/literal/reflect/a8baf2.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,19 @@
fn reflect_a8baf2() {
var res = reflect(vec3(1.0), vec3(1.0));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_a8baf2();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_a8baf2();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_a8baf2();
}

2
test/tint/builtins/gen/literal/reflect/b61e10.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_b61e10() {
float2 res = reflect((1.0f).xx, (1.0f).xx);
float2 res = (-3.0f).xx;
}
struct tint_symbol {

2
test/tint/builtins/gen/literal/reflect/b61e10.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_b61e10() {
float2 res = reflect((1.0f).xx, (1.0f).xx);
float2 res = (-3.0f).xx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/b61e10.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es
void reflect_b61e10() {
vec2 res = reflect(vec2(1.0f), vec2(1.0f));
vec2 res = vec2(-3.0f);
}
vec4 vertex_main() {
@ -21,7 +21,7 @@ void main() {
precision mediump float;
void reflect_b61e10() {
vec2 res = reflect(vec2(1.0f), vec2(1.0f));
vec2 res = vec2(-3.0f);
}
void fragment_main() {
@ -35,7 +35,7 @@ void main() {
#version 310 es
void reflect_b61e10() {
vec2 res = reflect(vec2(1.0f), vec2(1.0f));
vec2 res = vec2(-3.0f);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/b61e10.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_b61e10() {
float2 res = reflect(float2(1.0f), float2(1.0f));
float2 res = float2(-3.0f);
}
struct tint_symbol {

37
test/tint/builtins/gen/literal/reflect/b61e10.wgsl.expected.spvasm
View File

@ -1,10 +1,9 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 34
; Bound: 33
; Schema: 0
OpCapability Shader
%15 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -32,37 +31,37 @@
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v2float = OpTypeVector %float 2
%float_1 = OpConstant %float 1
%17 = OpConstantComposite %v2float %float_1 %float_1
%float_n3 = OpConstant %float -3
%15 = OpConstantComposite %v2float %float_n3 %float_n3
%_ptr_Function_v2float = OpTypePointer Function %v2float
%20 = OpConstantNull %v2float
%21 = OpTypeFunction %v4float
%18 = OpConstantNull %v2float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_b61e10 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v2float Function %20
%13 = OpExtInst %v2float %15 Reflect %17 %17
OpStore %res %13
%res = OpVariable %_ptr_Function_v2float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %21
%23 = OpLabel
%24 = OpFunctionCall %void %reflect_b61e10
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_b61e10
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%26 = OpLabel
%27 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %27
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_b61e10
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_b61e10
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%32 = OpLabel
%33 = OpFunctionCall %void %reflect_b61e10
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_b61e10
OpReturn
OpFunctionEnd

2
test/tint/builtins/gen/literal/reflect/bb15ac.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_bb15ac() {
vector<float16_t, 2> res = reflect((float16_t(1.0h)).xx, (float16_t(1.0h)).xx);
vector<float16_t, 2> res = (float16_t(-3.0h)).xx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/bb15ac.wgsl.expected.glsl
View File

@ -2,7 +2,7 @@
#extension GL_AMD_gpu_shader_half_float : require
void reflect_bb15ac() {
f16vec2 res = reflect(f16vec2(1.0hf), f16vec2(1.0hf));
f16vec2 res = f16vec2(-3.0hf);
}
vec4 vertex_main() {
@ -23,7 +23,7 @@ void main() {
precision mediump float;
void reflect_bb15ac() {
f16vec2 res = reflect(f16vec2(1.0hf), f16vec2(1.0hf));
f16vec2 res = f16vec2(-3.0hf);
}
void fragment_main() {
@ -38,7 +38,7 @@ void main() {
#extension GL_AMD_gpu_shader_half_float : require
void reflect_bb15ac() {
f16vec2 res = reflect(f16vec2(1.0hf), f16vec2(1.0hf));
f16vec2 res = f16vec2(-3.0hf);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/bb15ac.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_bb15ac() {
half2 res = reflect(half2(1.0h), half2(1.0h));
half2 res = half2(-3.0h);
}
struct tint_symbol {

36
test/tint/builtins/gen/literal/reflect/bb15ac.wgsl.expected.spvasm
View File

@ -1,14 +1,13 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 36
; Bound: 34
; Schema: 0
OpCapability Shader
OpCapability Float16
OpCapability UniformAndStorageBuffer16BitAccess
OpCapability StorageBuffer16BitAccess
OpCapability StorageInputOutput16
%16 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -37,38 +36,37 @@
%9 = OpTypeFunction %void
%half = OpTypeFloat 16
%v2half = OpTypeVector %half 2
%half_0x1p_0 = OpConstant %half 0x1p+0
%18 = OpConstantComposite %v2half %half_0x1p_0 %half_0x1p_0
%half_n0x1_8p_1 = OpConstant %half -0x1.8p+1
%16 = OpConstantComposite %v2half %half_n0x1_8p_1 %half_n0x1_8p_1
%_ptr_Function_v2half = OpTypePointer Function %v2half
%21 = OpConstantNull %v2half
%22 = OpTypeFunction %v4float
%19 = OpConstantNull %v2half
%20 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_bb15ac = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v2half Function %21
%13 = OpExtInst %v2half %16 Reflect %18 %18
OpStore %res %13
%res = OpVariable %_ptr_Function_v2half Function %19
OpStore %res %16
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %22
%24 = OpLabel
%25 = OpFunctionCall %void %reflect_bb15ac
%vertex_main_inner = OpFunction %v4float None %20
%22 = OpLabel
%23 = OpFunctionCall %void %reflect_bb15ac
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%27 = OpLabel
%28 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %28
%25 = OpLabel
%26 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %26
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_bb15ac
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_bb15ac
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%34 = OpLabel
%35 = OpFunctionCall %void %reflect_bb15ac
%32 = OpLabel
%33 = OpFunctionCall %void %reflect_bb15ac
OpReturn
OpFunctionEnd

43
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl Normal file
View File

@ -0,0 +1,43 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<2, fa>, vec<2, fa>) -> vec<2, fa>
fn reflect_bba2d0() {
var res = reflect(vec2(1.), vec2(1.));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_bba2d0();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_bba2d0();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_bba2d0();
}

30
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_bba2d0() {
float2 res = (-3.0f).xx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_bba2d0();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_bba2d0();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_bba2d0();
return;
}

30
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_bba2d0() {
float2 res = (-3.0f).xx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_bba2d0();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_bba2d0();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_bba2d0();
return;
}

49
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
vec4 vertex_main() {
reflect_bba2d0();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
void fragment_main() {
reflect_bba2d0();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
void compute_main() {
reflect_bba2d0();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_bba2d0() {
float2 res = float2(-3.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_bba2d0();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_bba2d0();
return;
}
kernel void compute_main() {
reflect_bba2d0();
return;
}

67
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,67 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 33
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_bba2d0 "reflect_bba2d0"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v2float = OpTypeVector %float 2
%float_n3 = OpConstant %float -3
%15 = OpConstantComposite %v2float %float_n3 %float_n3
%_ptr_Function_v2float = OpTypePointer Function %v2float
%18 = OpConstantNull %v2float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_bba2d0 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v2float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_bba2d0
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_bba2d0
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_bba2d0
OpReturn
OpFunctionEnd

19
test/tint/builtins/gen/literal/reflect/bba2d0.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,19 @@
fn reflect_bba2d0() {
var res = reflect(vec2(1.0), vec2(1.0));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_bba2d0();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_bba2d0();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_bba2d0();
}

43
test/tint/builtins/gen/literal/reflect/d7e210.wgsl Normal file
View File

@ -0,0 +1,43 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<4, fa>, vec<4, fa>) -> vec<4, fa>
fn reflect_d7e210() {
var res = reflect(vec4(1.), vec4(1.));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_d7e210();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_d7e210();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_d7e210();
}

30
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_d7e210() {
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_d7e210();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_d7e210();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_d7e210();
return;
}

30
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_d7e210() {
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_d7e210();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_d7e210();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_d7e210();
return;
}

49
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
vec4 vertex_main() {
reflect_d7e210();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
void fragment_main() {
reflect_d7e210();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
void compute_main() {
reflect_d7e210();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_d7e210() {
float4 res = float4(-7.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_d7e210();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_d7e210();
return;
}
kernel void compute_main() {
reflect_d7e210();
return;
}

65
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,65 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 31
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_d7e210 "reflect_d7e210"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%float_n7 = OpConstant %float -7
%14 = OpConstantComposite %v4float %float_n7 %float_n7 %float_n7 %float_n7
%_ptr_Function_v4float = OpTypePointer Function %v4float
%17 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_d7e210 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v4float Function %5
OpStore %res %14
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %17
%19 = OpLabel
%20 = OpFunctionCall %void %reflect_d7e210
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%22 = OpLabel
%23 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %23
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%26 = OpLabel
%27 = OpFunctionCall %void %reflect_d7e210
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_d7e210
OpReturn
OpFunctionEnd

19
test/tint/builtins/gen/literal/reflect/d7e210.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,19 @@
fn reflect_d7e210() {
var res = reflect(vec4(1.0), vec4(1.0));
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_d7e210();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_d7e210();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_d7e210();
}

2
test/tint/builtins/gen/literal/reflect/f47fdb.wgsl.expected.dxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_f47fdb() {
float3 res = reflect((1.0f).xxx, (1.0f).xxx);
float3 res = (-5.0f).xxx;
}
struct tint_symbol {

2
test/tint/builtins/gen/literal/reflect/f47fdb.wgsl.expected.fxc.hlsl
View File

@ -1,5 +1,5 @@
void reflect_f47fdb() {
float3 res = reflect((1.0f).xxx, (1.0f).xxx);
float3 res = (-5.0f).xxx;
}
struct tint_symbol {

6
test/tint/builtins/gen/literal/reflect/f47fdb.wgsl.expected.glsl
View File

@ -1,7 +1,7 @@
#version 310 es
void reflect_f47fdb() {
vec3 res = reflect(vec3(1.0f), vec3(1.0f));
vec3 res = vec3(-5.0f);
}
vec4 vertex_main() {
@ -21,7 +21,7 @@ void main() {
precision mediump float;
void reflect_f47fdb() {
vec3 res = reflect(vec3(1.0f), vec3(1.0f));
vec3 res = vec3(-5.0f);
}
void fragment_main() {
@ -35,7 +35,7 @@ void main() {
#version 310 es
void reflect_f47fdb() {
vec3 res = reflect(vec3(1.0f), vec3(1.0f));
vec3 res = vec3(-5.0f);
}
void compute_main() {

2
test/tint/builtins/gen/literal/reflect/f47fdb.wgsl.expected.msl
View File

@ -2,7 +2,7 @@
using namespace metal;
void reflect_f47fdb() {
float3 res = reflect(float3(1.0f), float3(1.0f));
float3 res = float3(-5.0f);
}
struct tint_symbol {

37
test/tint/builtins/gen/literal/reflect/f47fdb.wgsl.expected.spvasm
View File

@ -1,10 +1,9 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 34
; Bound: 33
; Schema: 0
OpCapability Shader
%15 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
@ -32,37 +31,37 @@
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v3float = OpTypeVector %float 3
%float_1 = OpConstant %float 1
%17 = OpConstantComposite %v3float %float_1 %float_1 %float_1
%float_n5 = OpConstant %float -5
%15 = OpConstantComposite %v3float %float_n5 %float_n5 %float_n5
%_ptr_Function_v3float = OpTypePointer Function %v3float
%20 = OpConstantNull %v3float
%21 = OpTypeFunction %v4float
%18 = OpConstantNull %v3float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_f47fdb = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v3float Function %20
%13 = OpExtInst %v3float %15 Reflect %17 %17
OpStore %res %13
%res = OpVariable %_ptr_Function_v3float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %21
%23 = OpLabel
%24 = OpFunctionCall %void %reflect_f47fdb
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_f47fdb
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%26 = OpLabel
%27 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %27
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_f47fdb
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_f47fdb
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%32 = OpLabel
%33 = OpFunctionCall %void %reflect_f47fdb
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_f47fdb
OpReturn
OpFunctionEnd

45
test/tint/builtins/gen/var/reflect/a8baf2.wgsl Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<3, fa>, vec<3, fa>) -> vec<3, fa>
fn reflect_a8baf2() {
const arg_0 = vec3(1.);
const arg_1 = vec3(1.);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_a8baf2();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_a8baf2();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_a8baf2();
}

30
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_a8baf2() {
float3 res = (-5.0f).xxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_a8baf2();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_a8baf2();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_a8baf2();
return;
}

30
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_a8baf2() {
float3 res = (-5.0f).xxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_a8baf2();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_a8baf2();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_a8baf2();
return;
}

49
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
vec4 vertex_main() {
reflect_a8baf2();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
void fragment_main() {
reflect_a8baf2();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_a8baf2() {
vec3 res = vec3(-5.0f);
}
void compute_main() {
reflect_a8baf2();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_a8baf2() {
float3 res = float3(-5.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_a8baf2();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_a8baf2();
return;
}
kernel void compute_main() {
reflect_a8baf2();
return;
}

67
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,67 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 33
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_a8baf2 "reflect_a8baf2"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v3float = OpTypeVector %float 3
%float_n5 = OpConstant %float -5
%15 = OpConstantComposite %v3float %float_n5 %float_n5 %float_n5
%_ptr_Function_v3float = OpTypePointer Function %v3float
%18 = OpConstantNull %v3float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_a8baf2 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v3float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_a8baf2
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_a8baf2
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_a8baf2
OpReturn
OpFunctionEnd

21
test/tint/builtins/gen/var/reflect/a8baf2.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,21 @@
fn reflect_a8baf2() {
const arg_0 = vec3(1.0);
const arg_1 = vec3(1.0);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_a8baf2();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_a8baf2();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_a8baf2();
}

45
test/tint/builtins/gen/var/reflect/bba2d0.wgsl Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<2, fa>, vec<2, fa>) -> vec<2, fa>
fn reflect_bba2d0() {
const arg_0 = vec2(1.);
const arg_1 = vec2(1.);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_bba2d0();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_bba2d0();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_bba2d0();
}

30
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_bba2d0() {
float2 res = (-3.0f).xx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_bba2d0();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_bba2d0();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_bba2d0();
return;
}

30
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_bba2d0() {
float2 res = (-3.0f).xx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_bba2d0();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_bba2d0();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_bba2d0();
return;
}

49
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
vec4 vertex_main() {
reflect_bba2d0();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
void fragment_main() {
reflect_bba2d0();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_bba2d0() {
vec2 res = vec2(-3.0f);
}
void compute_main() {
reflect_bba2d0();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_bba2d0() {
float2 res = float2(-3.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_bba2d0();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_bba2d0();
return;
}
kernel void compute_main() {
reflect_bba2d0();
return;
}

67
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,67 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 33
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_bba2d0 "reflect_bba2d0"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%v2float = OpTypeVector %float 2
%float_n3 = OpConstant %float -3
%15 = OpConstantComposite %v2float %float_n3 %float_n3
%_ptr_Function_v2float = OpTypePointer Function %v2float
%18 = OpConstantNull %v2float
%19 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_bba2d0 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v2float Function %18
OpStore %res %15
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %19
%21 = OpLabel
%22 = OpFunctionCall %void %reflect_bba2d0
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%24 = OpLabel
%25 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %25
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%28 = OpLabel
%29 = OpFunctionCall %void %reflect_bba2d0
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%31 = OpLabel
%32 = OpFunctionCall %void %reflect_bba2d0
OpReturn
OpFunctionEnd

21
test/tint/builtins/gen/var/reflect/bba2d0.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,21 @@
fn reflect_bba2d0() {
const arg_0 = vec2(1.0);
const arg_1 = vec2(1.0);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_bba2d0();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_bba2d0();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_bba2d0();
}

45
test/tint/builtins/gen/var/reflect/d7e210.wgsl Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// test/tint/builtins/gen/gen.wgsl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// fn reflect(vec<4, fa>, vec<4, fa>) -> vec<4, fa>
fn reflect_d7e210() {
const arg_0 = vec4(1.);
const arg_1 = vec4(1.);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_d7e210();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_d7e210();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_d7e210();
}

30
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.dxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_d7e210() {
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_d7e210();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_d7e210();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_d7e210();
return;
}

30
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.fxc.hlsl Normal file
View File

@ -0,0 +1,30 @@
void reflect_d7e210() {
float4 res = (-7.0f).xxxx;
}
struct tint_symbol {
float4 value : SV_Position;
};
float4 vertex_main_inner() {
reflect_d7e210();
return (0.0f).xxxx;
}
tint_symbol vertex_main() {
const float4 inner_result = vertex_main_inner();
tint_symbol wrapper_result = (tint_symbol)0;
wrapper_result.value = inner_result;
return wrapper_result;
}
void fragment_main() {
reflect_d7e210();
return;
}
[numthreads(1, 1, 1)]
void compute_main() {
reflect_d7e210();
return;
}

49
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.glsl Normal file
View File

@ -0,0 +1,49 @@
#version 310 es
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
vec4 vertex_main() {
reflect_d7e210();
return vec4(0.0f);
}
void main() {
gl_PointSize = 1.0;
vec4 inner_result = vertex_main();
gl_Position = inner_result;
gl_Position.y = -(gl_Position.y);
gl_Position.z = ((2.0f * gl_Position.z) - gl_Position.w);
return;
}
#version 310 es
precision mediump float;
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
void fragment_main() {
reflect_d7e210();
}
void main() {
fragment_main();
return;
}
#version 310 es
void reflect_d7e210() {
vec4 res = vec4(-7.0f);
}
void compute_main() {
reflect_d7e210();
}
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main() {
compute_main();
return;
}

33
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.msl Normal file
View File

@ -0,0 +1,33 @@
#include <metal_stdlib>
using namespace metal;
void reflect_d7e210() {
float4 res = float4(-7.0f);
}
struct tint_symbol {
float4 value [[position]];
};
float4 vertex_main_inner() {
reflect_d7e210();
return float4(0.0f);
}
vertex tint_symbol vertex_main() {
float4 const inner_result = vertex_main_inner();
tint_symbol wrapper_result = {};
wrapper_result.value = inner_result;
return wrapper_result;
}
fragment void fragment_main() {
reflect_d7e210();
return;
}
kernel void compute_main() {
reflect_d7e210();
return;
}

65
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.spvasm Normal file
View File

@ -0,0 +1,65 @@
; SPIR-V
; Version: 1.3
; Generator: Google Tint Compiler; 0
; Bound: 31
; Schema: 0
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %vertex_main "vertex_main" %value %vertex_point_size
OpEntryPoint Fragment %fragment_main "fragment_main"
OpEntryPoint GLCompute %compute_main "compute_main"
OpExecutionMode %fragment_main OriginUpperLeft
OpExecutionMode %compute_main LocalSize 1 1 1
OpName %value "value"
OpName %vertex_point_size "vertex_point_size"
OpName %reflect_d7e210 "reflect_d7e210"
OpName %res "res"
OpName %vertex_main_inner "vertex_main_inner"
OpName %vertex_main "vertex_main"
OpName %fragment_main "fragment_main"
OpName %compute_main "compute_main"
OpDecorate %value BuiltIn Position
OpDecorate %vertex_point_size BuiltIn PointSize
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%_ptr_Output_v4float = OpTypePointer Output %v4float
%5 = OpConstantNull %v4float
%value = OpVariable %_ptr_Output_v4float Output %5
%_ptr_Output_float = OpTypePointer Output %float
%8 = OpConstantNull %float
%vertex_point_size = OpVariable %_ptr_Output_float Output %8
%void = OpTypeVoid
%9 = OpTypeFunction %void
%float_n7 = OpConstant %float -7
%14 = OpConstantComposite %v4float %float_n7 %float_n7 %float_n7 %float_n7
%_ptr_Function_v4float = OpTypePointer Function %v4float
%17 = OpTypeFunction %v4float
%float_1 = OpConstant %float 1
%reflect_d7e210 = OpFunction %void None %9
%12 = OpLabel
%res = OpVariable %_ptr_Function_v4float Function %5
OpStore %res %14
OpReturn
OpFunctionEnd
%vertex_main_inner = OpFunction %v4float None %17
%19 = OpLabel
%20 = OpFunctionCall %void %reflect_d7e210
OpReturnValue %5
OpFunctionEnd
%vertex_main = OpFunction %void None %9
%22 = OpLabel
%23 = OpFunctionCall %v4float %vertex_main_inner
OpStore %value %23
OpStore %vertex_point_size %float_1
OpReturn
OpFunctionEnd
%fragment_main = OpFunction %void None %9
%26 = OpLabel
%27 = OpFunctionCall %void %reflect_d7e210
OpReturn
OpFunctionEnd
%compute_main = OpFunction %void None %9
%29 = OpLabel
%30 = OpFunctionCall %void %reflect_d7e210
OpReturn
OpFunctionEnd

21
test/tint/builtins/gen/var/reflect/d7e210.wgsl.expected.wgsl Normal file
View File

@ -0,0 +1,21 @@
fn reflect_d7e210() {
const arg_0 = vec4(1.0);
const arg_1 = vec4(1.0);
var res = reflect(arg_0, arg_1);
}
@vertex
fn vertex_main() -> @builtin(position) vec4<f32> {
reflect_d7e210();
return vec4<f32>();
}
@fragment
fn fragment_main() {
reflect_d7e210();
}
@compute @workgroup_size(1)
fn compute_main() {
reflect_d7e210();
}