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 /// CHECK-START: int Main.BoolCond_IntVarVar(boolean, int, int) register (after) 20 /// CHECK: Select [{{i\d+}},{{i\d+}},{{z\d+}}] 21 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 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 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 BoolCond_IntVarVar(boolean cond, int x, int y)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 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 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 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 BoolCond_IntVarCst(boolean cond, int x)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 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 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 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 BoolCond_IntCstVar(boolean cond, int y)81 public static int BoolCond_IntCstVar(boolean cond, int y) { 82 return cond ? 1 : y; 83 } 84 85 /// CHECK-START: long Main.BoolCond_LongVarVar(boolean, long, long) register (after) 86 /// CHECK: Select [{{j\d+}},{{j\d+}},{{z\d+}}] 87 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 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 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 BoolCond_LongVarVar(boolean cond, long x, long y)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 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 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 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 BoolCond_LongVarCst(boolean cond, long x)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 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 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 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 BoolCond_LongCstVar(boolean cond, long y)150 public static long BoolCond_LongCstVar(boolean cond, long y) { 151 return cond ? 1L : y; 152 } 153 154 /// CHECK-START: float Main.BoolCond_FloatVarVar(boolean, float, float) register (after) 155 /// CHECK: Select [{{f\d+}},{{f\d+}},{{z\d+}}] 156 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 BoolCond_FloatVarVar(boolean cond, float x, float y)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 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 BoolCond_FloatVarCst(boolean cond, float x)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 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 BoolCond_FloatCstVar(boolean cond, float y)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 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 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 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 IntNonmatCond_IntVarVar(int a, int b, int x, int y)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 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 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 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 IntMatCond_IntVarVar(int a, int b, int x, int y)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 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 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 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 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 IntNonmatCond_LongVarVar(int a, int b, long x, long y)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 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 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 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 IntMatCond_LongVarVar(int a, int b, long x, long y)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 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 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 LongNonmatCond_LongVarVar(long a, long b, long x, long y)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 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 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 LongMatCond_LongVarVar(long a, long b, long x, long y)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 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 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 FloatLtNonmatCond_IntVarVar(float a, float b, int x, int y)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 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 FloatGtNonmatCond_IntVarVar(float a, float b, int x, int y)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 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 FloatGtNonmatCond_FloatVarVar(float a, float b, float x, float y)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 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 FloatLtMatCond_IntVarVar(float a, float b, int x, int y)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 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 FloatGtMatCond_IntVarVar(float a, float b, int x, int y)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 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 FloatGtMatCond_FloatVarVar(float a, float b, float x, float y)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 assertEqual(int expected, int actual)434 public static void assertEqual(int expected, int actual) { 435 if (expected != actual) { 436 throw new Error("Assertion failed: " + expected + " != " + actual); 437 } 438 } 439 assertEqual(float expected, float actual)440 public static void assertEqual(float expected, float actual) { 441 if (expected != actual) { 442 throw new Error("Assertion failed: " + expected + " != " + actual); 443 } 444 } 445 main(String[] args)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 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 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 } 504