-
Notifications
You must be signed in to change notification settings - Fork 11.9k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[clang][HLSL] Update DXIL/SPIRV hybird CodeGen tests to use temp var
Update all hybird DXIL/SPIRV codegen tests to use temp variable representing interchange target
- Loading branch information
1 parent
e1cf849
commit f2e483e
Showing
9 changed files
with
313 additions
and
546 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Large diffs are not rendered by default.
Oops, something went wrong.
Large diffs are not rendered by default.
Oops, something went wrong.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,84 +1,64 @@ | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: dxil-pc-shadermodel6.3-library %s -fnative-half-type \ | ||
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \ | ||
// RUN: --check-prefixes=CHECK,DXIL_CHECK,DXIL_NATIVE_HALF,NATIVE_HALF | ||
// RUN: --check-prefixes=CHECK,NATIVE_HALF \ | ||
// RUN: -DFNATTRS=noundef -DTARGET=dx | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes \ | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,DXIL_CHECK,NO_HALF,DXIL_NO_HALF | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF \ | ||
// RUN: -DFNATTRS=noundef -DTARGET=dx | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: spirv-unknown-vulkan-compute %s -fnative-half-type \ | ||
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \ | ||
// RUN: --check-prefixes=CHECK,SPIR_CHECK,NATIVE_HALF,SPIR_NATIVE_HALF | ||
// RUN: --check-prefixes=CHECK,NATIVE_HALF \ | ||
// RUN: -DFNATTRS="spir_func noundef" -DTARGET=spv | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: spirv-unknown-vulkan-compute %s -emit-llvm -disable-llvm-passes \ | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,SPIR_CHECK,NO_HALF,SPIR_NO_HALF | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF \ | ||
// RUN: -DFNATTRS="spir_func noundef" -DTARGET=spv | ||
|
||
// DXIL_NATIVE_HALF: define noundef half @ | ||
// SPIR_NATIVE_HALF: define spir_func noundef half @ | ||
// DXIL_NATIVE_HALF: %hlsl.frac = call half @llvm.dx.frac.f16( | ||
// SPIR_NATIVE_HALF: %hlsl.frac = call half @llvm.spv.frac.f16( | ||
// NATIVE_HALF: define [[FNATTRS]] half @ | ||
// NATIVE_HALF: %hlsl.frac = call half @llvm.[[TARGET]].frac.f16( | ||
// NATIVE_HALF: ret half %hlsl.frac | ||
// DXIL_NO_HALF: define noundef float @ | ||
// SPIR_NO_HALF: define spir_func noundef float @ | ||
// DXIL_NO_HALF: %hlsl.frac = call float @llvm.dx.frac.f32( | ||
// SPIR_NO_HALF: %hlsl.frac = call float @llvm.spv.frac.f32( | ||
// NO_HALF: define [[FNATTRS]] float @ | ||
// NO_HALF: %hlsl.frac = call float @llvm.[[TARGET]].frac.f32( | ||
// NO_HALF: ret float %hlsl.frac | ||
half test_frac_half(half p0) { return frac(p0); } | ||
// DXIL_NATIVE_HALF: define noundef <2 x half> @ | ||
// SPIR_NATIVE_HALF: define spir_func noundef <2 x half> @ | ||
// DXIL_NATIVE_HALF: %hlsl.frac = call <2 x half> @llvm.dx.frac.v2f16 | ||
// SPIR_NATIVE_HALF: %hlsl.frac = call <2 x half> @llvm.spv.frac.v2f16 | ||
// NATIVE_HALF: define [[FNATTRS]] <2 x half> @ | ||
// NATIVE_HALF: %hlsl.frac = call <2 x half> @llvm.[[TARGET]].frac.v2f16 | ||
// NATIVE_HALF: ret <2 x half> %hlsl.frac | ||
// DXIL_NO_HALF: define noundef <2 x float> @ | ||
// SPIR_NO_HALF: define spir_func noundef <2 x float> @ | ||
// DXIL_NO_HALF: %hlsl.frac = call <2 x float> @llvm.dx.frac.v2f32( | ||
// SPIR_NO_HALF: %hlsl.frac = call <2 x float> @llvm.spv.frac.v2f32( | ||
// NO_HALF: define [[FNATTRS]] <2 x float> @ | ||
// NO_HALF: %hlsl.frac = call <2 x float> @llvm.[[TARGET]].frac.v2f32( | ||
// NO_HALF: ret <2 x float> %hlsl.frac | ||
half2 test_frac_half2(half2 p0) { return frac(p0); } | ||
// DXIL_NATIVE_HALF: define noundef <3 x half> @ | ||
// SPIR_NATIVE_HALF: define spir_func noundef <3 x half> @ | ||
// DXIL_NATIVE_HALF: %hlsl.frac = call <3 x half> @llvm.dx.frac.v3f16 | ||
// SPIR_NATIVE_HALF: %hlsl.frac = call <3 x half> @llvm.spv.frac.v3f16 | ||
// NATIVE_HALF: define [[FNATTRS]] <3 x half> @ | ||
// NATIVE_HALF: %hlsl.frac = call <3 x half> @llvm.[[TARGET]].frac.v3f16 | ||
// NATIVE_HALF: ret <3 x half> %hlsl.frac | ||
// DXIL_NO_HALF: define noundef <3 x float> @ | ||
// SPIR_NO_HALF: define spir_func noundef <3 x float> @ | ||
// DXIL_NO_HALF: %hlsl.frac = call <3 x float> @llvm.dx.frac.v3f32( | ||
// SPIR_NO_HALF: %hlsl.frac = call <3 x float> @llvm.spv.frac.v3f32( | ||
// NO_HALF: define [[FNATTRS]] <3 x float> @ | ||
// NO_HALF: %hlsl.frac = call <3 x float> @llvm.[[TARGET]].frac.v3f32( | ||
// NO_HALF: ret <3 x float> %hlsl.frac | ||
half3 test_frac_half3(half3 p0) { return frac(p0); } | ||
// DXIL_NATIVE_HALF: define noundef <4 x half> @ | ||
// SPIR_NATIVE_HALF: define spir_func noundef <4 x half> @ | ||
// DXIL_NATIVE_HALF: %hlsl.frac = call <4 x half> @llvm.dx.frac.v4f16 | ||
// SPIR_NATIVE_HALF: %hlsl.frac = call <4 x half> @llvm.spv.frac.v4f16 | ||
// NATIVE_HALF: define [[FNATTRS]] <4 x half> @ | ||
// NATIVE_HALF: %hlsl.frac = call <4 x half> @llvm.[[TARGET]].frac.v4f16 | ||
// NATIVE_HALF: ret <4 x half> %hlsl.frac | ||
// DXIL_NO_HALF: define noundef <4 x float> @ | ||
// SPIR_NO_HALF: define spir_func noundef <4 x float> @ | ||
// DXIL_NO_HALF: %hlsl.frac = call <4 x float> @llvm.dx.frac.v4f32( | ||
// SPIR_NO_HALF: %hlsl.frac = call <4 x float> @llvm.spv.frac.v4f32( | ||
// NO_HALF: define [[FNATTRS]] <4 x float> @ | ||
// NO_HALF: %hlsl.frac = call <4 x float> @llvm.[[TARGET]].frac.v4f32( | ||
// NO_HALF: ret <4 x float> %hlsl.frac | ||
half4 test_frac_half4(half4 p0) { return frac(p0); } | ||
|
||
// DXIL_CHECK: define noundef float @ | ||
// SPIR_CHECK: define spir_func noundef float @ | ||
// DXIL_CHECK: %hlsl.frac = call float @llvm.dx.frac.f32( | ||
// SPIR_CHECK: %hlsl.frac = call float @llvm.spv.frac.f32( | ||
// CHECK: define [[FNATTRS]] float @ | ||
// CHECK: %hlsl.frac = call float @llvm.[[TARGET]].frac.f32( | ||
// CHECK: ret float %hlsl.frac | ||
float test_frac_float(float p0) { return frac(p0); } | ||
// DXIL_CHECK: define noundef <2 x float> @ | ||
// SPIR_CHECK: define spir_func noundef <2 x float> @ | ||
// DXIL_CHECK: %hlsl.frac = call <2 x float> @llvm.dx.frac.v2f32 | ||
// SPIR_CHECK: %hlsl.frac = call <2 x float> @llvm.spv.frac.v2f32 | ||
// CHECK: define [[FNATTRS]] <2 x float> @ | ||
// CHECK: %hlsl.frac = call <2 x float> @llvm.[[TARGET]].frac.v2f32 | ||
// CHECK: ret <2 x float> %hlsl.frac | ||
float2 test_frac_float2(float2 p0) { return frac(p0); } | ||
// DXIL_CHECK: define noundef <3 x float> @ | ||
// SPIR_CHECK: define spir_func noundef <3 x float> @ | ||
// DXIL_CHECK: %hlsl.frac = call <3 x float> @llvm.dx.frac.v3f32 | ||
// SPIR_CHECK: %hlsl.frac = call <3 x float> @llvm.spv.frac.v3f32 | ||
// CHECK: define [[FNATTRS]] <3 x float> @ | ||
// CHECK: %hlsl.frac = call <3 x float> @llvm.[[TARGET]].frac.v3f32 | ||
// CHECK: ret <3 x float> %hlsl.frac | ||
float3 test_frac_float3(float3 p0) { return frac(p0); } | ||
// DXIL_CHECK: define noundef <4 x float> @ | ||
// SPIR_CHECK: define spir_func noundef <4 x float> @ | ||
// DXIL_CHECK: %hlsl.frac = call <4 x float> @llvm.dx.frac.v4f32 | ||
// SPIR_CHECK: %hlsl.frac = call <4 x float> @llvm.spv.frac.v4f32 | ||
// CHECK: define [[FNATTRS]] <4 x float> @ | ||
// CHECK: %hlsl.frac = call <4 x float> @llvm.[[TARGET]].frac.v4f32 | ||
// CHECK: ret <4 x float> %hlsl.frac | ||
float4 test_frac_float4(float4 p0) { return frac(p0); } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,88 +1,76 @@ | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: dxil-pc-shadermodel6.3-library %s -fnative-half-type \ | ||
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \ | ||
// RUN: --check-prefixes=CHECK,DXIL_CHECK,DXIL_NATIVE_HALF,NATIVE_HALF | ||
// RUN: --check-prefixes=CHECK,NATIVE_HALF \ | ||
// RUN: -DFNATTRS=noundef -DTARGET=dx | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes \ | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,DXIL_CHECK,NO_HALF,DXIL_NO_HALF | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF \ | ||
// RUN: -DFNATTRS=noundef -DTARGET=dx | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: spirv-unknown-vulkan-compute %s -fnative-half-type \ | ||
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \ | ||
// RUN: --check-prefixes=CHECK,NATIVE_HALF,SPIR_NATIVE_HALF,SPIR_CHECK | ||
// RUN: --check-prefixes=CHECK,NATIVE_HALF \ | ||
// RUN: -DFNATTRS="spir_func noundef" -DTARGET=spv | ||
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \ | ||
// RUN: spirv-unknown-vulkan-compute %s -emit-llvm -disable-llvm-passes \ | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF,SPIR_NO_HALF,SPIR_CHECK | ||
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,NO_HALF \ | ||
// RUN: -DFNATTRS="spir_func noundef" -DTARGET=spv | ||
|
||
|
||
// DXIL_NATIVE_HALF: %hlsl.lerp = call half @llvm.dx.lerp.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}) | ||
// SPIR_NATIVE_HALF: %hlsl.lerp = call half @llvm.spv.lerp.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}) | ||
// NATIVE_HALF: %hlsl.lerp = call half @llvm.[[TARGET]].lerp.f16(half %{{.*}}, half %{{.*}}, half %{{.*}}) | ||
// NATIVE_HALF: ret half %hlsl.lerp | ||
// DXIL_NO_HALF: %hlsl.lerp = call float @llvm.dx.lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// SPIR_NO_HALF: %hlsl.lerp = call float @llvm.spv.lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// NO_HALF: %hlsl.lerp = call float @llvm.[[TARGET]].lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// NO_HALF: ret float %hlsl.lerp | ||
half test_lerp_half(half p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_NATIVE_HALF: %hlsl.lerp = call <2 x half> @llvm.dx.lerp.v2f16(<2 x half> %{{.*}}, <2 x half> %{{.*}}, <2 x half> %{{.*}}) | ||
// SPIR_NATIVE_HALF: %hlsl.lerp = call <2 x half> @llvm.spv.lerp.v2f16(<2 x half> %{{.*}}, <2 x half> %{{.*}}, <2 x half> %{{.*}}) | ||
// NATIVE_HALF: %hlsl.lerp = call <2 x half> @llvm.[[TARGET]].lerp.v2f16(<2 x half> %{{.*}}, <2 x half> %{{.*}}, <2 x half> %{{.*}}) | ||
// NATIVE_HALF: ret <2 x half> %hlsl.lerp | ||
// DXIL_NO_HALF: %hlsl.lerp = call <2 x float> @llvm.dx.lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// SPIR_NO_HALF: %hlsl.lerp = call <2 x float> @llvm.spv.lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// NO_HALF: %hlsl.lerp = call <2 x float> @llvm.[[TARGET]].lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// NO_HALF: ret <2 x float> %hlsl.lerp | ||
half2 test_lerp_half2(half2 p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_NATIVE_HALF: %hlsl.lerp = call <3 x half> @llvm.dx.lerp.v3f16(<3 x half> %{{.*}}, <3 x half> %{{.*}}, <3 x half> %{{.*}}) | ||
// SPIR_NATIVE_HALF: %hlsl.lerp = call <3 x half> @llvm.spv.lerp.v3f16(<3 x half> %{{.*}}, <3 x half> %{{.*}}, <3 x half> %{{.*}}) | ||
// NATIVE_HALF: %hlsl.lerp = call <3 x half> @llvm.[[TARGET]].lerp.v3f16(<3 x half> %{{.*}}, <3 x half> %{{.*}}, <3 x half> %{{.*}}) | ||
// NATIVE_HALF: ret <3 x half> %hlsl.lerp | ||
// DXIL_NO_HALF: %hlsl.lerp = call <3 x float> @llvm.dx.lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// SPIR_NO_HALF: %hlsl.lerp = call <3 x float> @llvm.spv.lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// NO_HALF: %hlsl.lerp = call <3 x float> @llvm.[[TARGET]].lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// NO_HALF: ret <3 x float> %hlsl.lerp | ||
half3 test_lerp_half3(half3 p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_NATIVE_HALF: %hlsl.lerp = call <4 x half> @llvm.dx.lerp.v4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x half> %{{.*}}) | ||
// SPIR_NATIVE_HALF: %hlsl.lerp = call <4 x half> @llvm.spv.lerp.v4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x half> %{{.*}}) | ||
// NATIVE_HALF: %hlsl.lerp = call <4 x half> @llvm.[[TARGET]].lerp.v4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x half> %{{.*}}) | ||
// NATIVE_HALF: ret <4 x half> %hlsl.lerp | ||
// DXIL_NO_HALF: %hlsl.lerp = call <4 x float> @llvm.dx.lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// SPIR_NO_HALF: %hlsl.lerp = call <4 x float> @llvm.spv.lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// NO_HALF: %hlsl.lerp = call <4 x float> @llvm.[[TARGET]].lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// NO_HALF: ret <4 x float> %hlsl.lerp | ||
half4 test_lerp_half4(half4 p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_CHECK: %hlsl.lerp = call float @llvm.dx.lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// SPIR_CHECK: %hlsl.lerp = call float @llvm.spv.lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// CHECK: %hlsl.lerp = call float @llvm.[[TARGET]].lerp.f32(float %{{.*}}, float %{{.*}}, float %{{.*}}) | ||
// CHECK: ret float %hlsl.lerp | ||
float test_lerp_float(float p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_CHECK: %hlsl.lerp = call <2 x float> @llvm.dx.lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// SPIR_CHECK: %hlsl.lerp = call <2 x float> @llvm.spv.lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// CHECK: %hlsl.lerp = call <2 x float> @llvm.[[TARGET]].lerp.v2f32(<2 x float> %{{.*}}, <2 x float> %{{.*}}, <2 x float> %{{.*}}) | ||
// CHECK: ret <2 x float> %hlsl.lerp | ||
float2 test_lerp_float2(float2 p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_CHECK: %hlsl.lerp = call <3 x float> @llvm.dx.lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// SPIR_CHECK: %hlsl.lerp = call <3 x float> @llvm.spv.lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// CHECK: %hlsl.lerp = call <3 x float> @llvm.[[TARGET]].lerp.v3f32(<3 x float> %{{.*}}, <3 x float> %{{.*}}, <3 x float> %{{.*}}) | ||
// CHECK: ret <3 x float> %hlsl.lerp | ||
float3 test_lerp_float3(float3 p0) { return lerp(p0, p0, p0); } | ||
|
||
// DXIL_CHECK: %hlsl.lerp = call <4 x float> @llvm.dx.lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// SPIR_CHECK: %hlsl.lerp = call <4 x float> @llvm.spv.lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// CHECK: %hlsl.lerp = call <4 x float> @llvm.[[TARGET]].lerp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) | ||
// CHECK: ret <4 x float> %hlsl.lerp | ||
float4 test_lerp_float4(float4 p0) { return lerp(p0, p0, p0); } | ||
|
||
// CHECK: %[[b:.*]] = load <2 x float>, ptr %p1.addr, align 8 | ||
// CHECK: %[[c:.*]] = load <2 x float>, ptr %p1.addr, align 8 | ||
// DXIL_CHECK: %hlsl.lerp = call <2 x float> @llvm.dx.lerp.v2f32(<2 x float> %splat.splat, <2 x float> %[[b]], <2 x float> %[[c]]) | ||
// SPIR_CHECK: %hlsl.lerp = call <2 x float> @llvm.spv.lerp.v2f32(<2 x float> %splat.splat, <2 x float> %[[b]], <2 x float> %[[c]]) | ||
// CHECK: %hlsl.lerp = call <2 x float> @llvm.[[TARGET]].lerp.v2f32(<2 x float> %splat.splat, <2 x float> %[[b]], <2 x float> %[[c]]) | ||
// CHECK: ret <2 x float> %hlsl.lerp | ||
float2 test_lerp_float2_splat(float p0, float2 p1) { return lerp(p0, p1, p1); } | ||
|
||
// CHECK: %[[b:.*]] = load <3 x float>, ptr %p1.addr, align 16 | ||
// CHECK: %[[c:.*]] = load <3 x float>, ptr %p1.addr, align 16 | ||
// DXIL_CHECK: %hlsl.lerp = call <3 x float> @llvm.dx.lerp.v3f32(<3 x float> %splat.splat, <3 x float> %[[b]], <3 x float> %[[c]]) | ||
// SPIR_CHECK: %hlsl.lerp = call <3 x float> @llvm.spv.lerp.v3f32(<3 x float> %splat.splat, <3 x float> %[[b]], <3 x float> %[[c]]) | ||
// CHECK: %hlsl.lerp = call <3 x float> @llvm.[[TARGET]].lerp.v3f32(<3 x float> %splat.splat, <3 x float> %[[b]], <3 x float> %[[c]]) | ||
// CHECK: ret <3 x float> %hlsl.lerp | ||
float3 test_lerp_float3_splat(float p0, float3 p1) { return lerp(p0, p1, p1); } | ||
|
||
// CHECK: %[[b:.*]] = load <4 x float>, ptr %p1.addr, align 16 | ||
// CHECK: %[[c:.*]] = load <4 x float>, ptr %p1.addr, align 16 | ||
// DXIL_CHECK: %hlsl.lerp = call <4 x float> @llvm.dx.lerp.v4f32(<4 x float> %splat.splat, <4 x float> %[[b]], <4 x float> %[[c]]) | ||
// SPIR_CHECK: %hlsl.lerp = call <4 x float> @llvm.spv.lerp.v4f32(<4 x float> %splat.splat, <4 x float> %[[b]], <4 x float> %[[c]]) | ||
// CHECK: %hlsl.lerp = call <4 x float> @llvm.[[TARGET]].lerp.v4f32(<4 x float> %splat.splat, <4 x float> %[[b]], <4 x float> %[[c]]) | ||
// CHECK: ret <4 x float> %hlsl.lerp | ||
float4 test_lerp_float4_splat(float p0, float4 p1) { return lerp(p0, p1, p1); } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.