1// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
2
3//===----------------------------------------------------------------------===//
4// spv.IEqual
5//===----------------------------------------------------------------------===//
6
7// CHECK-LABEL: @i_equal_scalar
8spv.func @i_equal_scalar(%arg0: i32, %arg1: i32) "None" {
9  // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : i32
10  %0 = spv.IEqual %arg0, %arg1 : i32
11  spv.Return
12}
13
14// CHECK-LABEL: @i_equal_vector
15spv.func @i_equal_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" {
16  // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : vector<4xi64>
17  %0 = spv.IEqual %arg0, %arg1 : vector<4xi64>
18  spv.Return
19}
20
21//===----------------------------------------------------------------------===//
22// spv.INotEqual
23//===----------------------------------------------------------------------===//
24
25// CHECK-LABEL: @i_not_equal_scalar
26spv.func @i_not_equal_scalar(%arg0: i64, %arg1: i64) "None" {
27  // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : i64
28  %0 = spv.INotEqual %arg0, %arg1 : i64
29  spv.Return
30}
31
32// CHECK-LABEL: @i_not_equal_vector
33spv.func @i_not_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
34  // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : vector<2xi64>
35  %0 = spv.INotEqual %arg0, %arg1 : vector<2xi64>
36  spv.Return
37}
38
39//===----------------------------------------------------------------------===//
40// spv.SGreaterThanEqual
41//===----------------------------------------------------------------------===//
42
43// CHECK-LABEL: @s_greater_than_equal_scalar
44spv.func @s_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
45  // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : i64
46  %0 = spv.SGreaterThanEqual %arg0, %arg1 : i64
47  spv.Return
48}
49
50// CHECK-LABEL: @s_greater_than_equal_vector
51spv.func @s_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
52  // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : vector<2xi64>
53  %0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<2xi64>
54  spv.Return
55}
56
57//===----------------------------------------------------------------------===//
58// spv.SGreaterThan
59//===----------------------------------------------------------------------===//
60
61// CHECK-LABEL: @s_greater_than_scalar
62spv.func @s_greater_than_scalar(%arg0: i64, %arg1: i64) "None" {
63  // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : i64
64  %0 = spv.SGreaterThan %arg0, %arg1 : i64
65  spv.Return
66}
67
68// CHECK-LABEL: @s_greater_than_vector
69spv.func @s_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
70  // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : vector<2xi64>
71  %0 = spv.SGreaterThan %arg0, %arg1 : vector<2xi64>
72  spv.Return
73}
74
75//===----------------------------------------------------------------------===//
76// spv.SLessThanEqual
77//===----------------------------------------------------------------------===//
78
79// CHECK-LABEL: @s_less_than_equal_scalar
80spv.func @s_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
81  // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : i64
82  %0 = spv.SLessThanEqual %arg0, %arg1 : i64
83  spv.Return
84}
85
86// CHECK-LABEL: @s_less_than_equal_vector
87spv.func @s_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
88  // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : vector<2xi64>
89  %0 = spv.SLessThanEqual %arg0, %arg1 : vector<2xi64>
90  spv.Return
91}
92
93//===----------------------------------------------------------------------===//
94// spv.SLessThan
95//===----------------------------------------------------------------------===//
96
97// CHECK-LABEL: @s_less_than_scalar
98spv.func @s_less_than_scalar(%arg0: i64, %arg1: i64) "None" {
99  // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : i64
100  %0 = spv.SLessThan %arg0, %arg1 : i64
101  spv.Return
102}
103
104// CHECK-LABEL: @s_less_than_vector
105spv.func @s_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
106  // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : vector<2xi64>
107  %0 = spv.SLessThan %arg0, %arg1 : vector<2xi64>
108  spv.Return
109}
110
111//===----------------------------------------------------------------------===//
112// spv.UGreaterThanEqual
113//===----------------------------------------------------------------------===//
114
115// CHECK-LABEL: @u_greater_than_equal_scalar
116spv.func @u_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
117  // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : i64
118  %0 = spv.UGreaterThanEqual %arg0, %arg1 : i64
119  spv.Return
120}
121
122// CHECK-LABEL: @u_greater_than_equal_vector
123spv.func @u_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
124  // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : vector<2xi64>
125  %0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<2xi64>
126  spv.Return
127}
128
129//===----------------------------------------------------------------------===//
130// spv.UGreaterThan
131//===----------------------------------------------------------------------===//
132
133// CHECK-LABEL: @u_greater_than_scalar
134spv.func @u_greater_than_scalar(%arg0: i64, %arg1: i64) "None" {
135  // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : i64
136  %0 = spv.UGreaterThan %arg0, %arg1 : i64
137  spv.Return
138}
139
140// CHECK-LABEL: @u_greater_than_vector
141spv.func @u_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
142  // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : vector<2xi64>
143  %0 = spv.UGreaterThan %arg0, %arg1 : vector<2xi64>
144  spv.Return
145}
146
147//===----------------------------------------------------------------------===//
148// spv.ULessThanEqual
149//===----------------------------------------------------------------------===//
150
151// CHECK-LABEL: @u_less_than_equal_scalar
152spv.func @u_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
153  // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : i64
154  %0 = spv.ULessThanEqual %arg0, %arg1 : i64
155  spv.Return
156}
157
158// CHECK-LABEL: @u_less_than_equal_vector
159spv.func @u_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
160  // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : vector<2xi64>
161  %0 = spv.ULessThanEqual %arg0, %arg1 : vector<2xi64>
162  spv.Return
163}
164
165//===----------------------------------------------------------------------===//
166// spv.ULessThan
167//===----------------------------------------------------------------------===//
168
169// CHECK-LABEL: @u_less_than_scalar
170spv.func @u_less_than_scalar(%arg0: i64, %arg1: i64) "None" {
171  // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : i64
172  %0 = spv.ULessThan %arg0, %arg1 : i64
173  spv.Return
174}
175
176// CHECK-LABEL: @u_less_than_vector
177spv.func @u_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
178  // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : vector<2xi64>
179  %0 = spv.ULessThan %arg0, %arg1 : vector<2xi64>
180  spv.Return
181}
182
183//===----------------------------------------------------------------------===//
184// spv.FOrdEqual
185//===----------------------------------------------------------------------===//
186
187// CHECK-LABEL: @f_ord_equal_scalar
188spv.func @f_ord_equal_scalar(%arg0: f32, %arg1: f32) "None" {
189  // CHECK: llvm.fcmp "oeq" %{{.*}}, %{{.*}} : f32
190  %0 = spv.FOrdEqual %arg0, %arg1 : f32
191  spv.Return
192}
193
194// CHECK-LABEL: @f_ord_equal_vector
195spv.func @f_ord_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" {
196  // CHECK: llvm.fcmp "oeq" %{{.*}}, %{{.*}} : vector<4xf64>
197  %0 = spv.FOrdEqual %arg0, %arg1 : vector<4xf64>
198  spv.Return
199}
200
201//===----------------------------------------------------------------------===//
202// spv.FOrdGreaterThanEqual
203//===----------------------------------------------------------------------===//
204
205// CHECK-LABEL: @f_ord_greater_than_equal_scalar
206spv.func @f_ord_greater_than_equal_scalar(%arg0: f64, %arg1: f64) "None" {
207  // CHECK: llvm.fcmp "oge" %{{.*}}, %{{.*}} : f64
208  %0 = spv.FOrdGreaterThanEqual %arg0, %arg1 : f64
209  spv.Return
210}
211
212// CHECK-LABEL: @f_ord_greater_than_equal_vector
213spv.func @f_ord_greater_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
214  // CHECK: llvm.fcmp "oge" %{{.*}}, %{{.*}} : vector<2xf64>
215  %0 = spv.FOrdGreaterThanEqual %arg0, %arg1 : vector<2xf64>
216  spv.Return
217}
218
219//===----------------------------------------------------------------------===//
220// spv.FOrdGreaterThan
221//===----------------------------------------------------------------------===//
222
223// CHECK-LABEL: @f_ord_greater_than_scalar
224spv.func @f_ord_greater_than_scalar(%arg0: f64, %arg1: f64) "None" {
225  // CHECK: llvm.fcmp "ogt" %{{.*}}, %{{.*}} : f64
226  %0 = spv.FOrdGreaterThan %arg0, %arg1 : f64
227  spv.Return
228}
229
230// CHECK-LABEL: @f_ord_greater_than_vector
231spv.func @f_ord_greater_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
232  // CHECK: llvm.fcmp "ogt" %{{.*}}, %{{.*}} : vector<2xf64>
233  %0 = spv.FOrdGreaterThan %arg0, %arg1 : vector<2xf64>
234  spv.Return
235}
236
237//===----------------------------------------------------------------------===//
238// spv.FOrdLessThan
239//===----------------------------------------------------------------------===//
240
241// CHECK-LABEL: @f_ord_less_than_scalar
242spv.func @f_ord_less_than_scalar(%arg0: f64, %arg1: f64) "None" {
243  // CHECK: llvm.fcmp "olt" %{{.*}}, %{{.*}} : f64
244  %0 = spv.FOrdLessThan %arg0, %arg1 : f64
245  spv.Return
246}
247
248// CHECK-LABEL: @f_ord_less_than_vector
249spv.func @f_ord_less_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
250  // CHECK: llvm.fcmp "olt" %{{.*}}, %{{.*}} : vector<2xf64>
251  %0 = spv.FOrdLessThan %arg0, %arg1 : vector<2xf64>
252  spv.Return
253}
254
255//===----------------------------------------------------------------------===//
256// spv.FOrdLessThanEqual
257//===----------------------------------------------------------------------===//
258
259// CHECK-LABEL: @f_ord_less_than_equal_scalar
260spv.func @f_ord_less_than_equal_scalar(%arg0: f64, %arg1: f64) "None" {
261  // CHECK: llvm.fcmp "ole" %{{.*}}, %{{.*}} : f64
262  %0 = spv.FOrdLessThanEqual %arg0, %arg1 : f64
263  spv.Return
264}
265
266// CHECK-LABEL: @f_ord_less_than_equal_vector
267spv.func @f_ord_less_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
268  // CHECK: llvm.fcmp "ole" %{{.*}}, %{{.*}} : vector<2xf64>
269  %0 = spv.FOrdLessThanEqual %arg0, %arg1 : vector<2xf64>
270  spv.Return
271}
272
273//===----------------------------------------------------------------------===//
274// spv.FOrdNotEqual
275//===----------------------------------------------------------------------===//
276
277// CHECK-LABEL: @f_ord_not_equal_scalar
278spv.func @f_ord_not_equal_scalar(%arg0: f32, %arg1: f32) "None" {
279  // CHECK: llvm.fcmp "one" %{{.*}}, %{{.*}} : f32
280  %0 = spv.FOrdNotEqual %arg0, %arg1 : f32
281  spv.Return
282}
283
284// CHECK-LABEL: @f_ord_not_equal_vector
285spv.func @f_ord_not_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" {
286  // CHECK: llvm.fcmp "one" %{{.*}}, %{{.*}} : vector<4xf64>
287  %0 = spv.FOrdNotEqual %arg0, %arg1 : vector<4xf64>
288  spv.Return
289}
290
291//===----------------------------------------------------------------------===//
292// spv.FUnordEqual
293//===----------------------------------------------------------------------===//
294
295// CHECK-LABEL: @f_unord_equal_scalar
296spv.func @f_unord_equal_scalar(%arg0: f32, %arg1: f32) "None" {
297  // CHECK: llvm.fcmp "ueq" %{{.*}}, %{{.*}} : f32
298  %0 = spv.FUnordEqual %arg0, %arg1 : f32
299  spv.Return
300}
301
302// CHECK-LABEL: @f_unord_equal_vector
303spv.func @f_unord_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" {
304  // CHECK: llvm.fcmp "ueq" %{{.*}}, %{{.*}} : vector<4xf64>
305  %0 = spv.FUnordEqual %arg0, %arg1 : vector<4xf64>
306  spv.Return
307}
308
309//===----------------------------------------------------------------------===//
310// spv.FUnordGreaterThanEqual
311//===----------------------------------------------------------------------===//
312
313// CHECK-LABEL: @f_unord_greater_than_equal_scalar
314spv.func @f_unord_greater_than_equal_scalar(%arg0: f64, %arg1: f64) "None" {
315  // CHECK: llvm.fcmp "uge" %{{.*}}, %{{.*}} : f64
316  %0 = spv.FUnordGreaterThanEqual %arg0, %arg1 : f64
317  spv.Return
318}
319
320// CHECK-LABEL: @f_unord_greater_than_equal_vector
321spv.func @f_unord_greater_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
322  // CHECK: llvm.fcmp "uge" %{{.*}}, %{{.*}} : vector<2xf64>
323  %0 = spv.FUnordGreaterThanEqual %arg0, %arg1 : vector<2xf64>
324  spv.Return
325}
326
327//===----------------------------------------------------------------------===//
328// spv.FUnordGreaterThan
329//===----------------------------------------------------------------------===//
330
331// CHECK-LABEL: @f_unord_greater_than_scalar
332spv.func @f_unord_greater_than_scalar(%arg0: f64, %arg1: f64) "None" {
333  // CHECK: llvm.fcmp "ugt" %{{.*}}, %{{.*}} : f64
334  %0 = spv.FUnordGreaterThan %arg0, %arg1 : f64
335  spv.Return
336}
337
338// CHECK-LABEL: @f_unord_greater_than_vector
339spv.func @f_unord_greater_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
340  // CHECK: llvm.fcmp "ugt" %{{.*}}, %{{.*}} : vector<2xf64>
341  %0 = spv.FUnordGreaterThan %arg0, %arg1 : vector<2xf64>
342  spv.Return
343}
344
345//===----------------------------------------------------------------------===//
346// spv.FUnordLessThan
347//===----------------------------------------------------------------------===//
348
349// CHECK-LABEL: @f_unord_less_than_scalar
350spv.func @f_unord_less_than_scalar(%arg0: f64, %arg1: f64) "None" {
351  // CHECK: llvm.fcmp "ult" %{{.*}}, %{{.*}} : f64
352  %0 = spv.FUnordLessThan %arg0, %arg1 : f64
353  spv.Return
354}
355
356// CHECK-LABEL: @f_unord_less_than_vector
357spv.func @f_unord_less_than_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
358  // CHECK: llvm.fcmp "ult" %{{.*}}, %{{.*}} : vector<2xf64>
359  %0 = spv.FUnordLessThan %arg0, %arg1 : vector<2xf64>
360  spv.Return
361}
362
363//===----------------------------------------------------------------------===//
364// spv.FUnordLessThanEqual
365//===----------------------------------------------------------------------===//
366
367// CHECK-LABEL: @f_unord_less_than_equal_scalar
368spv.func @f_unord_less_than_equal_scalar(%arg0: f64, %arg1: f64) "None" {
369  // CHECK: llvm.fcmp "ule" %{{.*}}, %{{.*}} : f64
370  %0 = spv.FUnordLessThanEqual %arg0, %arg1 : f64
371  spv.Return
372}
373
374// CHECK-LABEL: @f_unord_less_than_equal_vector
375spv.func @f_unord_less_than_equal_vector(%arg0: vector<2xf64>, %arg1: vector<2xf64>) "None" {
376  // CHECK: llvm.fcmp "ule" %{{.*}}, %{{.*}} : vector<2xf64>
377  %0 = spv.FUnordLessThanEqual %arg0, %arg1 : vector<2xf64>
378  spv.Return
379}
380
381//===----------------------------------------------------------------------===//
382// spv.FUnordNotEqual
383//===----------------------------------------------------------------------===//
384
385// CHECK-LABEL: @f_unord_not_equal_scalar
386spv.func @f_unord_not_equal_scalar(%arg0: f32, %arg1: f32) "None" {
387  // CHECK: llvm.fcmp "une" %{{.*}}, %{{.*}} : f32
388  %0 = spv.FUnordNotEqual %arg0, %arg1 : f32
389  spv.Return
390}
391
392// CHECK-LABEL: @f_unord_not_equal_vector
393spv.func @f_unord_not_equal_vector(%arg0: vector<4xf64>, %arg1: vector<4xf64>) "None" {
394  // CHECK: llvm.fcmp "une" %{{.*}}, %{{.*}} : vector<4xf64>
395  %0 = spv.FUnordNotEqual %arg0, %arg1 : vector<4xf64>
396  spv.Return
397}
398