xref: /llvm-project/llvm/test/CodeGen/SPIRV/instructions/intrinsics.ll (revision 67d3ef74b31e1517d4f679e754cc2b3041c95901) 
1; RUN: llc -verify-machineinstrs -O0 %s -mtriple=spirv32-unknown-unknown -o - | FileCheck %s
2
3declare float @llvm.fabs.f32(float)
4declare float @llvm.rint.f32(float)
5declare float @llvm.nearbyint.f32(float)
6declare float @llvm.floor.f32(float)
7declare float @llvm.ceil.f32(float)
8declare float @llvm.round.f32(float)
9declare float @llvm.trunc.f32(float)
10declare float @llvm.sqrt.f32(float)
11declare float @llvm.sin.f32(float)
12declare float @llvm.cos.f32(float)
13declare float @llvm.exp2.f32(float)
14declare float @llvm.log.f32(float)
15declare float @llvm.log10.f32(float)
16declare float @llvm.log2.f32(float)
17declare float @llvm.minnum.f32(float, float)
18declare float @llvm.maxnum.f32(float, float)
19declare <2 x half> @llvm.fabs.v2f16(<2 x half>)
20declare <2 x half> @llvm.rint.v2f16(<2 x half>)
21declare <2 x half> @llvm.nearbyint.v2f16(<2 x half>)
22declare <2 x half> @llvm.floor.v2f16(<2 x half>)
23declare <2 x half> @llvm.ceil.v2f16(<2 x half>)
24declare <2 x half> @llvm.round.v2f16(<2 x half>)
25declare <2 x half> @llvm.trunc.v2f16(<2 x half>)
26declare <2 x half> @llvm.sqrt.v2f16(<2 x half>)
27declare <2 x half> @llvm.sin.v2f16(<2 x half>)
28declare <2 x half> @llvm.cos.v2f16(<2 x half>)
29declare <2 x half> @llvm.exp2.v2f16(<2 x half>)
30declare <2 x half> @llvm.log.v2f16(<2 x half>)
31declare <2 x half> @llvm.log10.v2f16(<2 x half>)
32declare <2 x half> @llvm.log2.v2f16(<2 x half>)
33
34; CHECK-DAG: OpName %[[#SCALAR_FABS:]] "scalar_fabs"
35; CHECK-DAG: OpName %[[#SCALAR_RINT:]] "scalar_rint"
36; CHECK-DAG: OpName %[[#SCALAR_NEARBYINT:]] "scalar_nearbyint"
37; CHECK-DAG: OpName %[[#SCALAR_FLOOR:]] "scalar_floor"
38; CHECK-DAG: OpName %[[#SCALAR_CEIL:]] "scalar_ceil"
39; CHECK-DAG: OpName %[[#SCALAR_ROUND:]] "scalar_round"
40; CHECK-DAG: OpName %[[#SCALAR_TRUNC:]] "scalar_trunc"
41; CHECK-DAG: OpName %[[#SCALAR_SQRT:]] "scalar_sqrt"
42; CHECK-DAG: OpName %[[#SCALAR_SIN:]] "scalar_sin"
43; CHECK-DAG: OpName %[[#SCALAR_COS:]] "scalar_cos"
44; CHECK-DAG: OpName %[[#SCALAR_EXP2:]] "scalar_exp2"
45; CHECK-DAG: OpName %[[#SCALAR_LOG:]] "scalar_log"
46; CHECK-DAG: OpName %[[#SCALAR_LOG10:]] "scalar_log10"
47; CHECK-DAG: OpName %[[#SCALAR_LOG2:]] "scalar_log2"
48; CHECK-DAG: OpName %[[#SCALAR_MINNUM:]] "scalar_minnum"
49; CHECK-DAG: OpName %[[#SCALAR_MAXNUM:]] "scalar_maxnum"
50; CHECK-DAG: OpName %[[#VECTOR_FABS:]] "vector_fabs"
51; CHECK-DAG: OpName %[[#VECTOR_RINT:]] "vector_rint"
52; CHECK-DAG: OpName %[[#VECTOR_NEARBYINT:]] "vector_nearbyint"
53; CHECK-DAG: OpName %[[#VECTOR_FLOOR:]] "vector_floor"
54; CHECK-DAG: OpName %[[#VECTOR_CEIL:]] "vector_ceil"
55; CHECK-DAG: OpName %[[#VECTOR_ROUND:]] "vector_round"
56; CHECK-DAG: OpName %[[#VECTOR_TRUNC:]] "vector_trunc"
57; CHECK-DAG: OpName %[[#VECTOR_SQRT:]] "vector_sqrt"
58; CHECK-DAG: OpName %[[#VECTOR_SIN:]] "vector_sin"
59; CHECK-DAG: OpName %[[#VECTOR_COS:]] "vector_cos"
60; CHECK-DAG: OpName %[[#VECTOR_EXP2:]] "vector_exp2"
61; CHECK-DAG: OpName %[[#VECTOR_LOG:]] "vector_log"
62; CHECK-DAG: OpName %[[#VECTOR_LOG10:]] "vector_log10"
63; CHECK-DAG: OpName %[[#VECTOR_LOG2:]] "vector_log2"
64
65; CHECK-DAG: %[[#CLEXT:]] = OpExtInstImport "OpenCL.std"
66
67; CHECK:      %[[#SCALAR_FABS]] = OpFunction
68; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
69; CHECK:      OpLabel
70; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] fabs %[[#A]]
71; CHECK:      OpReturnValue %[[#R]]
72; CHECK-NEXT: OpFunctionEnd
73define float @scalar_fabs(float %a) {
74    %r = call float @llvm.fabs.f32(float %a)
75    ret float %r
76}
77
78; CHECK:      %[[#SCALAR_RINT]] = OpFunction
79; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
80; CHECK:      OpLabel
81; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] rint %[[#A]]
82; CHECK:      OpReturnValue %[[#R]]
83; CHECK-NEXT: OpFunctionEnd
84define float @scalar_rint(float %a) {
85    %r = call float @llvm.rint.f32(float %a)
86    ret float %r
87}
88
89; CHECK:      %[[#SCALAR_NEARBYINT]] = OpFunction
90; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
91; CHECK:      OpLabel
92; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] rint %[[#A]]
93; CHECK:      OpReturnValue %[[#R]]
94; CHECK-NEXT: OpFunctionEnd
95define float @scalar_nearbyint(float %a) {
96    %r = call float @llvm.nearbyint.f32(float %a)
97    ret float %r
98}
99
100; CHECK:      %[[#SCALAR_FLOOR]] = OpFunction
101; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
102; CHECK:      OpLabel
103; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] floor %[[#A]]
104; CHECK:      OpReturnValue %[[#R]]
105; CHECK-NEXT: OpFunctionEnd
106define float @scalar_floor(float %a) {
107    %r = call float @llvm.floor.f32(float %a)
108    ret float %r
109}
110
111; CHECK:      %[[#SCALAR_CEIL]] = OpFunction
112; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
113; CHECK:      OpLabel
114; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] ceil %[[#A]]
115; CHECK:      OpReturnValue %[[#R]]
116; CHECK-NEXT: OpFunctionEnd
117define float @scalar_ceil(float %a) {
118    %r = call float @llvm.ceil.f32(float %a)
119    ret float %r
120}
121
122; CHECK:      %[[#SCALAR_ROUND]] = OpFunction
123; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
124; CHECK:      OpLabel
125; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] round %[[#A]]
126; CHECK:      OpReturnValue %[[#R]]
127; CHECK-NEXT: OpFunctionEnd
128define float @scalar_round(float %a) {
129    %r = call float @llvm.round.f32(float %a)
130    ret float %r
131}
132
133; CHECK:      %[[#SCALAR_TRUNC]] = OpFunction
134; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
135; CHECK:      OpLabel
136; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] trunc %[[#A]]
137; CHECK:      OpReturnValue %[[#R]]
138; CHECK-NEXT: OpFunctionEnd
139define float @scalar_trunc(float %a) {
140    %r = call float @llvm.trunc.f32(float %a)
141    ret float %r
142}
143
144; CHECK:      %[[#SCALAR_SQRT]] = OpFunction
145; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
146; CHECK:      OpLabel
147; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] sqrt %[[#A]]
148; CHECK:      OpReturnValue %[[#R]]
149; CHECK-NEXT: OpFunctionEnd
150define float @scalar_sqrt(float %a) {
151    %r = call float @llvm.sqrt.f32(float %a)
152    ret float %r
153}
154
155; CHECK:      %[[#SCALAR_SIN]] = OpFunction
156; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
157; CHECK:      OpLabel
158; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] sin %[[#A]]
159; CHECK:      OpReturnValue %[[#R]]
160; CHECK-NEXT: OpFunctionEnd
161define float @scalar_sin(float %a) {
162    %r = call float @llvm.sin.f32(float %a)
163    ret float %r
164}
165
166; CHECK:      %[[#SCALAR_COS]] = OpFunction
167; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
168; CHECK:      OpLabel
169; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] cos %[[#A]]
170; CHECK:      OpReturnValue %[[#R]]
171; CHECK-NEXT: OpFunctionEnd
172define float @scalar_cos(float %a) {
173    %r = call float @llvm.cos.f32(float %a)
174    ret float %r
175}
176
177; CHECK:      %[[#SCALAR_EXP2]] = OpFunction
178; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
179; CHECK:      OpLabel
180; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] exp2 %[[#A]]
181; CHECK:      OpReturnValue %[[#R]]
182; CHECK-NEXT: OpFunctionEnd
183define float @scalar_exp2(float %a) {
184    %r = call float @llvm.exp2.f32(float %a)
185    ret float %r
186}
187
188; CHECK:      %[[#SCALAR_LOG]] = OpFunction
189; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
190; CHECK:      OpLabel
191; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log %[[#A]]
192; CHECK:      OpReturnValue %[[#R]]
193; CHECK-NEXT: OpFunctionEnd
194define float @scalar_log(float %a) {
195    %r = call float @llvm.log.f32(float %a)
196    ret float %r
197}
198
199; CHECK:      %[[#SCALAR_LOG10]] = OpFunction
200; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
201; CHECK:      OpLabel
202; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log10 %[[#A]]
203; CHECK:      OpReturnValue %[[#R]]
204; CHECK-NEXT: OpFunctionEnd
205define float @scalar_log10(float %a) {
206    %r = call float @llvm.log10.f32(float %a)
207    ret float %r
208}
209
210; CHECK:      %[[#SCALAR_LOG2]] = OpFunction
211; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
212; CHECK:      OpLabel
213; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log2 %[[#A]]
214; CHECK:      OpReturnValue %[[#R]]
215; CHECK-NEXT: OpFunctionEnd
216define float @scalar_log2(float %a) {
217    %r = call float @llvm.log2.f32(float %a)
218    ret float %r
219}
220
221; CHECK:      %[[#VECTOR_FABS]] = OpFunction
222; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
223; CHECK:      OpLabel
224; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] fabs %[[#A]]
225; CHECK:      OpReturnValue %[[#R]]
226; CHECK-NEXT: OpFunctionEnd
227define <2 x half> @vector_fabs(<2 x half> %a) {
228    %r = call <2 x half> @llvm.fabs.v2f16(<2 x half> %a)
229    ret <2 x half> %r
230}
231
232; CHECK:      %[[#VECTOR_RINT]] = OpFunction
233; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
234; CHECK:      OpLabel
235; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] rint %[[#A]]
236; CHECK:      OpReturnValue %[[#R]]
237; CHECK-NEXT: OpFunctionEnd
238define <2 x half> @vector_rint(<2 x half> %a) {
239    %r = call <2 x half> @llvm.rint.v2f16(<2 x half> %a)
240    ret <2 x half> %r
241}
242
243; CHECK:      %[[#VECTOR_NEARBYINT]] = OpFunction
244; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
245; CHECK:      OpLabel
246; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] rint %[[#A]]
247; CHECK:      OpReturnValue %[[#R]]
248; CHECK-NEXT: OpFunctionEnd
249define <2 x half> @vector_nearbyint(<2 x half> %a) {
250    %r = call <2 x half> @llvm.nearbyint.v2f16(<2 x half> %a)
251    ret <2 x half> %r
252}
253
254; CHECK:      %[[#VECTOR_FLOOR]] = OpFunction
255; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
256; CHECK:      OpLabel
257; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] floor %[[#A]]
258; CHECK:      OpReturnValue %[[#R]]
259; CHECK-NEXT: OpFunctionEnd
260define <2 x half> @vector_floor(<2 x half> %a) {
261    %r = call <2 x half> @llvm.floor.v2f16(<2 x half> %a)
262    ret <2 x half> %r
263}
264
265; CHECK:      %[[#VECTOR_CEIL]] = OpFunction
266; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
267; CHECK:      OpLabel
268; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] ceil %[[#A]]
269; CHECK:      OpReturnValue %[[#R]]
270; CHECK-NEXT: OpFunctionEnd
271define <2 x half> @vector_ceil(<2 x half> %a) {
272    %r = call <2 x half> @llvm.ceil.v2f16(<2 x half> %a)
273    ret <2 x half> %r
274}
275
276; CHECK:      %[[#VECTOR_ROUND]] = OpFunction
277; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
278; CHECK:      OpLabel
279; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] round %[[#A]]
280; CHECK:      OpReturnValue %[[#R]]
281; CHECK-NEXT: OpFunctionEnd
282define <2 x half> @vector_round(<2 x half> %a) {
283    %r = call <2 x half> @llvm.round.v2f16(<2 x half> %a)
284    ret <2 x half> %r
285}
286
287; CHECK:      %[[#VECTOR_TRUNC]] = OpFunction
288; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
289; CHECK:      OpLabel
290; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] trunc %[[#A]]
291; CHECK:      OpReturnValue %[[#R]]
292; CHECK-NEXT: OpFunctionEnd
293define <2 x half> @vector_trunc(<2 x half> %a) {
294    %r = call <2 x half> @llvm.trunc.v2f16(<2 x half> %a)
295    ret <2 x half> %r
296}
297
298; CHECK:      %[[#VECTOR_SQRT]] = OpFunction
299; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
300; CHECK:      OpLabel
301; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] sqrt %[[#A]]
302; CHECK:      OpReturnValue %[[#R]]
303; CHECK-NEXT: OpFunctionEnd
304define <2 x half> @vector_sqrt(<2 x half> %a) {
305    %r = call <2 x half> @llvm.sqrt.v2f16(<2 x half> %a)
306    ret <2 x half> %r
307}
308
309; CHECK:      %[[#VECTOR_SIN]] = OpFunction
310; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
311; CHECK:      OpLabel
312; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] sin %[[#A]]
313; CHECK:      OpReturnValue %[[#R]]
314; CHECK-NEXT: OpFunctionEnd
315define <2 x half> @vector_sin(<2 x half> %a) {
316    %r = call <2 x half> @llvm.sin.v2f16(<2 x half> %a)
317    ret <2 x half> %r
318}
319
320; CHECK:      %[[#VECTOR_COS]] = OpFunction
321; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
322; CHECK:      OpLabel
323; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] cos %[[#A]]
324; CHECK:      OpReturnValue %[[#R]]
325; CHECK-NEXT: OpFunctionEnd
326define <2 x half> @vector_cos(<2 x half> %a) {
327    %r = call <2 x half> @llvm.cos.v2f16(<2 x half> %a)
328    ret <2 x half> %r
329}
330
331; CHECK:      %[[#VECTOR_EXP2]] = OpFunction
332; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
333; CHECK:      OpLabel
334; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] exp2 %[[#A]]
335; CHECK:      OpReturnValue %[[#R]]
336; CHECK-NEXT: OpFunctionEnd
337define <2 x half> @vector_exp2(<2 x half> %a) {
338    %r = call <2 x half> @llvm.exp2.v2f16(<2 x half> %a)
339    ret <2 x half> %r
340}
341
342; CHECK:      %[[#VECTOR_LOG]] = OpFunction
343; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
344; CHECK:      OpLabel
345; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log %[[#A]]
346; CHECK:      OpReturnValue %[[#R]]
347; CHECK-NEXT: OpFunctionEnd
348define <2 x half> @vector_log(<2 x half> %a) {
349    %r = call <2 x half> @llvm.log.v2f16(<2 x half> %a)
350    ret <2 x half> %r
351}
352
353; CHECK:      %[[#VECTOR_LOG10]] = OpFunction
354; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
355; CHECK:      OpLabel
356; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log10 %[[#A]]
357; CHECK:      OpReturnValue %[[#R]]
358; CHECK-NEXT: OpFunctionEnd
359define <2 x half> @vector_log10(<2 x half> %a) {
360    %r = call <2 x half> @llvm.log10.v2f16(<2 x half> %a)
361    ret <2 x half> %r
362}
363
364; CHECK:      %[[#VECTOR_LOG2]] = OpFunction
365; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
366; CHECK:      OpLabel
367; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] log2 %[[#A]]
368; CHECK:      OpReturnValue %[[#R]]
369; CHECK-NEXT: OpFunctionEnd
370define <2 x half> @vector_log2(<2 x half> %a) {
371    %r = call <2 x half> @llvm.log2.v2f16(<2 x half> %a)
372    ret <2 x half> %r
373}
374
375; CHECK:      %[[#SCALAR_MINNUM]] = OpFunction
376; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
377; CHECK-NEXT: %[[#B:]] = OpFunctionParameter
378; CHECK:      OpLabel
379; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] fmin %[[#A]] %[[#B]]
380; CHECK:      OpReturnValue %[[#R]]
381; CHECK-NEXT: OpFunctionEnd
382define float @scalar_minnum(float %A, float %B) {
383  %r = call float @llvm.minnum.f32(float %A, float %B)
384  ret float %r
385}
386
387; CHECK:      %[[#SCALAR_MAXNUM]] = OpFunction
388; CHECK-NEXT: %[[#A:]] = OpFunctionParameter
389; CHECK-NEXT: %[[#B:]] = OpFunctionParameter
390; CHECK:      OpLabel
391; CHECK:      %[[#R:]] = OpExtInst %[[#]] %[[#CLEXT]] fmax %[[#A]] %[[#B]]
392; CHECK:      OpReturnValue %[[#R]]
393; CHECK-NEXT: OpFunctionEnd
394define float @scalar_maxnum(float %A, float %B) {
395  %r = call float @llvm.maxnum.f32(float %A, float %B)
396  ret float %r
397}
398