1; RUN: llc %s -o - | FileCheck %s
2
3target triple = "spirv32-unknown-unknown"
4
5; CHECK-DAG: OpName [[UEQ:%.*]] "test_ueq"
6; CHECK-DAG: OpName [[OEQ:%.*]] "test_oeq"
7; CHECK-DAG: OpName [[UNE:%.*]] "test_une"
8; CHECK-DAG: OpName [[ONE:%.*]] "test_one"
9; CHECK-DAG: OpName [[ULT:%.*]] "test_ult"
10; CHECK-DAG: OpName [[OLT:%.*]] "test_olt"
11; CHECK-DAG: OpName [[ULE:%.*]] "test_ule"
12; CHECK-DAG: OpName [[OLE:%.*]] "test_ole"
13; CHECK-DAG: OpName [[UGT:%.*]] "test_ugt"
14; CHECK-DAG: OpName [[OGT:%.*]] "test_ogt"
15; CHECK-DAG: OpName [[UGE:%.*]] "test_uge"
16; CHECK-DAG: OpName [[OGE:%.*]] "test_oge"
17; CHECK-DAG: OpName [[UNO:%.*]] "test_uno"
18; CHECK-DAG: OpName [[ORD:%.*]] "test_ord"
19
20; CHECK-DAG: OpName [[v3UEQ:%.*]] "test_v3_ueq"
21; CHECK-DAG: OpName [[v3OEQ:%.*]] "test_v3_oeq"
22; CHECK-DAG: OpName [[v3UNE:%.*]] "test_v3_une"
23; CHECK-DAG: OpName [[v3ONE:%.*]] "test_v3_one"
24; CHECK-DAG: OpName [[v3ULT:%.*]] "test_v3_ult"
25; CHECK-DAG: OpName [[v3OLT:%.*]] "test_v3_olt"
26; CHECK-DAG: OpName [[v3ULE:%.*]] "test_v3_ule"
27; CHECK-DAG: OpName [[v3OLE:%.*]] "test_v3_ole"
28; CHECK-DAG: OpName [[v3UGT:%.*]] "test_v3_ugt"
29; CHECK-DAG: OpName [[v3OGT:%.*]] "test_v3_ogt"
30; CHECK-DAG: OpName [[v3UGE:%.*]] "test_v3_uge"
31; CHECK-DAG: OpName [[v3OGE:%.*]] "test_v3_oge"
32; CHECK-DAG: OpName [[v3UNO:%.*]] "test_v3_uno"
33; CHECK-DAG: OpName [[v3ORD:%.*]] "test_v3_ord"
34
35; CHECK: [[UEQ]] = OpFunction
36; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
37; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
38; CHECK-NEXT: OpLabel
39; CHECK-NEXT: [[R:%.*]] = OpFUnordEqual {{%.+}} [[A]] [[B]]
40; CHECK-NEXT: OpReturnValue [[R]]
41; CHECK-NEXT: OpFunctionEnd
42define i1 @test_ueq(float %a, float %b) {
43  %r = fcmp ueq float %a, %b
44  ret i1 %r
45}
46
47; CHECK: [[OEQ]] = OpFunction
48; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
49; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
50; CHECK-NEXT: OpLabel
51; CHECK-NEXT: [[R:%.*]] = OpFOrdEqual {{%.+}} [[A]] [[B]]
52; CHECK-NEXT: OpReturnValue [[R]]
53; CHECK-NEXT: OpFunctionEnd
54define i1 @test_oeq(float %a, float %b) {
55  %r = fcmp oeq float %a, %b
56  ret i1 %r
57}
58
59; CHECK: [[UNE]] = OpFunction
60; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
61; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
62; CHECK-NEXT: OpLabel
63; CHECK-NEXT: [[R:%.*]] = OpFUnordNotEqual {{%.+}} [[A]] [[B]]
64; CHECK-NEXT: OpReturnValue [[R]]
65; CHECK-NEXT: OpFunctionEnd
66define i1 @test_une(float %a, float %b) {
67  %r = fcmp une float %a, %b
68  ret i1 %r
69}
70
71; CHECK: [[ONE]] = OpFunction
72; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
73; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
74; CHECK-NEXT: OpLabel
75; CHECK-NEXT: [[R:%.*]] = OpFOrdNotEqual {{%.+}} [[A]] [[B]]
76; CHECK-NEXT: OpReturnValue [[R]]
77; CHECK-NEXT: OpFunctionEnd
78define i1 @test_one(float %a, float %b) {
79  %r = fcmp one float %a, %b
80  ret i1 %r
81}
82
83; CHECK: [[ULT]] = OpFunction
84; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
85; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
86; CHECK-NEXT: OpLabel
87; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThan {{%.+}} [[A]] [[B]]
88; CHECK-NEXT: OpReturnValue [[R]]
89; CHECK-NEXT: OpFunctionEnd
90define i1 @test_ult(float %a, float %b) {
91  %r = fcmp ult float %a, %b
92  ret i1 %r
93}
94
95; CHECK: [[OLT]] = OpFunction
96; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
97; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
98; CHECK-NEXT: OpLabel
99; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThan {{%.+}} [[A]] [[B]]
100; CHECK-NEXT: OpReturnValue [[R]]
101; CHECK-NEXT: OpFunctionEnd
102define i1 @test_olt(float %a, float %b) {
103  %r = fcmp olt float %a, %b
104  ret i1 %r
105}
106
107; CHECK: [[ULE]] = OpFunction
108; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
109; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
110; CHECK-NEXT: OpLabel
111; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThanEqual {{%.+}} [[A]] [[B]]
112; CHECK-NEXT: OpReturnValue [[R]]
113; CHECK-NEXT: OpFunctionEnd
114define i1 @test_ule(float %a, float %b) {
115  %r = fcmp ule float %a, %b
116  ret i1 %r
117}
118
119; CHECK: [[OLE]] = OpFunction
120; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
121; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
122; CHECK-NEXT: OpLabel
123; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThanEqual {{%.+}} [[A]] [[B]]
124; CHECK-NEXT: OpReturnValue [[R]]
125; CHECK-NEXT: OpFunctionEnd
126define i1 @test_ole(float %a, float %b) {
127  %r = fcmp ole float %a, %b
128  ret i1 %r
129}
130
131; CHECK: [[UGT]] = OpFunction
132; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
133; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
134; CHECK-NEXT: OpLabel
135; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThan {{%.+}} [[A]] [[B]]
136; CHECK-NEXT: OpReturnValue [[R]]
137; CHECK-NEXT: OpFunctionEnd
138define i1 @test_ugt(float %a, float %b) {
139  %r = fcmp ugt float %a, %b
140  ret i1 %r
141}
142
143; CHECK: [[OGT]] = OpFunction
144; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
145; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
146; CHECK-NEXT: OpLabel
147; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThan {{%.+}} [[A]] [[B]]
148; CHECK-NEXT: OpReturnValue [[R]]
149; CHECK-NEXT: OpFunctionEnd
150define i1 @test_ogt(float %a, float %b) {
151  %r = fcmp ogt float %a, %b
152  ret i1 %r
153}
154
155; CHECK: [[UGE]] = OpFunction
156; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
157; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
158; CHECK-NEXT: OpLabel
159; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThanEqual {{%.+}} [[A]] [[B]]
160; CHECK-NEXT: OpReturnValue [[R]]
161; CHECK-NEXT: OpFunctionEnd
162define i1 @test_uge(float %a, float %b) {
163  %r = fcmp uge float %a, %b
164  ret i1 %r
165}
166
167; CHECK: [[OGE]] = OpFunction
168; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
169; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
170; CHECK-NEXT: OpLabel
171; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThanEqual {{%.+}} [[A]] [[B]]
172; CHECK-NEXT: OpReturnValue [[R]]
173; CHECK-NEXT: OpFunctionEnd
174define i1 @test_oge(float %a, float %b) {
175  %r = fcmp oge float %a, %b
176  ret i1 %r
177}
178
179; CHECK: [[ORD]] = OpFunction
180; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
181; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
182; CHECK-NEXT: OpLabel
183; CHECK-NEXT: [[R:%.*]] = OpOrdered {{%.+}} [[A]] [[B]]
184; CHECK-NEXT: OpReturnValue [[R]]
185; CHECK-NEXT: OpFunctionEnd
186define i1 @test_ord(float %a, float %b) {
187  %r = fcmp ord float %a, %b
188  ret i1 %r
189}
190
191; CHECK: [[UNO]] = OpFunction
192; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
193; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
194; CHECK-NEXT: OpLabel
195; CHECK-NEXT: [[R:%.*]] = OpUnordered {{%.+}} [[A]] [[B]]
196; CHECK-NEXT: OpReturnValue [[R]]
197; CHECK-NEXT: OpFunctionEnd
198define i1 @test_uno(float %a, float %b) {
199  %r = fcmp uno float %a, %b
200  ret i1 %r
201}
202
203; CHECK: [[v3UEQ]] = OpFunction
204; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
205; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
206; CHECK-NEXT: OpLabel
207; CHECK-NEXT: [[R:%.*]] = OpFUnordEqual {{%.+}} [[A]] [[B]]
208; CHECK-NEXT: OpReturnValue [[R]]
209; CHECK-NEXT: OpFunctionEnd
210define <3 x i1> @test_v3_ueq(<3 x float> %a, <3 x float> %b) {
211  %r = fcmp ueq <3 x float> %a, %b
212  ret <3 x i1> %r
213}
214
215; CHECK: [[v3OEQ]] = OpFunction
216; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
217; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
218; CHECK-NEXT: OpLabel
219; CHECK-NEXT: [[R:%.*]] = OpFOrdEqual {{%.+}} [[A]] [[B]]
220; CHECK-NEXT: OpReturnValue [[R]]
221; CHECK-NEXT: OpFunctionEnd
222define <3 x i1> @test_v3_oeq(<3 x float> %a, <3 x float> %b) {
223  %r = fcmp oeq <3 x float> %a, %b
224  ret <3 x i1> %r
225}
226
227; CHECK: [[v3UNE]] = OpFunction
228; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
229; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
230; CHECK-NEXT: OpLabel
231; CHECK-NEXT: [[R:%.*]] = OpFUnordNotEqual {{%.+}} [[A]] [[B]]
232; CHECK-NEXT: OpReturnValue [[R]]
233; CHECK-NEXT: OpFunctionEnd
234define <3 x i1> @test_v3_une(<3 x float> %a, <3 x float> %b) {
235  %r = fcmp une <3 x float> %a, %b
236  ret <3 x i1> %r
237}
238
239; CHECK: [[v3ONE]] = OpFunction
240; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
241; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
242; CHECK-NEXT: OpLabel
243; CHECK-NEXT: [[R:%.*]] = OpFOrdNotEqual {{%.+}} [[A]] [[B]]
244; CHECK-NEXT: OpReturnValue [[R]]
245; CHECK-NEXT: OpFunctionEnd
246define <3 x i1> @test_v3_one(<3 x float> %a, <3 x float> %b) {
247  %r = fcmp one <3 x float> %a, %b
248  ret <3 x i1> %r
249}
250
251; CHECK: [[v3ULT]] = OpFunction
252; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
253; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
254; CHECK-NEXT: OpLabel
255; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThan {{%.+}} [[A]] [[B]]
256; CHECK-NEXT: OpReturnValue [[R]]
257; CHECK-NEXT: OpFunctionEnd
258define <3 x i1> @test_v3_ult(<3 x float> %a, <3 x float> %b) {
259  %r = fcmp ult <3 x float> %a, %b
260  ret <3 x i1> %r
261}
262
263; CHECK: [[v3OLT]] = OpFunction
264; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
265; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
266; CHECK-NEXT: OpLabel
267; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThan {{%.+}} [[A]] [[B]]
268; CHECK-NEXT: OpReturnValue [[R]]
269; CHECK-NEXT: OpFunctionEnd
270define <3 x i1> @test_v3_olt(<3 x float> %a, <3 x float> %b) {
271  %r = fcmp olt <3 x float> %a, %b
272  ret <3 x i1> %r
273}
274
275; CHECK: [[v3ULE]] = OpFunction
276; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
277; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
278; CHECK-NEXT: OpLabel
279; CHECK-NEXT: [[R:%.*]] = OpFUnordLessThanEqual {{%.+}} [[A]] [[B]]
280; CHECK-NEXT: OpReturnValue [[R]]
281; CHECK-NEXT: OpFunctionEnd
282define <3 x i1> @test_v3_ule(<3 x float> %a, <3 x float> %b) {
283  %r = fcmp ule <3 x float> %a, %b
284  ret <3 x i1> %r
285}
286
287; CHECK: [[v3OLE]] = OpFunction
288; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
289; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
290; CHECK-NEXT: OpLabel
291; CHECK-NEXT: [[R:%.*]] = OpFOrdLessThanEqual {{%.+}} [[A]] [[B]]
292; CHECK-NEXT: OpReturnValue [[R]]
293; CHECK-NEXT: OpFunctionEnd
294define <3 x i1> @test_v3_ole(<3 x float> %a, <3 x float> %b) {
295  %r = fcmp ole <3 x float> %a, %b
296  ret <3 x i1> %r
297}
298
299; CHECK: [[v3UGT]] = OpFunction
300; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
301; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
302; CHECK-NEXT: OpLabel
303; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThan {{%.+}} [[A]] [[B]]
304; CHECK-NEXT: OpReturnValue [[R]]
305; CHECK-NEXT: OpFunctionEnd
306define <3 x i1> @test_v3_ugt(<3 x float> %a, <3 x float> %b) {
307  %r = fcmp ugt <3 x float> %a, %b
308  ret <3 x i1> %r
309}
310
311; CHECK: [[v3OGT]] = OpFunction
312; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
313; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
314; CHECK-NEXT: OpLabel
315; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThan {{%.+}} [[A]] [[B]]
316; CHECK-NEXT: OpReturnValue [[R]]
317; CHECK-NEXT: OpFunctionEnd
318define <3 x i1> @test_v3_ogt(<3 x float> %a, <3 x float> %b) {
319  %r = fcmp ogt <3 x float> %a, %b
320  ret <3 x i1> %r
321}
322
323; CHECK: [[v3UGE]] = OpFunction
324; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
325; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
326; CHECK-NEXT: OpLabel
327; CHECK-NEXT: [[R:%.*]] = OpFUnordGreaterThanEqual {{%.+}} [[A]] [[B]]
328; CHECK-NEXT: OpReturnValue [[R]]
329; CHECK-NEXT: OpFunctionEnd
330define <3 x i1> @test_v3_uge(<3 x float> %a, <3 x float> %b) {
331  %r = fcmp uge <3 x float> %a, %b
332  ret <3 x i1> %r
333}
334
335; CHECK: [[v3OGE]] = OpFunction
336; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
337; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
338; CHECK-NEXT: OpLabel
339; CHECK-NEXT: [[R:%.*]] = OpFOrdGreaterThanEqual {{%.+}} [[A]] [[B]]
340; CHECK-NEXT: OpReturnValue [[R]]
341; CHECK-NEXT: OpFunctionEnd
342define <3 x i1> @test_v3_oge(<3 x float> %a, <3 x float> %b) {
343  %r = fcmp oge <3 x float> %a, %b
344  ret <3 x i1> %r
345}
346
347; CHECK: [[v3ORD]] = OpFunction
348; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
349; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
350; CHECK-NEXT: OpLabel
351; CHECK-NEXT: [[R:%.*]] = OpOrdered {{%.+}} [[A]] [[B]]
352; CHECK-NEXT: OpReturnValue [[R]]
353; CHECK-NEXT: OpFunctionEnd
354define <3 x i1> @test_v3_ord(<3 x float> %a, <3 x float> %b) {
355  %r = fcmp ord <3 x float> %a, %b
356  ret <3 x i1> %r
357}
358
359; CHECK: [[v3UNO]] = OpFunction
360; CHECK-NEXT: [[A:%.*]] = OpFunctionParameter
361; CHECK-NEXT: [[B:%.*]] = OpFunctionParameter
362; CHECK-NEXT: OpLabel
363; CHECK-NEXT: [[R:%.*]] = OpUnordered {{%.+}} [[A]] [[B]]
364; CHECK-NEXT: OpReturnValue [[R]]
365; CHECK-NEXT: OpFunctionEnd
366define <3 x i1> @test_v3_uno(<3 x float> %a, <3 x float> %b) {
367  %r = fcmp uno <3 x float> %a, %b
368  ret <3 x i1> %r
369}
370