Gitiles
Code Review Sign In
review.blissroms.org / platform_art / 0c5b18edd1308975804ccf29a02a130a7b6f7fa7 / . / test / 570-checker-select / src / Main.java
blob: 59741d6d05577679efbe937fc814fe91c89f7760 [file] [log] [blame]
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17public class Main {
18
19 /// CHECK-START: int Main.BoolCond_IntVarVar(boolean, int, int) register (after)
20 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
21
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]22 /// CHECK-START-ARM64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
23 /// CHECK: Select
24 /// CHECK-NEXT: cmp
25 /// CHECK-NEXT: csel ne
26
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]27 /// CHECK-START-X86_64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
28 /// CHECK: <<Cond:z\d+>> ParameterValue
29 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
30 /// CHECK: cmovnz/ne
31
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]32 /// CHECK-START-X86: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after)
33 /// CHECK: <<Cond:z\d+>> ParameterValue
34 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
35 /// CHECK: cmovnz/ne
36
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]37 public static int BoolCond_IntVarVar(boolean cond, int x, int y) {
38 return cond ? x : y;
39 }
40
41 /// CHECK-START: int Main.BoolCond_IntVarCst(boolean, int) register (after)
42 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
43
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]44 /// CHECK-START-ARM64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
45 /// CHECK: Select
46 /// CHECK-NEXT: cmp
47 /// CHECK-NEXT: csinc ne
48
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]49 /// CHECK-START-X86_64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
50 /// CHECK: <<Cond:z\d+>> ParameterValue
51 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
52 /// CHECK: cmovnz/ne
53
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]54 /// CHECK-START-X86: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after)
55 /// CHECK: <<Cond:z\d+>> ParameterValue
56 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
57 /// CHECK: cmovnz/ne
58
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]59 public static int BoolCond_IntVarCst(boolean cond, int x) {
60 return cond ? x : 1;
61 }
62
63 /// CHECK-START: int Main.BoolCond_IntCstVar(boolean, int) register (after)
64 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}]
65
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]66 /// CHECK-START-ARM64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
67 /// CHECK: Select
68 /// CHECK-NEXT: cmp
69 /// CHECK-NEXT: csinc eq
70
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]71 /// CHECK-START-X86_64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
72 /// CHECK: <<Cond:z\d+>> ParameterValue
73 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
74 /// CHECK: cmovnz/ne
75
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]76 /// CHECK-START-X86: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after)
77 /// CHECK: <<Cond:z\d+>> ParameterValue
78 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
79 /// CHECK: cmovnz/ne
80
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]81 public static int BoolCond_IntCstVar(boolean cond, int y) {
82 return cond ? 1 : y;
83 }
84
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]85 /// CHECK-START: long Main.BoolCond_LongVarVar(boolean, long, long) register (after)
86 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
87
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]88 /// CHECK-START-ARM64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
89 /// CHECK: Select
90 /// CHECK-NEXT: cmp
91 /// CHECK-NEXT: csel ne
92
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]93 /// CHECK-START-X86_64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
94 /// CHECK: <<Cond:z\d+>> ParameterValue
95 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
96 /// CHECK: cmovnz/neq
97
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]98 /// CHECK-START-X86: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after)
99 /// CHECK: <<Cond:z\d+>> ParameterValue
100 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
101 /// CHECK: cmovnz/ne
102 /// CHECK-NEXT: cmovnz/ne
103
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]104 public static long BoolCond_LongVarVar(boolean cond, long x, long y) {
105 return cond ? x : y;
106 }
107
108 /// CHECK-START: long Main.BoolCond_LongVarCst(boolean, long) register (after)
109 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
110
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]111 /// CHECK-START-ARM64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
112 /// CHECK: Select
113 /// CHECK-NEXT: cmp
114 /// CHECK-NEXT: csinc ne
115
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]116 /// CHECK-START-X86_64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
117 /// CHECK: <<Cond:z\d+>> ParameterValue
118 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
119 /// CHECK: cmovnz/neq
120
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]121 /// CHECK-START-X86: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after)
122 /// CHECK: <<Cond:z\d+>> ParameterValue
123 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
124 /// CHECK: cmovnz/ne
125 /// CHECK-NEXT: cmovnz/ne
126
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]127 public static long BoolCond_LongVarCst(boolean cond, long x) {
128 return cond ? x : 1L;
129 }
130
131 /// CHECK-START: long Main.BoolCond_LongCstVar(boolean, long) register (after)
132 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}]
133
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]134 /// CHECK-START-ARM64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
135 /// CHECK: Select
136 /// CHECK-NEXT: cmp
137 /// CHECK-NEXT: csinc eq
138
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]139 /// CHECK-START-X86_64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
140 /// CHECK: <<Cond:z\d+>> ParameterValue
141 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
142 /// CHECK: cmovnz/neq
143
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]144 /// CHECK-START-X86: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after)
145 /// CHECK: <<Cond:z\d+>> ParameterValue
146 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
147 /// CHECK: cmovnz/ne
148 /// CHECK-NEXT: cmovnz/ne
149
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]150 public static long BoolCond_LongCstVar(boolean cond, long y) {
151 return cond ? 1L : y;
152 }
153
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]154 /// CHECK-START: float Main.BoolCond_FloatVarVar(boolean, float, float) register (after)
155 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
156
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]157 /// CHECK-START-ARM64: float Main.BoolCond_FloatVarVar(boolean, float, float) disassembly (after)
158 /// CHECK: Select
159 /// CHECK-NEXT: cmp
160 /// CHECK-NEXT: fcsel ne
161
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]162 public static float BoolCond_FloatVarVar(boolean cond, float x, float y) {
163 return cond ? x : y;
164 }
165
166 /// CHECK-START: float Main.BoolCond_FloatVarCst(boolean, float) register (after)
167 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
168
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]169 /// CHECK-START-ARM64: float Main.BoolCond_FloatVarCst(boolean, float) disassembly (after)
170 /// CHECK: Select
171 /// CHECK-NEXT: cmp
172 /// CHECK-NEXT: fcsel ne
173
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]174 public static float BoolCond_FloatVarCst(boolean cond, float x) {
175 return cond ? x : 1.0f;
176 }
177
178 /// CHECK-START: float Main.BoolCond_FloatCstVar(boolean, float) register (after)
179 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}]
180
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]181 /// CHECK-START-ARM64: float Main.BoolCond_FloatCstVar(boolean, float) disassembly (after)
182 /// CHECK: Select
183 /// CHECK-NEXT: cmp
184 /// CHECK-NEXT: fcsel ne
185
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]186 public static float BoolCond_FloatCstVar(boolean cond, float y) {
187 return cond ? 1.0f : y;
188 }
189
190 /// CHECK-START: int Main.IntNonmatCond_IntVarVar(int, int, int, int) register (after)
191 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
192 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
193
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]194 /// CHECK-START-ARM64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
195 /// CHECK: Select
196 /// CHECK-NEXT: cmp
197 /// CHECK-NEXT: csel le
198
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]199 /// CHECK-START-X86_64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
200 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
201 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
202 /// CHECK: cmovle/ng
203
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]204 /// CHECK-START-X86: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after)
205 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
206 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
207 /// CHECK: cmovle/ng
208
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]209 public static int IntNonmatCond_IntVarVar(int a, int b, int x, int y) {
210 return a > b ? x : y;
211 }
212
213 /// CHECK-START: int Main.IntMatCond_IntVarVar(int, int, int, int) register (after)
214 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
215 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},{{z\d+}}]
216 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
217
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]218 /// CHECK-START-ARM64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
219 /// CHECK: LessThanOrEqual
220 /// CHECK-NEXT: cmp
221 /// CHECK-NEXT: cset le
222 /// CHECK: Select
223 /// CHECK-NEXT: csel le
224
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]225 /// CHECK-START-X86_64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
226 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
227 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
228 /// CHECK: cmovle/ng
229
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]230 /// CHECK-START-X86: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after)
231 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
232 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>]
233 /// CHECK: cmovle/ng
234
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]235 public static int IntMatCond_IntVarVar(int a, int b, int x, int y) {
236 int result = (a > b ? x : y);
237 return result + (a > b ? 0 : 1);
238 }
239
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]240 /// CHECK-START: long Main.IntNonmatCond_LongVarVar(int, int, long, long) register (after)
241 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
242 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
243
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]244 /// CHECK-START-ARM64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
245 /// CHECK: Select
246 /// CHECK-NEXT: cmp
247 /// CHECK-NEXT: csel le
248
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]249 /// CHECK-START-X86_64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
250 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
251 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
252 /// CHECK: cmovle/ngq
253
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]254 /// CHECK-START-X86: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after)
255 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
256 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>]
257 /// CHECK: cmovle/ng
258 /// CHECK-NEXT: cmovle/ng
259
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]260 public static long IntNonmatCond_LongVarVar(int a, int b, long x, long y) {
261 return a > b ? x : y;
262 }
263
264 /// CHECK-START: long Main.IntMatCond_LongVarVar(int, int, long, long) register (after)
265 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
266 /// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
267 /// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
268 /// CHECK: Add [<<Sel2>>,<<Sel1>>]
269
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]270 /// CHECK-START-ARM64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
271 /// CHECK: LessThanOrEqual
272 /// CHECK-NEXT: cmp
273 /// CHECK-NEXT: cset le
274 /// CHECK: Select
275 /// CHECK-NEXT: csel le
276
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]277 /// CHECK-START-X86_64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
278 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
279 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
280 /// CHECK: cmovle/ngq
281 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
282 /// CHECK: cmovnz/neq
283
Mark Mendell0c5b18e2016-02-06 13:58:35 -0500[diff] [blame^]284 /// CHECK-START-X86: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after)
285 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}]
286 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
287 /// CHECK-NEXT: cmovle/ng
288 /// CHECK-NEXT: cmovle/ng
289 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
290 /// CHECK: cmovnz/ne
291 /// CHECK-NEXT: cmovnz/ne
292
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]293 public static long IntMatCond_LongVarVar(int a, int b, long x, long y) {
294 long result = (a > b ? x : y);
295 return result + (a > b ? 0L : 1L);
296 }
297
298 /// CHECK-START: long Main.LongNonmatCond_LongVarVar(long, long, long, long) register (after)
299 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
300 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
301
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]302 /// CHECK-START-ARM64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
303 /// CHECK: Select
304 /// CHECK-NEXT: cmp
305 /// CHECK-NEXT: csel le
306
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]307 /// CHECK-START-X86_64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after)
308 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
309 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
310 /// CHECK: cmovle/ngq
311
312 public static long LongNonmatCond_LongVarVar(long a, long b, long x, long y) {
313 return a > b ? x : y;
314 }
315
316 /// CHECK-START: long Main.LongMatCond_LongVarVar(long, long, long, long) register (after)
317 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
318 /// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
319 /// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>]
320 /// CHECK: Add [<<Sel2>>,<<Sel1>>]
321
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]322 /// CHECK-START-ARM64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
323 /// CHECK: LessThanOrEqual
324 /// CHECK-NEXT: cmp
325 /// CHECK-NEXT: cset le
326 /// CHECK: Select
327 /// CHECK-NEXT: csel le
328
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]329 /// CHECK-START-X86_64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after)
330 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}]
331 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
332 /// CHECK: cmovle/ngq
333 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>]
334 /// CHECK: cmovnz/neq
335
336 public static long LongMatCond_LongVarVar(long a, long b, long x, long y) {
337 long result = (a > b ? x : y);
338 return result + (a > b ? 0L : 1L);
339 }
340
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]341 /// CHECK-START: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) register (after)
342 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}]
343 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
344
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]345 /// CHECK-START-ARM64: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
346 /// CHECK: LessThanOrEqual
347 /// CHECK: Select
348 /// CHECK-NEXT: fcmp
349 /// CHECK-NEXT: csel le
350
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]351 public static int FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y) {
352 return a > b ? x : y;
353 }
354
355 /// CHECK-START: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) register (after)
356 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
357 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>]
358
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]359 /// CHECK-START-ARM64: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) disassembly (after)
360 /// CHECK: GreaterThanOrEqual
361 /// CHECK: Select
362 /// CHECK-NEXT: fcmp
363 /// CHECK-NEXT: csel hs
364
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]365 public static int FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y) {
366 return a < b ? x : y;
367 }
368
369 /// CHECK-START: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) register (after)
370 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
371 /// CHECK-NEXT: Select [{{f\d+}},{{f\d+}},<<Cond>>]
372
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]373 /// CHECK-START-ARM64: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) disassembly (after)
374 /// CHECK: GreaterThanOrEqual
375 /// CHECK: Select
376 /// CHECK-NEXT: fcmp
377 /// CHECK-NEXT: fcsel hs
378
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]379 public static float FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y) {
380 return a < b ? x : y;
381 }
382
383 /// CHECK-START: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) register (after)
384 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}]
385 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>]
386 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
387
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]388 /// CHECK-START-ARM64: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) disassembly (after)
389 /// CHECK: LessThanOrEqual
390 /// CHECK-NEXT: fcmp
391 /// CHECK-NEXT: cset le
392 /// CHECK: Select
393 /// CHECK-NEXT: csel le
394
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]395 public static int FloatLtMatCond_IntVarVar(float a, float b, int x, int y) {
396 int result = (a > b ? x : y);
397 return result + (a > b ? 0 : 1);
398 }
399
400 /// CHECK-START: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) register (after)
401 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}]
402 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>]
403 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>]
404
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]405 /// CHECK-START-ARM64: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) disassembly (after)
406 /// CHECK: GreaterThanOrEqual
407 /// CHECK-NEXT: fcmp
408 /// CHECK-NEXT: cset hs
409 /// CHECK: Select
410 /// CHECK-NEXT: csel hs
411
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]412 public static int FloatGtMatCond_IntVarVar(float a, float b, int x, int y) {
413 int result = (a < b ? x : y);
414 return result + (a < b ? 0 : 1);
415 }
416
417 /// CHECK-START: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) register (after)
418 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual
419 /// CHECK-NEXT: <<Sel:f\d+>> Select [{{f\d+}},{{f\d+}},<<Cond>>]
420 /// CHECK-NEXT: TypeConversion [<<Cond>>]
421
David Brazdilc0b601b2016-02-08 14:20:45 +0000[diff] [blame]422 /// CHECK-START-ARM64: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) disassembly (after)
423 /// CHECK: GreaterThanOrEqual
424 /// CHECK-NEXT: fcmp
425 /// CHECK-NEXT: cset hs
426 /// CHECK: Select
427 /// CHECK-NEXT: fcsel hs
428
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]429 public static float FloatGtMatCond_FloatVarVar(float a, float b, float x, float y) {
430 float result = (a < b ? x : y);
431 return result + (a < b ? 0 : 1);
432 }
433
434 public static void assertEqual(int expected, int actual) {
435 if (expected != actual) {
436 throw new Error("Assertion failed: " + expected + " != " + actual);
437 }
438 }
439
440 public static void assertEqual(float expected, float actual) {
441 if (expected != actual) {
442 throw new Error("Assertion failed: " + expected + " != " + actual);
443 }
444 }
445
446 public static void main(String[] args) {
447 assertEqual(5, BoolCond_IntVarVar(true, 5, 7));
448 assertEqual(7, BoolCond_IntVarVar(false, 5, 7));
449 assertEqual(5, BoolCond_IntVarCst(true, 5));
450 assertEqual(1, BoolCond_IntVarCst(false, 5));
451 assertEqual(1, BoolCond_IntCstVar(true, 7));
452 assertEqual(7, BoolCond_IntCstVar(false, 7));
453
Mark Mendell7c0b44f2016-02-01 10:08:35 -0500[diff] [blame]454 assertEqual(5L, BoolCond_LongVarVar(true, 5L, 7L));
455 assertEqual(7L, BoolCond_LongVarVar(false, 5L, 7L));
456 assertEqual(5L, BoolCond_LongVarCst(true, 5L));
457 assertEqual(1L, BoolCond_LongVarCst(false, 5L));
458 assertEqual(1L, BoolCond_LongCstVar(true, 7L));
459 assertEqual(7L, BoolCond_LongCstVar(false, 7L));
460
David Brazdilfb502702016-02-02 10:09:14 +0000[diff] [blame]461 assertEqual(5, BoolCond_FloatVarVar(true, 5, 7));
462 assertEqual(7, BoolCond_FloatVarVar(false, 5, 7));
463 assertEqual(5, BoolCond_FloatVarCst(true, 5));
464 assertEqual(1, BoolCond_FloatVarCst(false, 5));
465 assertEqual(1, BoolCond_FloatCstVar(true, 7));
466 assertEqual(7, BoolCond_FloatCstVar(false, 7));
467
468 assertEqual(5, IntNonmatCond_IntVarVar(3, 2, 5, 7));
469 assertEqual(7, IntNonmatCond_IntVarVar(2, 3, 5, 7));
470 assertEqual(5, IntMatCond_IntVarVar(3, 2, 5, 7));
471 assertEqual(8, IntMatCond_IntVarVar(2, 3, 5, 7));
472
473 assertEqual(5, FloatLtNonmatCond_IntVarVar(3, 2, 5, 7));
474 assertEqual(7, FloatLtNonmatCond_IntVarVar(2, 3, 5, 7));
475 assertEqual(7, FloatLtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
476 assertEqual(7, FloatLtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
477
478 assertEqual(5, FloatGtNonmatCond_IntVarVar(2, 3, 5, 7));
479 assertEqual(7, FloatGtNonmatCond_IntVarVar(3, 2, 5, 7));
480 assertEqual(7, FloatGtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7));
481 assertEqual(7, FloatGtNonmatCond_IntVarVar(2, Float.NaN, 5, 7));
482
483 assertEqual(5, FloatGtNonmatCond_FloatVarVar(2, 3, 5, 7));
484 assertEqual(7, FloatGtNonmatCond_FloatVarVar(3, 2, 5, 7));
485 assertEqual(7, FloatGtNonmatCond_FloatVarVar(Float.NaN, 2, 5, 7));
486 assertEqual(7, FloatGtNonmatCond_FloatVarVar(2, Float.NaN, 5, 7));
487
488 assertEqual(5, FloatLtMatCond_IntVarVar(3, 2, 5, 7));
489 assertEqual(8, FloatLtMatCond_IntVarVar(2, 3, 5, 7));
490 assertEqual(8, FloatLtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
491 assertEqual(8, FloatLtMatCond_IntVarVar(2, Float.NaN, 5, 7));
492
493 assertEqual(5, FloatGtMatCond_IntVarVar(2, 3, 5, 7));
494 assertEqual(8, FloatGtMatCond_IntVarVar(3, 2, 5, 7));
495 assertEqual(8, FloatGtMatCond_IntVarVar(Float.NaN, 2, 5, 7));
496 assertEqual(8, FloatGtMatCond_IntVarVar(2, Float.NaN, 5, 7));
497
498 assertEqual(5, FloatGtMatCond_FloatVarVar(2, 3, 5, 7));
499 assertEqual(8, FloatGtMatCond_FloatVarVar(3, 2, 5, 7));
500 assertEqual(8, FloatGtMatCond_FloatVarVar(Float.NaN, 2, 5, 7));
501 assertEqual(8, FloatGtMatCond_FloatVarVar(2, Float.NaN, 5, 7));
502 }
503}