Skip to content

Commit 4f1106a

Browse files
kcloudy0717kcloudy0717
committed
Clean up tests by passing target/cc as part of FileCheck cmd -D
1 parent 8c71e06 commit 4f1106a

2 files changed

Lines changed: 45 additions & 47 deletions

File tree

‎clang/test/CodeGenHLSL/builtins/QuadReadAcrossDiagonal.hlsl‎

Lines changed: 44 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,171 +1,169 @@
11
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
22
// RUN: dxil-pc-shadermodel6.3-compute %s -fnative-half-type -fnative-int16-type \
33
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \
4-
// RUN: --check-prefixes=CHECK,CHECK-DXIL,CHECK-NATIVE_HALF
4+
// RUN: --check-prefixes=CHECK,CHECK-NATIVE_HALF -DTARGET=dx -DCC=""
55
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
66
// RUN: dxil-pc-shadermodel6.3-compute %s -emit-llvm -disable-llvm-passes \
7-
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,CHECK-DXIL,CHECK-NO_HALF
7+
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NO_HALF -DTARGET=dx -DCC=""
88

99
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
1010
// RUN: spirv-unknown-vulkan-compute %s -fnative-half-type -fnative-int16-type \
1111
// RUN: -emit-llvm -disable-llvm-passes -o - | FileCheck %s \
12-
// RUN: --check-prefixes=CHECK,CHECK-SPIRV,CHECK-NATIVE_HALF
12+
// RUN: --check-prefixes=CHECK,CHECK-NATIVE_HALF -DTARGET=spv -DCC="spir_func "
1313
// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
1414
// RUN: spirv-unknown-vulkan-compute %s -emit-llvm -disable-llvm-passes \
15-
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,CHECK-SPIRV,CHECK-NO_HALF
15+
// RUN: -o - | FileCheck %s --check-prefixes=CHECK,CHECK-NO_HALF -DTARGET=spv -DCC="spir_func "
1616

17-
// Capture the expected interchange format so not every check needs to be duplicated
18-
// CHECK-DXIL: %[[RET:.*]] = call [[CC:]]i32 @llvm.[[ICF:dx]].quad.read.across.diagonal.i32(i32 %[[#]])
19-
// CHECK-SPIRV: %[[RET:.*]] = call [[CC:spir_func ]]i32 @llvm.[[ICF:spv]].quad.read.across.diagonal.i32(i32 %[[#]])
17+
// CHECK: %[[RET:.*]] = call [[CC]]i32 @llvm.[[TARGET]].quad.read.across.diagonal.i32(i32 %[[#]])
2018
// CHECK: ret i32 %[[RET]]
2119
int test_int(int expr) { return QuadReadAcrossDiagonal(expr); }
2220

23-
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v2i32(<2 x i32> %[[#]])
21+
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v2i32(<2 x i32> %[[#]])
2422
// CHECK: ret <2 x i32> %[[RET]]
2523
int2 test_int2(int2 expr) { return QuadReadAcrossDiagonal(expr); }
2624

27-
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v3i32(<3 x i32> %[[#]])
25+
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v3i32(<3 x i32> %[[#]])
2826
// CHECK: ret <3 x i32> %[[RET]]
2927
int3 test_int3(int3 expr) { return QuadReadAcrossDiagonal(expr); }
3028

31-
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v4i32(<4 x i32> %[[#]])
29+
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v4i32(<4 x i32> %[[#]])
3230
// CHECK: ret <4 x i32> %[[RET]]
3331
int4 test_int4(int4 expr) { return QuadReadAcrossDiagonal(expr); }
3432

35-
// CHECK: %[[RET:.*]] = call [[CC]]i32 @llvm.[[ICF]].quad.read.across.diagonal.i32(i32 %[[#]])
33+
// CHECK: %[[RET:.*]] = call [[CC]]i32 @llvm.[[TARGET]].quad.read.across.diagonal.i32(i32 %[[#]])
3634
// CHECK: ret i32 %[[RET]]
3735
uint test_uint(uint expr) { return QuadReadAcrossDiagonal(expr); }
3836

39-
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v2i32(<2 x i32> %[[#]])
37+
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v2i32(<2 x i32> %[[#]])
4038
// CHECK: ret <2 x i32> %[[RET]]
4139
uint2 test_uint2(uint2 expr) { return QuadReadAcrossDiagonal(expr); }
4240

43-
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v3i32(<3 x i32> %[[#]])
41+
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v3i32(<3 x i32> %[[#]])
4442
// CHECK: ret <3 x i32> %[[RET]]
4543
uint3 test_uint3(uint3 expr) { return QuadReadAcrossDiagonal(expr); }
4644

47-
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i32> @llvm.[[ICF]].quad.read.across.diagonal.v4i32(<4 x i32> %[[#]])
45+
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i32> @llvm.[[TARGET]].quad.read.across.diagonal.v4i32(<4 x i32> %[[#]])
4846
// CHECK: ret <4 x i32> %[[RET]]
4947
uint4 test_uint4(uint4 expr) { return QuadReadAcrossDiagonal(expr); }
5048

51-
// CHECK: %[[RET:.*]] = call [[CC]]i64 @llvm.[[ICF]].quad.read.across.diagonal.i64(i64 %[[#]])
49+
// CHECK: %[[RET:.*]] = call [[CC]]i64 @llvm.[[TARGET]].quad.read.across.diagonal.i64(i64 %[[#]])
5250
// CHECK: ret i64 %[[RET]]
5351
int64_t test_int64_t(int64_t expr) { return QuadReadAcrossDiagonal(expr); }
5452

55-
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v2i64(<2 x i64> %[[#]])
53+
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v2i64(<2 x i64> %[[#]])
5654
// CHECK: ret <2 x i64> %[[RET]]
5755
int64_t2 test_int64_t2(int64_t2 expr) { return QuadReadAcrossDiagonal(expr); }
5856

59-
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v3i64(<3 x i64> %[[#]])
57+
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v3i64(<3 x i64> %[[#]])
6058
// CHECK: ret <3 x i64> %[[RET]]
6159
int64_t3 test_int64_t3(int64_t3 expr) { return QuadReadAcrossDiagonal(expr); }
6260

63-
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v4i64(<4 x i64> %[[#]])
61+
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v4i64(<4 x i64> %[[#]])
6462
// CHECK: ret <4 x i64> %[[RET]]
6563
int64_t4 test_int64_t4(int64_t4 expr) { return QuadReadAcrossDiagonal(expr); }
6664

67-
// CHECK: %[[RET:.*]] = call [[CC]]i64 @llvm.[[ICF]].quad.read.across.diagonal.i64(i64 %[[#]])
65+
// CHECK: %[[RET:.*]] = call [[CC]]i64 @llvm.[[TARGET]].quad.read.across.diagonal.i64(i64 %[[#]])
6866
// CHECK: ret i64 %[[RET]]
6967
uint64_t test_uint64_t(uint64_t expr) { return QuadReadAcrossDiagonal(expr); }
7068

71-
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v2i64(<2 x i64> %[[#]])
69+
// CHECK: %[[RET:.*]] = call [[CC]]<2 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v2i64(<2 x i64> %[[#]])
7270
// CHECK: ret <2 x i64> %[[RET]]
7371
uint64_t2 test_uint64_t2(uint64_t2 expr) { return QuadReadAcrossDiagonal(expr); }
7472

75-
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v3i64(<3 x i64> %[[#]])
73+
// CHECK: %[[RET:.*]] = call [[CC]]<3 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v3i64(<3 x i64> %[[#]])
7674
// CHECK: ret <3 x i64> %[[RET]]
7775
uint64_t3 test_uint64_t3(uint64_t3 expr) { return QuadReadAcrossDiagonal(expr); }
7876

79-
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i64> @llvm.[[ICF]].quad.read.across.diagonal.v4i64(<4 x i64> %[[#]])
77+
// CHECK: %[[RET:.*]] = call [[CC]]<4 x i64> @llvm.[[TARGET]].quad.read.across.diagonal.v4i64(<4 x i64> %[[#]])
8078
// CHECK: ret <4 x i64> %[[RET]]
8179
uint64_t4 test_uint64_t4(uint64_t4 expr) { return QuadReadAcrossDiagonal(expr); }
8280

83-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]float @llvm.[[ICF]].quad.read.across.diagonal.f32(float %[[#]])
81+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]float @llvm.[[TARGET]].quad.read.across.diagonal.f32(float %[[#]])
8482
// CHECK: ret float %[[RET]]
8583
float test_float(float expr) { return QuadReadAcrossDiagonal(expr); }
8684

87-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x float> @llvm.[[ICF]].quad.read.across.diagonal.v2f32(<2 x float> %[[#]])
85+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v2f32(<2 x float> %[[#]])
8886
// CHECK: ret <2 x float> %[[RET]]
8987
float2 test_float2(float2 expr) { return QuadReadAcrossDiagonal(expr); }
9088

91-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x float> @llvm.[[ICF]].quad.read.across.diagonal.v3f32(<3 x float> %[[#]])
89+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v3f32(<3 x float> %[[#]])
9290
// CHECK: ret <3 x float> %[[RET]]
9391
float3 test_float3(float3 expr) { return QuadReadAcrossDiagonal(expr); }
9492

95-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x float> @llvm.[[ICF]].quad.read.across.diagonal.v4f32(<4 x float> %[[#]])
93+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v4f32(<4 x float> %[[#]])
9694
// CHECK: ret <4 x float> %[[RET]]
9795
float4 test_float4(float4 expr) { return QuadReadAcrossDiagonal(expr); }
9896

99-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]double @llvm.[[ICF]].quad.read.across.diagonal.f64(double %[[#]])
97+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]double @llvm.[[TARGET]].quad.read.across.diagonal.f64(double %[[#]])
10098
// CHECK: ret double %[[RET]]
10199
double test_double(double expr) { return QuadReadAcrossDiagonal(expr); }
102100

103-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x double> @llvm.[[ICF]].quad.read.across.diagonal.v2f64(<2 x double> %[[#]])
101+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x double> @llvm.[[TARGET]].quad.read.across.diagonal.v2f64(<2 x double> %[[#]])
104102
// CHECK: ret <2 x double> %[[RET]]
105103
double2 test_double2(double2 expr) { return QuadReadAcrossDiagonal(expr); }
106104

107-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x double> @llvm.[[ICF]].quad.read.across.diagonal.v3f64(<3 x double> %[[#]])
105+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x double> @llvm.[[TARGET]].quad.read.across.diagonal.v3f64(<3 x double> %[[#]])
108106
// CHECK: ret <3 x double> %[[RET]]
109107
double3 test_double3(double3 expr) { return QuadReadAcrossDiagonal(expr); }
110108

111-
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x double> @llvm.[[ICF]].quad.read.across.diagonal.v4f64(<4 x double> %[[#]])
109+
// CHECK: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x double> @llvm.[[TARGET]].quad.read.across.diagonal.v4f64(<4 x double> %[[#]])
112110
// CHECK: ret <4 x double> %[[RET]]
113111
double4 test_double4(double4 expr) { return QuadReadAcrossDiagonal(expr); }
114112

115-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]half @llvm.[[ICF]].quad.read.across.diagonal.f16(half %[[#]])
113+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]half @llvm.[[TARGET]].quad.read.across.diagonal.f16(half %[[#]])
116114
// CHECK-NATIVE_HALF: ret half %[[RET]]
117-
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]float @llvm.[[ICF]].quad.read.across.diagonal.f32(float %[[#]])
115+
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]float @llvm.[[TARGET]].quad.read.across.diagonal.f32(float %[[#]])
118116
// CHECK-NO_HALF: ret float %[[RET]]
119117
half test_half(half expr) { return QuadReadAcrossDiagonal(expr); }
120118

121-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x half> @llvm.[[ICF]].quad.read.across.diagonal.v2f16(<2 x half> %[[#]])
119+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x half> @llvm.[[TARGET]].quad.read.across.diagonal.v2f16(<2 x half> %[[#]])
122120
// CHECK-NATIVE_HALF: ret <2 x half> %[[RET]]
123-
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x float> @llvm.[[ICF]].quad.read.across.diagonal.v2f32(<2 x float> %[[#]])
121+
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<2 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v2f32(<2 x float> %[[#]])
124122
// CHECK-NO_HALF: ret <2 x float> %[[RET]]
125123
half2 test_half2(half2 expr) { return QuadReadAcrossDiagonal(expr); }
126124

127-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x half> @llvm.[[ICF]].quad.read.across.diagonal.v3f16(<3 x half> %[[#]])
125+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x half> @llvm.[[TARGET]].quad.read.across.diagonal.v3f16(<3 x half> %[[#]])
128126
// CHECK-NATIVE_HALF: ret <3 x half> %[[RET]]
129-
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x float> @llvm.[[ICF]].quad.read.across.diagonal.v3f32(<3 x float> %[[#]])
127+
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<3 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v3f32(<3 x float> %[[#]])
130128
// CHECK-NO_HALF: ret <3 x float> %[[RET]]
131129
half3 test_half3(half3 expr) { return QuadReadAcrossDiagonal(expr); }
132130

133-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x half> @llvm.[[ICF]].quad.read.across.diagonal.v4f16(<4 x half> %[[#]])
131+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x half> @llvm.[[TARGET]].quad.read.across.diagonal.v4f16(<4 x half> %[[#]])
134132
// CHECK-NATIVE_HALF: ret <4 x half> %[[RET]]
135-
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x float> @llvm.[[ICF]].quad.read.across.diagonal.v4f32(<4 x float> %[[#]])
133+
// CHECK-NO_HALF: %[[RET:.*]] = call reassoc nnan ninf nsz arcp afn [[CC]]<4 x float> @llvm.[[TARGET]].quad.read.across.diagonal.v4f32(<4 x float> %[[#]])
136134
// CHECK-NO_HALF: ret <4 x float> %[[RET]]
137135
half4 test_half4(half4 expr) { return QuadReadAcrossDiagonal(expr); }
138136

139137
#ifdef __HLSL_ENABLE_16_BIT
140-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]i16 @llvm.[[ICF]].quad.read.across.diagonal.i16(i16 %[[#]])
138+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]i16 @llvm.[[TARGET]].quad.read.across.diagonal.i16(i16 %[[#]])
141139
// CHECK-NATIVE_HALF: ret i16 %[[RET]]
142140
int16_t test_int16_t(int16_t expr) { return QuadReadAcrossDiagonal(expr); }
143141

144-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<2 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v2i16(<2 x i16> %[[#]])
142+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<2 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v2i16(<2 x i16> %[[#]])
145143
// CHECK-NATIVE_HALF: ret <2 x i16> %[[RET]]
146144
int16_t2 test_int16_t2(int16_t2 expr) { return QuadReadAcrossDiagonal(expr); }
147145

148-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<3 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v3i16(<3 x i16> %[[#]])
146+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<3 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v3i16(<3 x i16> %[[#]])
149147
// CHECK-NATIVE_HALF: ret <3 x i16> %[[RET]]
150148
int16_t3 test_int16_t3(int16_t3 expr) { return QuadReadAcrossDiagonal(expr); }
151149

152-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<4 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v4i16(<4 x i16> %[[#]])
150+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<4 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v4i16(<4 x i16> %[[#]])
153151
// CHECK-NATIVE_HALF: ret <4 x i16> %[[RET]]
154152
int16_t4 test_int16_t4(int16_t4 expr) { return QuadReadAcrossDiagonal(expr); }
155153

156-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]i16 @llvm.[[ICF]].quad.read.across.diagonal.i16(i16 %[[#]])
154+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]i16 @llvm.[[TARGET]].quad.read.across.diagonal.i16(i16 %[[#]])
157155
// CHECK-NATIVE_HALF: ret i16 %[[RET]]
158156
uint16_t test_uint16_t(uint16_t expr) { return QuadReadAcrossDiagonal(expr); }
159157

160-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<2 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v2i16(<2 x i16> %[[#]])
158+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<2 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v2i16(<2 x i16> %[[#]])
161159
// CHECK-NATIVE_HALF: ret <2 x i16> %[[RET]]
162160
uint16_t2 test_uint16_t2(uint16_t2 expr) { return QuadReadAcrossDiagonal(expr); }
163161

164-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<3 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v3i16(<3 x i16> %[[#]])
162+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<3 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v3i16(<3 x i16> %[[#]])
165163
// CHECK-NATIVE_HALF: ret <3 x i16> %[[RET]]
166164
uint16_t3 test_uint16_t3(uint16_t3 expr) { return QuadReadAcrossDiagonal(expr); }
167165

168-
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<4 x i16> @llvm.[[ICF]].quad.read.across.diagonal.v4i16(<4 x i16> %[[#]])
166+
// CHECK-NATIVE_HALF: %[[RET:.*]] = call [[CC]]<4 x i16> @llvm.[[TARGET]].quad.read.across.diagonal.v4i16(<4 x i16> %[[#]])
169167
// CHECK-NATIVE_HALF: ret <4 x i16> %[[RET]]
170168
uint16_t4 test_uint16_t4(uint16_t4 expr) { return QuadReadAcrossDiagonal(expr); }
171169
#endif

‎llvm/test/CodeGen/DirectX/QuadReadAcrossDiagonal.ll‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ declare i16 @llvm.dx.quad.read.across.diagonal.i16(i16)
5252
declare i32 @llvm.dx.quad.read.across.diagonal.i32(i32)
5353
declare i64 @llvm.dx.quad.read.across.diagonal.i64(i64)
5454

55-
; Test that for vector values, QuadReadAcrossX scalarizes and maps down to the
55+
; Test that for vector values, QuadReadAcrossDiagonal scalarizes and maps down to the
5656
; DirectX op
5757

5858
define noundef <2 x half> @quad_read_across_diagonal_v2half(<2 x half> noundef %expr) {

0 commit comments

Comments
 (0)