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 17 public class Main { 18 19 static boolean doThrow = false; 20 21 /// CHECK-START: int Main.BoolCond_IntVarVar(boolean, int, int) register (after) 22 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}] 23 24 /// CHECK-START-ARM64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after) 25 /// CHECK: Select 26 /// CHECK-NEXT: cmp 27 /// CHECK-NEXT: csel ne 28 29 /// CHECK-START-X86_64: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after) 30 /// CHECK: <<Cond:z\d+>> ParameterValue 31 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 32 /// CHECK: cmovnz/ne 33 34 /// CHECK-START-X86: int Main.BoolCond_IntVarVar(boolean, int, int) disassembly (after) 35 /// CHECK: <<Cond:z\d+>> ParameterValue 36 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 37 /// CHECK: cmovnz/ne 38 BoolCond_IntVarVar(boolean cond, int x, int y)39 public static int BoolCond_IntVarVar(boolean cond, int x, int y) { 40 if (doThrow) { 41 // Try defeating inlining. 42 throw new Error(); 43 } 44 return cond ? x : y; 45 } 46 47 /// CHECK-START: int Main.BoolCond_IntVarCst(boolean, int) register (after) 48 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}] 49 50 /// CHECK-START-ARM64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after) 51 /// CHECK: Select 52 /// CHECK-NEXT: cmp 53 /// CHECK-NEXT: csinc ne 54 55 /// CHECK-START-X86_64: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after) 56 /// CHECK: <<Cond:z\d+>> ParameterValue 57 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 58 /// CHECK: cmovnz/ne 59 60 /// CHECK-START-X86: int Main.BoolCond_IntVarCst(boolean, int) disassembly (after) 61 /// CHECK: <<Cond:z\d+>> ParameterValue 62 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 63 /// CHECK: cmovnz/ne 64 BoolCond_IntVarCst(boolean cond, int x)65 public static int BoolCond_IntVarCst(boolean cond, int x) { 66 if (doThrow) { 67 // Try defeating inlining. 68 throw new Error(); 69 } 70 return cond ? x : 1; 71 } 72 73 /// CHECK-START: int Main.BoolCond_IntCstVar(boolean, int) register (after) 74 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}] 75 76 /// CHECK-START-ARM64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after) 77 /// CHECK: Select 78 /// CHECK-NEXT: cmp 79 /// CHECK-NEXT: csinc eq 80 81 /// CHECK-START-X86_64: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after) 82 /// CHECK: <<Cond:z\d+>> ParameterValue 83 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 84 /// CHECK: cmovnz/ne 85 86 /// CHECK-START-X86: int Main.BoolCond_IntCstVar(boolean, int) disassembly (after) 87 /// CHECK: <<Cond:z\d+>> ParameterValue 88 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 89 /// CHECK: cmovnz/ne 90 BoolCond_IntCstVar(boolean cond, int y)91 public static int BoolCond_IntCstVar(boolean cond, int y) { 92 if (doThrow) { 93 // Try defeating inlining. 94 throw new Error(); 95 } 96 return cond ? 1 : y; 97 } 98 99 /// CHECK-START: long Main.BoolCond_LongVarVar(boolean, long, long) register (after) 100 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}] 101 102 /// CHECK-START-ARM64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after) 103 /// CHECK: Select 104 /// CHECK-NEXT: cmp 105 /// CHECK-NEXT: csel ne 106 107 /// CHECK-START-X86_64: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after) 108 /// CHECK: <<Cond:z\d+>> ParameterValue 109 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 110 /// CHECK: cmovnz/neq 111 112 /// CHECK-START-X86: long Main.BoolCond_LongVarVar(boolean, long, long) disassembly (after) 113 /// CHECK: <<Cond:z\d+>> ParameterValue 114 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 115 /// CHECK: cmovnz/ne 116 /// CHECK-NEXT: cmovnz/ne 117 BoolCond_LongVarVar(boolean cond, long x, long y)118 public static long BoolCond_LongVarVar(boolean cond, long x, long y) { 119 if (doThrow) { 120 // Try defeating inlining. 121 throw new Error(); 122 } 123 return cond ? x : y; 124 } 125 126 /// CHECK-START: long Main.BoolCond_LongVarCst(boolean, long) register (after) 127 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}] 128 129 /// CHECK-START-ARM64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after) 130 /// CHECK: Select 131 /// CHECK-NEXT: cmp 132 /// CHECK-NEXT: csinc ne 133 134 /// CHECK-START-X86_64: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after) 135 /// CHECK: <<Cond:z\d+>> ParameterValue 136 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 137 /// CHECK: cmovnz/neq 138 139 /// CHECK-START-X86: long Main.BoolCond_LongVarCst(boolean, long) disassembly (after) 140 /// CHECK: <<Cond:z\d+>> ParameterValue 141 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 142 /// CHECK: cmovnz/ne 143 /// CHECK-NEXT: cmovnz/ne 144 BoolCond_LongVarCst(boolean cond, long x)145 public static long BoolCond_LongVarCst(boolean cond, long x) { 146 if (doThrow) { 147 // Try defeating inlining. 148 throw new Error(); 149 } 150 return cond ? x : 1L; 151 } 152 153 /// CHECK-START: long Main.BoolCond_LongCstVar(boolean, long) register (after) 154 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}] 155 156 /// CHECK-START-ARM64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after) 157 /// CHECK: Select 158 /// CHECK-NEXT: cmp 159 /// CHECK-NEXT: csinc eq 160 161 /// CHECK-START-X86_64: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after) 162 /// CHECK: <<Cond:z\d+>> ParameterValue 163 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 164 /// CHECK: cmovnz/neq 165 166 /// CHECK-START-X86: long Main.BoolCond_LongCstVar(boolean, long) disassembly (after) 167 /// CHECK: <<Cond:z\d+>> ParameterValue 168 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 169 /// CHECK: cmovnz/ne 170 /// CHECK-NEXT: cmovnz/ne 171 BoolCond_LongCstVar(boolean cond, long y)172 public static long BoolCond_LongCstVar(boolean cond, long y) { 173 if (doThrow) { 174 // Try defeating inlining. 175 throw new Error(); 176 } 177 return cond ? 1L : y; 178 } 179 180 /// CHECK-START: float Main.BoolCond_FloatVarVar(boolean, float, float) register (after) 181 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}] 182 183 /// CHECK-START-ARM64: float Main.BoolCond_FloatVarVar(boolean, float, float) disassembly (after) 184 /// CHECK: Select 185 /// CHECK-NEXT: cmp 186 /// CHECK-NEXT: fcsel ne 187 BoolCond_FloatVarVar(boolean cond, float x, float y)188 public static float BoolCond_FloatVarVar(boolean cond, float x, float y) { 189 if (doThrow) { 190 // Try defeating inlining. 191 throw new Error(); 192 } 193 return cond ? x : y; 194 } 195 196 /// CHECK-START: float Main.BoolCond_FloatVarCst(boolean, float) register (after) 197 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}] 198 199 /// CHECK-START-ARM64: float Main.BoolCond_FloatVarCst(boolean, float) disassembly (after) 200 /// CHECK: Select 201 /// CHECK-NEXT: cmp 202 /// CHECK-NEXT: fcsel ne 203 BoolCond_FloatVarCst(boolean cond, float x)204 public static float BoolCond_FloatVarCst(boolean cond, float x) { 205 if (doThrow) { 206 // Try defeating inlining. 207 throw new Error(); 208 } 209 return cond ? x : 1.0f; 210 } 211 212 /// CHECK-START: float Main.BoolCond_FloatCstVar(boolean, float) register (after) 213 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}] 214 215 /// CHECK-START-ARM64: float Main.BoolCond_FloatCstVar(boolean, float) disassembly (after) 216 /// CHECK: Select 217 /// CHECK-NEXT: cmp 218 /// CHECK-NEXT: fcsel ne 219 BoolCond_FloatCstVar(boolean cond, float y)220 public static float BoolCond_FloatCstVar(boolean cond, float y) { 221 if (doThrow) { 222 // Try defeating inlining. 223 throw new Error(); 224 } 225 return cond ? 1.0f : y; 226 } 227 228 /// CHECK-START: int Main.IntNonmatCond_IntVarVar(int, int, int, int) register (after) 229 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 230 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>] 231 232 /// CHECK-START-ARM64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after) 233 /// CHECK: Select 234 /// CHECK-NEXT: cmp 235 /// CHECK-NEXT: csel le 236 237 /// CHECK-START-X86_64: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after) 238 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 239 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>] 240 /// CHECK: cmovle/ng 241 242 /// CHECK-START-X86: int Main.IntNonmatCond_IntVarVar(int, int, int, int) disassembly (after) 243 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 244 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>] 245 /// CHECK: cmovle/ng 246 IntNonmatCond_IntVarVar(int a, int b, int x, int y)247 public static int IntNonmatCond_IntVarVar(int a, int b, int x, int y) { 248 if (doThrow) { 249 // Try defeating inlining. 250 throw new Error(); 251 } 252 return a > b ? x : y; 253 } 254 255 /// CHECK-START: int Main.IntMatCond_IntVarVar(int, int, int, int) register (after) 256 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 257 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},{{z\d+}}] 258 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>] 259 260 /// CHECK-START-ARM64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after) 261 /// CHECK: LessThanOrEqual 262 /// CHECK-NEXT: cmp 263 /// CHECK-NEXT: cset le 264 /// CHECK: Select 265 /// CHECK-NEXT: csel le 266 267 /// CHECK-START-X86_64: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after) 268 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 269 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 270 /// CHECK: cmovle/ng 271 272 /// CHECK-START-X86: int Main.IntMatCond_IntVarVar(int, int, int, int) disassembly (after) 273 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 274 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 275 /// CHECK: cmovle/ng 276 IntMatCond_IntVarVar(int a, int b, int x, int y)277 public static int IntMatCond_IntVarVar(int a, int b, int x, int y) { 278 if (doThrow) { 279 // Try defeating inlining. 280 throw new Error(); 281 } 282 int result = (a > b ? x : y); 283 return result + (a > b ? 0 : 1); 284 } 285 286 /// CHECK-START: long Main.IntNonmatCond_LongVarVar(int, int, long, long) register (after) 287 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 288 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>] 289 290 /// CHECK-START-ARM64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after) 291 /// CHECK: Select 292 /// CHECK-NEXT: cmp 293 /// CHECK-NEXT: csel le 294 295 /// CHECK-START-X86_64: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after) 296 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 297 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>] 298 /// CHECK: cmovle/ngq 299 300 /// CHECK-START-X86: long Main.IntNonmatCond_LongVarVar(int, int, long, long) disassembly (after) 301 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 302 /// CHECK-NEXT: Select [{{j\d+}},{{j\d+}},<<Cond>>] 303 /// CHECK: cmovle/ng 304 /// CHECK-NEXT: cmovle/ng 305 IntNonmatCond_LongVarVar(int a, int b, long x, long y)306 public static long IntNonmatCond_LongVarVar(int a, int b, long x, long y) { 307 if (doThrow) { 308 // Try defeating inlining. 309 throw new Error(); 310 } 311 return a > b ? x : y; 312 } 313 314 /// CHECK-START: long Main.IntMatCond_LongVarVar(int, int, long, long) register (after) 315 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 316 /// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>] 317 /// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>] 318 /// CHECK: Add [<<Sel2>>,<<Sel1>>] 319 320 /// CHECK-START-ARM64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after) 321 /// CHECK: LessThanOrEqual 322 /// CHECK-NEXT: cmp 323 /// CHECK-NEXT: cset le 324 /// CHECK: Select 325 /// CHECK-NEXT: csel le 326 327 /// CHECK-START-X86_64: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after) 328 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 329 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 330 /// CHECK: cmovle/ngq 331 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 332 /// CHECK: cmovnz/neq 333 334 /// CHECK-START-X86: long Main.IntMatCond_LongVarVar(int, int, long, long) disassembly (after) 335 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{i\d+}},{{i\d+}}] 336 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 337 /// CHECK-NEXT: cmovle/ng 338 /// CHECK-NEXT: cmovle/ng 339 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 340 /// CHECK: cmovnz/ne 341 /// CHECK-NEXT: cmovnz/ne 342 IntMatCond_LongVarVar(int a, int b, long x, long y)343 public static long IntMatCond_LongVarVar(int a, int b, long x, long y) { 344 if (doThrow) { 345 // Try defeating inlining. 346 throw new Error(); 347 } 348 long result = (a > b ? x : y); 349 return result + (a > b ? 0L : 1L); 350 } 351 352 /// CHECK-START: long Main.LongNonmatCond_LongVarVar(long, long, long, long) register (after) 353 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}] 354 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 355 356 /// CHECK-START-ARM64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after) 357 /// CHECK: Select 358 /// CHECK-NEXT: cmp 359 /// CHECK-NEXT: csel le 360 361 /// CHECK-START-X86_64: long Main.LongNonmatCond_LongVarVar(long, long, long, long) disassembly (after) 362 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}] 363 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 364 /// CHECK: cmovle/ngq 365 LongNonmatCond_LongVarVar(long a, long b, long x, long y)366 public static long LongNonmatCond_LongVarVar(long a, long b, long x, long y) { 367 if (doThrow) { 368 // Try defeating inlining. 369 throw new Error(); 370 } 371 return a > b ? x : y; 372 } 373 374 /// CHECK-START-ARM: long Main.$noinline$LongEqNonmatCond_LongVarVar(long, long, long, long) disassembly (after) 375 /// CHECK: Select 376 /// CHECK-NEXT: cmp {{r\d+}}, {{r\d+}} 377 /// CHECK-NEXT: it eq 378 /// CHECK-NEXT: cmpeq {{r\d+}}, {{r\d+}} 379 /// CHECK-NEXT: it eq 380 $noinline$LongEqNonmatCond_LongVarVar(long a, long b, long x, long y)381 public static long $noinline$LongEqNonmatCond_LongVarVar(long a, long b, long x, long y) { 382 return a == b ? x : y; 383 } 384 385 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar(long, long, long) disassembly (after) 386 /// CHECK: Select 387 /// CHECK-NEXT: mov ip, #52720 388 /// CHECK-NEXT: movt ip, #35243 389 /// CHECK-NEXT: cmp {{r\d+}}, ip 390 /// CHECK-NEXT: sbcs ip, {{r\d+}}, #{{\d+}} 391 /// CHECK-NEXT: it ge 392 $noinline$LongNonmatCondCst_LongVarVar(long a, long x, long y)393 public static long $noinline$LongNonmatCondCst_LongVarVar(long a, long x, long y) { 394 return a > 0x89ABCDEFL ? x : y; 395 } 396 397 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar2(long, long, long) disassembly (after) 398 /// CHECK: Select 399 /// CHECK-NEXT: mov ip, #{{\d+}} 400 /// CHECK-NEXT: movt ip, #{{\d+}} 401 /// CHECK-NEXT: cmp {{r\d+}}, ip 402 $noinline$LongNonmatCondCst_LongVarVar2(long a, long x, long y)403 public static long $noinline$LongNonmatCondCst_LongVarVar2(long a, long x, long y) { 404 return a > 0x0123456789ABCDEFL ? x : y; 405 } 406 407 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar3(long, long, long) disassembly (after) 408 /// CHECK: Select 409 /// CHECK-NEXT: cmp {{r\d+}}, {{r\d+}} 410 /// CHECK-NOT: sbcs 411 /// CHECK-NOT: cmp 412 $noinline$LongNonmatCondCst_LongVarVar3(long a, long x, long y)413 public static long $noinline$LongNonmatCondCst_LongVarVar3(long a, long x, long y) { 414 return a > 0x7FFFFFFFFFFFFFFFL ? x : y; 415 } 416 417 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar4(long, long, long) disassembly (after) 418 /// CHECK: Select 419 /// CHECK-NEXT: orrs ip, {{r\d+}}, {{r\d+}} 420 /// CHECK-NOT: cmp 421 /// CHECK-NOT: sbcs 422 $noinline$LongNonmatCondCst_LongVarVar4(long a, long x, long y)423 public static long $noinline$LongNonmatCondCst_LongVarVar4(long a, long x, long y) { 424 return a == 0 ? x : y; 425 } 426 427 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar5(long, long, long) disassembly (after) 428 /// CHECK: Select 429 /// CHECK-NEXT: orrs ip, {{r\d+}}, {{r\d+}} 430 /// CHECK-NOT: cmp 431 /// CHECK-NOT: sbcs 432 $noinline$LongNonmatCondCst_LongVarVar5(long a, long x, long y)433 public static long $noinline$LongNonmatCondCst_LongVarVar5(long a, long x, long y) { 434 return a != 0 ? x : y; 435 } 436 437 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar6(long, long, long) disassembly (after) 438 /// CHECK: Select 439 /// CHECK-NEXT: cmp {{r\d+}}, #0 440 /// CHECK-NOT: cmp 441 /// CHECK-NOT: sbcs 442 $noinline$LongNonmatCondCst_LongVarVar6(long a, long x, long y)443 public static long $noinline$LongNonmatCondCst_LongVarVar6(long a, long x, long y) { 444 return a >= 0 ? x : y; 445 } 446 447 /// CHECK-START-ARM: long Main.$noinline$LongNonmatCondCst_LongVarVar7(long, long, long) disassembly (after) 448 /// CHECK: Select 449 /// CHECK-NEXT: cmp {{r\d+}}, #0 450 /// CHECK-NOT: cmp 451 /// CHECK-NOT: sbcs 452 $noinline$LongNonmatCondCst_LongVarVar7(long a, long x, long y)453 public static long $noinline$LongNonmatCondCst_LongVarVar7(long a, long x, long y) { 454 return a < 0 ? x : y; 455 } 456 457 /// CHECK-START: long Main.LongMatCond_LongVarVar(long, long, long, long) register (after) 458 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}] 459 /// CHECK: <<Sel1:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>] 460 /// CHECK: <<Sel2:j\d+>> Select [{{j\d+}},{{j\d+}},<<Cond>>] 461 /// CHECK: Add [<<Sel2>>,<<Sel1>>] 462 463 /// CHECK-START-ARM64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after) 464 /// CHECK: LessThanOrEqual 465 /// CHECK-NEXT: cmp 466 /// CHECK-NEXT: cset le 467 /// CHECK: Select 468 /// CHECK-NEXT: csel le 469 470 /// CHECK-START-X86_64: long Main.LongMatCond_LongVarVar(long, long, long, long) disassembly (after) 471 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{j\d+}},{{j\d+}}] 472 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 473 /// CHECK: cmovle/ngq 474 /// CHECK: Select [{{j\d+}},{{j\d+}},<<Cond>>] 475 /// CHECK: cmovnz/neq 476 LongMatCond_LongVarVar(long a, long b, long x, long y)477 public static long LongMatCond_LongVarVar(long a, long b, long x, long y) { 478 if (doThrow) { 479 // Try defeating inlining. 480 throw new Error(); 481 } 482 long result = (a > b ? x : y); 483 return result + (a > b ? 0L : 1L); 484 } 485 486 /// CHECK-START: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) register (after) 487 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}] 488 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>] 489 490 /// CHECK-START-ARM64: int Main.FloatLtNonmatCond_IntVarVar(float, float, int, int) disassembly (after) 491 /// CHECK: LessThanOrEqual 492 /// CHECK: Select 493 /// CHECK-NEXT: fcmp 494 /// CHECK-NEXT: csel le 495 FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y)496 public static int FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y) { 497 if (doThrow) { 498 // Try defeating inlining. 499 throw new Error(); 500 } 501 return a > b ? x : y; 502 } 503 504 /// CHECK-START: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) register (after) 505 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}] 506 /// CHECK-NEXT: Select [{{i\d+}},{{i\d+}},<<Cond>>] 507 508 /// CHECK-START-ARM64: int Main.FloatGtNonmatCond_IntVarVar(float, float, int, int) disassembly (after) 509 /// CHECK: GreaterThanOrEqual 510 /// CHECK: Select 511 /// CHECK-NEXT: fcmp 512 /// CHECK-NEXT: csel hs 513 FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y)514 public static int FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y) { 515 if (doThrow) { 516 // Try defeating inlining. 517 throw new Error(); 518 } 519 return a < b ? x : y; 520 } 521 522 /// CHECK-START: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) register (after) 523 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}] 524 /// CHECK-NEXT: Select [{{f\d+}},{{f\d+}},<<Cond>>] 525 526 /// CHECK-START-ARM64: float Main.FloatGtNonmatCond_FloatVarVar(float, float, float, float) disassembly (after) 527 /// CHECK: GreaterThanOrEqual 528 /// CHECK: Select 529 /// CHECK-NEXT: fcmp 530 /// CHECK-NEXT: fcsel hs 531 FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y)532 public static float FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y) { 533 if (doThrow) { 534 // Try defeating inlining. 535 throw new Error(); 536 } 537 return a < b ? x : y; 538 } 539 540 /// CHECK-START: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) register (after) 541 /// CHECK: <<Cond:z\d+>> LessThanOrEqual [{{f\d+}},{{f\d+}}] 542 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>] 543 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>] 544 545 /// CHECK-START-ARM64: int Main.FloatLtMatCond_IntVarVar(float, float, int, int) disassembly (after) 546 /// CHECK: LessThanOrEqual 547 /// CHECK-NEXT: fcmp 548 /// CHECK-NEXT: cset le 549 /// CHECK: Select 550 /// CHECK-NEXT: csel le 551 FloatLtMatCond_IntVarVar(float a, float b, int x, int y)552 public static int FloatLtMatCond_IntVarVar(float a, float b, int x, int y) { 553 if (doThrow) { 554 // Try defeating inlining. 555 throw new Error(); 556 } 557 int result = (a > b ? x : y); 558 return result + (a > b ? 0 : 1); 559 } 560 561 /// CHECK-START: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) register (after) 562 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual [{{f\d+}},{{f\d+}}] 563 /// CHECK-NEXT: <<Sel:i\d+>> Select [{{i\d+}},{{i\d+}},<<Cond>>] 564 /// CHECK-NEXT: Add [<<Cond>>,<<Sel>>] 565 566 /// CHECK-START-ARM64: int Main.FloatGtMatCond_IntVarVar(float, float, int, int) disassembly (after) 567 /// CHECK: GreaterThanOrEqual 568 /// CHECK-NEXT: fcmp 569 /// CHECK-NEXT: cset hs 570 /// CHECK: Select 571 /// CHECK-NEXT: csel hs 572 FloatGtMatCond_IntVarVar(float a, float b, int x, int y)573 public static int FloatGtMatCond_IntVarVar(float a, float b, int x, int y) { 574 if (doThrow) { 575 // Try defeating inlining. 576 throw new Error(); 577 } 578 int result = (a < b ? x : y); 579 return result + (a < b ? 0 : 1); 580 } 581 582 /// CHECK-START: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) register (after) 583 /// CHECK: <<Cond:z\d+>> GreaterThanOrEqual 584 /// CHECK-NEXT: <<Sel:f\d+>> Select [{{f\d+}},{{f\d+}},<<Cond>>] 585 /// CHECK-NEXT: TypeConversion [<<Cond>>] 586 587 /// CHECK-START-ARM64: float Main.FloatGtMatCond_FloatVarVar(float, float, float, float) disassembly (after) 588 /// CHECK: GreaterThanOrEqual 589 /// CHECK-NEXT: fcmp 590 /// CHECK-NEXT: cset hs 591 /// CHECK: Select 592 /// CHECK-NEXT: fcsel hs 593 FloatGtMatCond_FloatVarVar(float a, float b, float x, float y)594 public static float FloatGtMatCond_FloatVarVar(float a, float b, float x, float y) { 595 if (doThrow) { 596 // Try defeating inlining. 597 throw new Error(); 598 } 599 float result = (a < b ? x : y); 600 return result + (a < b ? 0 : 1); 601 } 602 603 /// CHECK-START: int Main.BoolCond_0_m1(boolean) register (after) 604 /// CHECK: <<Cond:z\d+>> ParameterValue 605 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 606 607 /// CHECK-START-ARM64: int Main.BoolCond_0_m1(boolean) disassembly (after) 608 /// CHECK: <<Cond:z\d+>> ParameterValue 609 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 610 /// CHECK-NEXT: cmp {{w\d+}}, #0x0 (0) 611 /// CHECK-NEXT: csetm {{w\d+}}, eq 612 613 /// CHECK-START-X86_64: int Main.BoolCond_0_m1(boolean) disassembly (after) 614 /// CHECK: <<Cond:z\d+>> ParameterValue 615 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 616 /// CHECK: cmovnz/ne 617 618 /// CHECK-START-X86: int Main.BoolCond_0_m1(boolean) disassembly (after) 619 /// CHECK: <<Cond:z\d+>> ParameterValue 620 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 621 /// CHECK: cmovnz/ne 622 BoolCond_0_m1(boolean cond)623 public static int BoolCond_0_m1(boolean cond) { 624 if (doThrow) { 625 // Try defeating inlining. 626 throw new Error(); 627 } 628 return cond ? 0 : -1; 629 } 630 631 /// CHECK-START: int Main.BoolCond_m1_0(boolean) register (after) 632 /// CHECK: <<Cond:z\d+>> ParameterValue 633 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 634 635 /// CHECK-START-ARM64: int Main.BoolCond_m1_0(boolean) disassembly (after) 636 /// CHECK: <<Cond:z\d+>> ParameterValue 637 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 638 /// CHECK-NEXT: cmp {{w\d+}}, #0x0 (0) 639 /// CHECK-NEXT: csetm {{w\d+}}, ne 640 641 /// CHECK-START-X86_64: int Main.BoolCond_m1_0(boolean) disassembly (after) 642 /// CHECK: <<Cond:z\d+>> ParameterValue 643 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 644 /// CHECK: cmovnz/ne 645 646 /// CHECK-START-X86: int Main.BoolCond_m1_0(boolean) disassembly (after) 647 /// CHECK: <<Cond:z\d+>> ParameterValue 648 /// CHECK: Select [{{i\d+}},{{i\d+}},<<Cond>>] 649 /// CHECK: cmovnz/ne 650 BoolCond_m1_0(boolean cond)651 public static int BoolCond_m1_0(boolean cond) { 652 if (doThrow) { 653 // Try defeating inlining. 654 throw new Error(); 655 } 656 return cond ? -1 : 0; 657 } 658 assertEqual(int expected, int actual)659 public static void assertEqual(int expected, int actual) { 660 if (expected != actual) { 661 throw new Error("Assertion failed: " + expected + " != " + actual); 662 } 663 } 664 assertEqual(float expected, float actual)665 public static void assertEqual(float expected, float actual) { 666 if (expected != actual) { 667 throw new Error("Assertion failed: " + expected + " != " + actual); 668 } 669 } 670 main(String[] args)671 public static void main(String[] args) { 672 assertEqual(5, BoolCond_IntVarVar(true, 5, 7)); 673 assertEqual(7, BoolCond_IntVarVar(false, 5, 7)); 674 assertEqual(5, BoolCond_IntVarCst(true, 5)); 675 assertEqual(1, BoolCond_IntVarCst(false, 5)); 676 assertEqual(1, BoolCond_IntCstVar(true, 7)); 677 assertEqual(7, BoolCond_IntCstVar(false, 7)); 678 679 assertEqual(5L, BoolCond_LongVarVar(true, 5L, 7L)); 680 assertEqual(7L, BoolCond_LongVarVar(false, 5L, 7L)); 681 assertEqual(5L, BoolCond_LongVarCst(true, 5L)); 682 assertEqual(1L, BoolCond_LongVarCst(false, 5L)); 683 assertEqual(1L, BoolCond_LongCstVar(true, 7L)); 684 assertEqual(7L, BoolCond_LongCstVar(false, 7L)); 685 686 assertEqual(5, BoolCond_FloatVarVar(true, 5, 7)); 687 assertEqual(7, BoolCond_FloatVarVar(false, 5, 7)); 688 assertEqual(5, BoolCond_FloatVarCst(true, 5)); 689 assertEqual(1, BoolCond_FloatVarCst(false, 5)); 690 assertEqual(1, BoolCond_FloatCstVar(true, 7)); 691 assertEqual(7, BoolCond_FloatCstVar(false, 7)); 692 693 assertEqual(5, IntNonmatCond_IntVarVar(3, 2, 5, 7)); 694 assertEqual(7, IntNonmatCond_IntVarVar(2, 3, 5, 7)); 695 assertEqual(5, IntMatCond_IntVarVar(3, 2, 5, 7)); 696 assertEqual(8, IntMatCond_IntVarVar(2, 3, 5, 7)); 697 698 assertEqual(0xAAAAAAAA55555555L, 699 LongNonmatCond_LongVarVar(3L, 2L, 0xAAAAAAAA55555555L, 0x8888888877777777L)); 700 assertEqual(0x8888888877777777L, 701 LongNonmatCond_LongVarVar(2L, 2L, 0xAAAAAAAA55555555L, 0x8888888877777777L)); 702 assertEqual(0x8888888877777777L, 703 LongNonmatCond_LongVarVar(2L, 3L, 0xAAAAAAAA55555555L, 0x8888888877777777L)); 704 assertEqual(0xAAAAAAAA55555555L, LongNonmatCond_LongVarVar(0x0000000100000000L, 705 0x00000000FFFFFFFFL, 706 0xAAAAAAAA55555555L, 707 0x8888888877777777L)); 708 assertEqual(0x8888888877777777L, LongNonmatCond_LongVarVar(0x00000000FFFFFFFFL, 709 0x0000000100000000L, 710 0xAAAAAAAA55555555L, 711 0x8888888877777777L)); 712 713 assertEqual(0x8888888877777777L, $noinline$LongEqNonmatCond_LongVarVar(2L, 714 3L, 715 0xAAAAAAAA55555555L, 716 0x8888888877777777L)); 717 assertEqual(0xAAAAAAAA55555555L, $noinline$LongEqNonmatCond_LongVarVar(2L, 718 2L, 719 0xAAAAAAAA55555555L, 720 0x8888888877777777L)); 721 assertEqual(0x8888888877777777L, $noinline$LongEqNonmatCond_LongVarVar(0x10000000000L, 722 0L, 723 0xAAAAAAAA55555555L, 724 0x8888888877777777L)); 725 726 assertEqual(5L, $noinline$LongNonmatCondCst_LongVarVar2(0x7FFFFFFFFFFFFFFFL, 5L, 7L)); 727 assertEqual(7L, $noinline$LongNonmatCondCst_LongVarVar2(2L, 5L, 7L)); 728 729 assertEqual(7L, $noinline$LongNonmatCondCst_LongVarVar3(2L, 5L, 7L)); 730 731 long[] long_inputs = { 732 0L, 1L, -1L, Long.MIN_VALUE, Long.MAX_VALUE, 2L, 0x100000000L, 0xFFFFFFFF00000000L, -9000L}; 733 734 long[] expected_1 = {5L, 7L, 7L, 7L, 7L, 7L, 7L, 7L, 7L}; 735 736 for (int i = 0; i < long_inputs.length; i++) { 737 assertEqual(expected_1[i], $noinline$LongNonmatCondCst_LongVarVar4(long_inputs[i], 5L, 7L)); 738 } 739 740 long[] expected_2 = {7L, 5L, 5L, 5L, 5L, 5L, 5L, 5L, 5L}; 741 742 for (int i = 0; i < long_inputs.length; i++) { 743 assertEqual(expected_2[i], $noinline$LongNonmatCondCst_LongVarVar5(long_inputs[i], 5L, 7L)); 744 } 745 746 long[] expected_3 = {5L, 5L, 7L, 7L, 5L, 5L, 5L, 7L, 7L}; 747 748 for (int i = 0; i < long_inputs.length; i++) { 749 assertEqual(expected_3[i], $noinline$LongNonmatCondCst_LongVarVar6(long_inputs[i], 5L, 7L)); 750 } 751 752 long[] expected_4 = {7L, 7L, 5L, 5L, 7L, 7L, 7L, 5L, 5L}; 753 754 for (int i = 0; i < long_inputs.length; i++) { 755 assertEqual(expected_4[i], $noinline$LongNonmatCondCst_LongVarVar7(long_inputs[i], 5L, 7L)); 756 } 757 758 assertEqual(7L, $noinline$LongNonmatCondCst_LongVarVar7(0L, 5L, 7L)); 759 assertEqual(7L, $noinline$LongNonmatCondCst_LongVarVar7(2L, 5L, 7L)); 760 assertEqual(5L, $noinline$LongNonmatCondCst_LongVarVar7(-9000L, 5L, 7L)); 761 762 assertEqual(5, FloatLtNonmatCond_IntVarVar(3, 2, 5, 7)); 763 assertEqual(7, FloatLtNonmatCond_IntVarVar(2, 3, 5, 7)); 764 assertEqual(7, FloatLtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7)); 765 assertEqual(7, FloatLtNonmatCond_IntVarVar(2, Float.NaN, 5, 7)); 766 767 assertEqual(5, FloatGtNonmatCond_IntVarVar(2, 3, 5, 7)); 768 assertEqual(7, FloatGtNonmatCond_IntVarVar(3, 2, 5, 7)); 769 assertEqual(7, FloatGtNonmatCond_IntVarVar(Float.NaN, 2, 5, 7)); 770 assertEqual(7, FloatGtNonmatCond_IntVarVar(2, Float.NaN, 5, 7)); 771 772 assertEqual(5, FloatGtNonmatCond_FloatVarVar(2, 3, 5, 7)); 773 assertEqual(7, FloatGtNonmatCond_FloatVarVar(3, 2, 5, 7)); 774 assertEqual(7, FloatGtNonmatCond_FloatVarVar(Float.NaN, 2, 5, 7)); 775 assertEqual(7, FloatGtNonmatCond_FloatVarVar(2, Float.NaN, 5, 7)); 776 777 assertEqual(5, FloatLtMatCond_IntVarVar(3, 2, 5, 7)); 778 assertEqual(8, FloatLtMatCond_IntVarVar(2, 3, 5, 7)); 779 assertEqual(8, FloatLtMatCond_IntVarVar(Float.NaN, 2, 5, 7)); 780 assertEqual(8, FloatLtMatCond_IntVarVar(2, Float.NaN, 5, 7)); 781 782 assertEqual(5, FloatGtMatCond_IntVarVar(2, 3, 5, 7)); 783 assertEqual(8, FloatGtMatCond_IntVarVar(3, 2, 5, 7)); 784 assertEqual(8, FloatGtMatCond_IntVarVar(Float.NaN, 2, 5, 7)); 785 assertEqual(8, FloatGtMatCond_IntVarVar(2, Float.NaN, 5, 7)); 786 787 assertEqual(5, FloatGtMatCond_FloatVarVar(2, 3, 5, 7)); 788 assertEqual(8, FloatGtMatCond_FloatVarVar(3, 2, 5, 7)); 789 assertEqual(8, FloatGtMatCond_FloatVarVar(Float.NaN, 2, 5, 7)); 790 assertEqual(8, FloatGtMatCond_FloatVarVar(2, Float.NaN, 5, 7)); 791 792 assertEqual(0, BoolCond_0_m1(true)); 793 assertEqual(-1, BoolCond_0_m1(false)); 794 assertEqual(-1, BoolCond_m1_0(true)); 795 assertEqual(0, BoolCond_m1_0(false)); 796 } 797 } 798