1 /* 2 * Copyright (c) 2025, Rivos Inc. All rights reserved. 3 * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25 package compiler.c2.cmove; 26 27 import compiler.lib.ir_framework.*; 28 import java.util.List; 29 30 /* 31 * @test 32 * @bug 8358892 8357551 33 * @summary The test is to trigger code path of BoolTest::ge/gt in C2_MacroAssembler::enc_cmove_cmp_fp 34 * @requires vm.debug 35 * @library /test/lib / 36 * @run driver ${test.main.class} 37 */ 38 public class TestFPComparison2 { 39 static final double[] DOUBLES = new double[] { 40 Double.NEGATIVE_INFINITY, 41 -Double.MAX_VALUE, 42 -1.0, 43 -Double.MIN_VALUE, 44 -0.0, 45 0.0, 46 Double.MIN_VALUE, 47 1.0, 48 Double.MAX_VALUE, 49 Double.POSITIVE_INFINITY, 50 Double.NaN, 51 }; 52 53 static final float[] FLOATS = new float[] { 54 Float.NEGATIVE_INFINITY, 55 -Float.MAX_VALUE, 56 -1.0F, 57 -Float.MIN_VALUE, 58 -0.0F, 59 0.0F, 60 Float.MIN_VALUE, 61 1.0F, 62 Float.MAX_VALUE, 63 Float.POSITIVE_INFINITY, 64 Float.NaN, 65 }; 66 67 static final int[] INTS = new int[] { 68 Integer.MIN_VALUE, 69 -100, 70 -1, 71 0, 72 1, 73 100, 74 Integer.MAX_VALUE, 75 }; 76 77 public static void main(String[] args) { 78 List<String> options = List.of("-XX:-TieredCompilation", "-Xlog:jit+compilation=trace"); 79 // Booltest::ge 80 TestFramework 81 framework = new TestFramework(Test_ge_1.class); 82 framework.addFlags(options.toArray(new String[0])).start(); 83 framework = new TestFramework(Test_ge_cmove_fp_1.class); 84 framework.addFlags(options.toArray(new String[0])).start(); 85 86 framework = new TestFramework(Test_ge_2.class); 87 framework.addFlags(options.toArray(new String[0])).start(); 88 framework = new TestFramework(Test_ge_cmove_fp_2.class); 89 framework.addFlags(options.toArray(new String[0])).start(); 90 91 // Booltest::gt 92 framework = new TestFramework(Test_gt_1.class); 93 framework.addFlags(options.toArray(new String[0])).start(); 94 framework = new TestFramework(Test_gt_cmove_fp_1.class); 95 framework.addFlags(options.toArray(new String[0])).start(); 96 97 framework = new TestFramework(Test_gt_2.class); 98 framework.addFlags(options.toArray(new String[0])).start(); 99 framework = new TestFramework(Test_gt_cmove_fp_2.class); 100 framework.addFlags(options.toArray(new String[0])).start(); 101 102 // BoolTest::ge/gt in C2_MacroAssembler::enc_cmove_fp_cmp_fp 103 framework = new TestFramework(Test_cmov_fp_cmp_fp_ge_3.class); 104 framework.addFlags(options.toArray(new String[0])).start(); 105 framework = new TestFramework(Test_cmov_fp_cmp_fp_ge_4.class); 106 framework.addFlags(options.toArray(new String[0])).start(); 107 } 108 } 109 110 class Test_ge_1 { 111 @Test 112 @IR(counts = {IRNode.CMOVE_I, "1"}, 113 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 114 public static int test_float_BoolTest_ge_fixed_1_0(float x, float y) { 115 // return 1 116 // when either x or y is NaN 117 // when neither is NaN, and x > y 118 // return 0 119 // when neither is NaN, and x <= y 120 return !(x <= y) ? 1 : 0; 121 } 122 @DontCompile 123 public static int golden_float_BoolTest_ge_fixed_1_0(float x, float y) { 124 return !(x <= y) ? 1 : 0; 125 } 126 127 @Test 128 @IR(counts = {IRNode.CMOVE_I, "1"}, 129 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 130 public static int test_double_BoolTest_ge_fixed_1_0(double x, double y) { 131 // return 1 132 // when either x or y is NaN 133 // when neither is NaN, and x > y 134 // return 0 135 // when neither is NaN, and x <= y 136 return !(x <= y) ? 1 : 0; 137 } 138 @DontCompile 139 public static int golden_double_BoolTest_ge_fixed_1_0(double x, double y) { 140 return !(x <= y) ? 1 : 0; 141 } 142 143 @Test 144 @IR(counts = {IRNode.CMOVE_I, "1"}, 145 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 146 public static int test_float_BoolTest_ge_fixed_0_1(float x, float y) { 147 return !(x <= y) ? 0 : 1; 148 } 149 @DontCompile 150 public static int golden_float_BoolTest_ge_fixed_0_1(float x, float y) { 151 return !(x <= y) ? 0 : 1; 152 } 153 154 @Test 155 @IR(counts = {IRNode.CMOVE_I, "1"}, 156 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 157 public static int test_double_BoolTest_ge_fixed_0_1(double x, double y) { 158 return !(x <= y) ? 0 : 1; 159 } 160 @DontCompile 161 public static int golden_double_BoolTest_ge_fixed_0_1(double x, double y) { 162 return !(x <= y) ? 0 : 1; 163 } 164 165 @Test 166 @IR(counts = {IRNode.CMOVE_I, "1"}, 167 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 168 public static int test_float_BoolTest_ge_fixed_10_20(float x, float y) { 169 return !(x <= y) ? 10 : 20; 170 } 171 @DontCompile 172 public static int golden_float_BoolTest_ge_fixed_10_20(float x, float y) { 173 return !(x <= y) ? 10 : 20; 174 } 175 176 @Test 177 @IR(counts = {IRNode.CMOVE_I, "1"}, 178 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 179 public static int test_double_BoolTest_ge_fixed_10_20(double x, double y) { 180 return !(x <= y) ? 10 : 20; 181 } 182 @DontCompile 183 public static int golden_double_BoolTest_ge_fixed_10_20(double x, double y) { 184 return !(x <= y) ? 10 : 20; 185 } 186 187 @Test 188 @IR(counts = {IRNode.CMOVE_I, "1"}, 189 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 190 public static int test_float_BoolTest_ge_variable_results(float x, float y, int a, int b) { 191 return !(x <= y) ? a : b; 192 } 193 @DontCompile 194 public static int golden_float_BoolTest_ge_variable_results(float x, float y, int a, int b) { 195 return !(x <= y) ? a : b; 196 } 197 198 @Test 199 @IR(counts = {IRNode.CMOVE_I, "1"}, 200 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 201 public static int test_double_BoolTest_ge_variable_results(double x, double y, int a, int b) { 202 return !(x <= y) ? a : b; 203 } 204 @DontCompile 205 public static int golden_double_BoolTest_ge_variable_results(double x, double y, int a, int b) { 206 return !(x <= y) ? a : b; 207 } 208 209 @Run(test = {"test_float_BoolTest_ge_fixed_1_0", "test_double_BoolTest_ge_fixed_1_0", 210 "test_float_BoolTest_ge_fixed_0_1", "test_double_BoolTest_ge_fixed_0_1", 211 "test_float_BoolTest_ge_fixed_10_20", "test_double_BoolTest_ge_fixed_10_20", 212 "test_float_BoolTest_ge_variable_results", "test_double_BoolTest_ge_variable_results"}) 213 public void runTests() { 214 int err = 0; 215 216 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 217 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 218 float x = TestFPComparison2.FLOATS[i]; 219 float y = TestFPComparison2.FLOATS[j]; 220 int actual = test_float_BoolTest_ge_fixed_1_0(x, y); 221 int expected = golden_float_BoolTest_ge_fixed_1_0(x, y); 222 if (actual != expected) { 223 System.out.println("Float failed (ge, 1, 0), x: " + x + ", y: " + y + 224 ", actual: " + actual + ", expected: " + expected); 225 err++; 226 } 227 } 228 } 229 230 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 231 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 232 double x = TestFPComparison2.DOUBLES[i]; 233 double y = TestFPComparison2.DOUBLES[j]; 234 int actual = test_double_BoolTest_ge_fixed_1_0(x, y); 235 int expected = golden_double_BoolTest_ge_fixed_1_0(x, y); 236 if (actual != expected) { 237 System.out.println("Double failed (ge, 1, 0), x: " + x + ", y: " + y + 238 ", actual: " + actual + ", expected: " + expected); 239 err++; 240 } 241 } 242 } 243 244 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 245 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 246 float x = TestFPComparison2.FLOATS[i]; 247 float y = TestFPComparison2.FLOATS[j]; 248 int actual = test_float_BoolTest_ge_fixed_0_1(x, y); 249 int expected = golden_float_BoolTest_ge_fixed_0_1(x, y); 250 if (actual != expected) { 251 System.out.println("Float failed (ge, 0, 1), x: " + x + ", y: " + y + 252 ", actual: " + actual + ", expected: " + expected); 253 err++; 254 } 255 } 256 } 257 258 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 259 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 260 double x = TestFPComparison2.DOUBLES[i]; 261 double y = TestFPComparison2.DOUBLES[j]; 262 int actual = test_double_BoolTest_ge_fixed_0_1(x, y); 263 int expected = golden_double_BoolTest_ge_fixed_0_1(x, y); 264 if (actual != expected) { 265 System.out.println("Double failed (ge, 0, 1), x: " + x + ", y: " + y + 266 ", actual: " + actual + ", expected: " + expected); 267 err++; 268 } 269 } 270 } 271 272 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 273 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 274 float x = TestFPComparison2.FLOATS[i]; 275 float y = TestFPComparison2.FLOATS[j]; 276 int actual = test_float_BoolTest_ge_fixed_10_20(x, y); 277 int expected = golden_float_BoolTest_ge_fixed_10_20(x, y); 278 if (actual != expected) { 279 System.out.println("Float failed (ge, 10, 20), x: " + x + ", y: " + y + 280 ", actual: " + actual + ", expected: " + expected); 281 err++; 282 } 283 } 284 } 285 286 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 287 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 288 double x = TestFPComparison2.DOUBLES[i]; 289 double y = TestFPComparison2.DOUBLES[j]; 290 int actual = test_double_BoolTest_ge_fixed_10_20(x, y); 291 int expected = golden_double_BoolTest_ge_fixed_10_20(x, y); 292 if (actual != expected) { 293 System.out.println("Double failed (ge, 10, 20), x: " + x + ", y: " + y + 294 ", actual: " + actual + ", expected: " + expected); 295 err++; 296 } 297 } 298 } 299 300 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 301 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 302 float x = TestFPComparison2.FLOATS[i]; 303 float y = TestFPComparison2.FLOATS[j]; 304 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 305 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 306 int a = TestFPComparison2.INTS[m]; 307 int b = TestFPComparison2.INTS[n]; 308 int actual = test_float_BoolTest_ge_variable_results(x, y, a, b); 309 int expected = golden_float_BoolTest_ge_variable_results(x, y, a, b); 310 if (actual != expected) { 311 System.out.println("Float failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 312 ", actual: " + actual + ", expected: " + expected); 313 err++; 314 } 315 } 316 } 317 } 318 } 319 320 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 321 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 322 double x = TestFPComparison2.DOUBLES[i]; 323 double y = TestFPComparison2.DOUBLES[j]; 324 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 325 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 326 int a = TestFPComparison2.INTS[m]; 327 int b = TestFPComparison2.INTS[n]; 328 int actual = test_double_BoolTest_ge_variable_results(x, y, a, b); 329 int expected = golden_double_BoolTest_ge_variable_results(x, y, a, b); 330 if (actual != expected) { 331 System.out.println("Double failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 332 ", actual: " + actual + ", expected: " + expected); 333 err++; 334 } 335 } 336 } 337 } 338 } 339 340 if (err != 0) { 341 throw new RuntimeException("Some tests failed"); 342 } 343 } 344 } 345 346 347 class Test_ge_cmove_fp_1 { 348 @Test 349 @IR(counts = {IRNode.CMOVE_F, "1"}, 350 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 351 public static float test_float_BoolTest_ge_fixed_1_0(float x, float y) { 352 // return 1 353 // when either x or y is NaN 354 // when neither is NaN, and x > y 355 // return 0 356 // when neither is NaN, and x <= y 357 return !(x <= y) ? 1.0f : 0.0f; 358 } 359 @DontCompile 360 public static float golden_float_BoolTest_ge_fixed_1_0(float x, float y) { 361 return !(x <= y) ? 1.0f : 0.0f; 362 } 363 364 @Test 365 @IR(counts = {IRNode.CMOVE_F, "1"}, 366 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 367 public static float test_double_BoolTest_ge_fixed_1_0(double x, double y) { 368 // return 1 369 // when either x or y is NaN 370 // when neither is NaN, and x > y 371 // return 0 372 // when neither is NaN, and x <= y 373 return !(x <= y) ? 1.0f : 0.0f; 374 } 375 @DontCompile 376 public static float golden_double_BoolTest_ge_fixed_1_0(double x, double y) { 377 return !(x <= y) ? 1.0f : 0.0f; 378 } 379 380 @Test 381 @IR(counts = {IRNode.CMOVE_F, "1"}, 382 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 383 public static float test_float_BoolTest_ge_fixed_0_1(float x, float y) { 384 return !(x <= y) ? 0.0f : 1.0f; 385 } 386 @DontCompile 387 public static float golden_float_BoolTest_ge_fixed_0_1(float x, float y) { 388 return !(x <= y) ? 0.0f : 1.0f; 389 } 390 391 @Test 392 @IR(counts = {IRNode.CMOVE_F, "1"}, 393 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 394 public static float test_double_BoolTest_ge_fixed_0_1(double x, double y) { 395 return !(x <= y) ? 0.0f : 1.0f; 396 } 397 @DontCompile 398 public static float golden_double_BoolTest_ge_fixed_0_1(double x, double y) { 399 return !(x <= y) ? 0.0f : 1.0f; 400 } 401 402 @Test 403 @IR(counts = {IRNode.CMOVE_F, "1"}, 404 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 405 public static float test_float_BoolTest_ge_fixed_10_20(float x, float y) { 406 return !(x <= y) ? 10.0f : 20.0f; 407 } 408 @DontCompile 409 public static float golden_float_BoolTest_ge_fixed_10_20(float x, float y) { 410 return !(x <= y) ? 10.0f : 20.0f; 411 } 412 413 @Test 414 @IR(counts = {IRNode.CMOVE_F, "1"}, 415 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 416 public static float test_double_BoolTest_ge_fixed_10_20(double x, double y) { 417 return !(x <= y) ? 10.0f : 20.0f; 418 } 419 @DontCompile 420 public static float golden_double_BoolTest_ge_fixed_10_20(double x, double y) { 421 return !(x <= y) ? 10.0f : 20.0f; 422 } 423 424 @Test 425 @IR(counts = {IRNode.CMOVE_F, "1"}, 426 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 427 public static float test_float_BoolTest_ge_variable_results(float x, float y, float a, float b) { 428 return !(x <= y) ? a : b; 429 } 430 @DontCompile 431 public static float golden_float_BoolTest_ge_variable_results(float x, float y, float a, float b) { 432 return !(x <= y) ? a : b; 433 } 434 435 @Test 436 @IR(counts = {IRNode.CMOVE_F, "1"}, 437 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 438 public static float test_double_BoolTest_ge_variable_results(double x, double y, float a, float b) { 439 return !(x <= y) ? a : b; 440 } 441 @DontCompile 442 public static float golden_double_BoolTest_ge_variable_results(double x, double y, float a, float b) { 443 return !(x <= y) ? a : b; 444 } 445 446 @Run(test = {"test_float_BoolTest_ge_fixed_1_0", "test_double_BoolTest_ge_fixed_1_0", 447 "test_float_BoolTest_ge_fixed_0_1", "test_double_BoolTest_ge_fixed_0_1", 448 "test_float_BoolTest_ge_fixed_10_20", "test_double_BoolTest_ge_fixed_10_20", 449 "test_float_BoolTest_ge_variable_results", "test_double_BoolTest_ge_variable_results"}) 450 public void runTests() { 451 int err = 0; 452 453 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 454 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 455 float x = TestFPComparison2.FLOATS[i]; 456 float y = TestFPComparison2.FLOATS[j]; 457 float actual = test_float_BoolTest_ge_fixed_1_0(x, y); 458 float expected = golden_float_BoolTest_ge_fixed_1_0(x, y); 459 if (actual != expected) { 460 System.out.println("Float failed (ge, 1, 0), x: " + x + ", y: " + y + 461 ", actual: " + actual + ", expected: " + expected); 462 err++; 463 } 464 } 465 } 466 467 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 468 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 469 double x = TestFPComparison2.DOUBLES[i]; 470 double y = TestFPComparison2.DOUBLES[j]; 471 float actual = test_double_BoolTest_ge_fixed_1_0(x, y); 472 float expected = golden_double_BoolTest_ge_fixed_1_0(x, y); 473 if (actual != expected) { 474 System.out.println("Double failed (ge, 1, 0), x: " + x + ", y: " + y + 475 ", actual: " + actual + ", expected: " + expected); 476 err++; 477 } 478 } 479 } 480 481 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 482 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 483 float x = TestFPComparison2.FLOATS[i]; 484 float y = TestFPComparison2.FLOATS[j]; 485 float actual = test_float_BoolTest_ge_fixed_0_1(x, y); 486 float expected = golden_float_BoolTest_ge_fixed_0_1(x, y); 487 if (actual != expected) { 488 System.out.println("Float failed (ge, 0, 1), x: " + x + ", y: " + y + 489 ", actual: " + actual + ", expected: " + expected); 490 err++; 491 } 492 } 493 } 494 495 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 496 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 497 double x = TestFPComparison2.DOUBLES[i]; 498 double y = TestFPComparison2.DOUBLES[j]; 499 float actual = test_double_BoolTest_ge_fixed_0_1(x, y); 500 float expected = golden_double_BoolTest_ge_fixed_0_1(x, y); 501 if (actual != expected) { 502 System.out.println("Double failed (ge, 0, 1), x: " + x + ", y: " + y + 503 ", actual: " + actual + ", expected: " + expected); 504 err++; 505 } 506 } 507 } 508 509 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 510 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 511 float x = TestFPComparison2.FLOATS[i]; 512 float y = TestFPComparison2.FLOATS[j]; 513 float actual = test_float_BoolTest_ge_fixed_10_20(x, y); 514 float expected = golden_float_BoolTest_ge_fixed_10_20(x, y); 515 if (actual != expected) { 516 System.out.println("Float failed (ge, 10, 20), x: " + x + ", y: " + y + 517 ", actual: " + actual + ", expected: " + expected); 518 err++; 519 } 520 } 521 } 522 523 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 524 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 525 double x = TestFPComparison2.DOUBLES[i]; 526 double y = TestFPComparison2.DOUBLES[j]; 527 float actual = test_double_BoolTest_ge_fixed_10_20(x, y); 528 float expected = golden_double_BoolTest_ge_fixed_10_20(x, y); 529 if (actual != expected) { 530 System.out.println("Double failed (ge, 10, 20), x: " + x + ", y: " + y + 531 ", actual: " + actual + ", expected: " + expected); 532 err++; 533 } 534 } 535 } 536 537 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 538 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 539 float x = TestFPComparison2.FLOATS[i]; 540 float y = TestFPComparison2.FLOATS[j]; 541 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 542 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 543 float a = TestFPComparison2.FLOATS[m]; 544 float b = TestFPComparison2.FLOATS[n]; 545 float actual = test_float_BoolTest_ge_variable_results(x, y, a, b); 546 float expected = golden_float_BoolTest_ge_variable_results(x, y, a, b); 547 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 548 System.out.println("Float failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 549 ", actual: " + actual + ", expected: " + expected); 550 err++; 551 } 552 } 553 } 554 } 555 } 556 557 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 558 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 559 double x = TestFPComparison2.DOUBLES[i]; 560 double y = TestFPComparison2.DOUBLES[j]; 561 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 562 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 563 float a = TestFPComparison2.FLOATS[m]; 564 float b = TestFPComparison2.FLOATS[n]; 565 float actual = test_double_BoolTest_ge_variable_results(x, y, a, b); 566 float expected = golden_double_BoolTest_ge_variable_results(x, y, a, b); 567 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 568 System.out.println("Double failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 569 ", actual: " + actual + ", expected: " + expected); 570 err++; 571 } 572 } 573 } 574 } 575 } 576 577 if (err != 0) { 578 throw new RuntimeException("Some tests failed"); 579 } 580 } 581 } 582 583 class Test_ge_2 { 584 @Test 585 @IR(counts = {IRNode.CMOVE_I, "1"}, 586 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 587 public static int test_float_BoolTest_ge_fixed_1_0(float x, float y) { 588 // return 1 589 // when either x or y is NaN 590 // when neither is NaN, and x < y 591 // return 0 592 // when neither is NaN, and x >= y 593 return !(x >= y) ? 1 : 0; 594 } 595 @DontCompile 596 public static int golden_float_BoolTest_ge_fixed_1_0(float x, float y) { 597 return !(x >= y) ? 1 : 0; 598 } 599 600 @Test 601 @IR(counts = {IRNode.CMOVE_I, "1"}, 602 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 603 public static int test_double_BoolTest_ge_fixed_1_0(double x, double y) { 604 // return 1 605 // when either x or y is NaN 606 // when neither is NaN, and x < y 607 // return 0 608 // when neither is NaN, and x >= y 609 return !(x >= y) ? 1 : 0; 610 } 611 @DontCompile 612 public static int golden_double_BoolTest_ge_fixed_1_0(double x, double y) { 613 return !(x >= y) ? 1 : 0; 614 } 615 616 @Test 617 @IR(counts = {IRNode.CMOVE_I, "1"}, 618 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 619 public static int test_float_BoolTest_ge_fixed_0_1(float x, float y) { 620 return !(x >= y) ? 0 : 1; 621 } 622 @DontCompile 623 public static int golden_float_BoolTest_ge_fixed_0_1(float x, float y) { 624 return !(x >= y) ? 0 : 1; 625 } 626 627 @Test 628 @IR(counts = {IRNode.CMOVE_I, "1"}, 629 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 630 public static int test_double_BoolTest_ge_fixed_0_1(double x, double y) { 631 return !(x >= y) ? 0 : 1; 632 } 633 @DontCompile 634 public static int golden_double_BoolTest_ge_fixed_0_1(double x, double y) { 635 return !(x >= y) ? 0 : 1; 636 } 637 638 @Test 639 @IR(counts = {IRNode.CMOVE_I, "1"}, 640 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 641 public static int test_float_BoolTest_ge_fixed_10_20(float x, float y) { 642 return !(x >= y) ? 10 : 20; 643 } 644 @DontCompile 645 public static int golden_float_BoolTest_ge_fixed_10_20(float x, float y) { 646 return !(x >= y) ? 10 : 20; 647 } 648 649 @Test 650 @IR(counts = {IRNode.CMOVE_I, "1"}, 651 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 652 public static int test_double_BoolTest_ge_fixed_10_20(double x, double y) { 653 return !(x >= y) ? 10 : 20; 654 } 655 @DontCompile 656 public static int golden_double_BoolTest_ge_fixed_10_20(double x, double y) { 657 return !(x >= y) ? 10 : 20; 658 } 659 660 @Test 661 @IR(counts = {IRNode.CMOVE_I, "1"}, 662 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 663 public static int test_float_BoolTest_ge_variable_results(float x, float y, int a, int b) { 664 return !(x >= y) ? a : b; 665 } 666 @DontCompile 667 public static int golden_float_BoolTest_ge_variable_results(float x, float y, int a, int b) { 668 return !(x >= y) ? a : b; 669 } 670 671 @Test 672 @IR(counts = {IRNode.CMOVE_I, "1"}, 673 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 674 public static int test_double_BoolTest_ge_variable_results(double x, double y, int a, int b) { 675 return !(x >= y) ? a : b; 676 } 677 @DontCompile 678 public static int golden_double_BoolTest_ge_variable_results(double x, double y, int a, int b) { 679 return !(x >= y) ? a : b; 680 } 681 682 @Run(test = {"test_float_BoolTest_ge_fixed_1_0", "test_double_BoolTest_ge_fixed_1_0", 683 "test_float_BoolTest_ge_fixed_0_1", "test_double_BoolTest_ge_fixed_0_1", 684 "test_float_BoolTest_ge_fixed_10_20", "test_double_BoolTest_ge_fixed_10_20", 685 "test_float_BoolTest_ge_variable_results", "test_double_BoolTest_ge_variable_results"}) 686 public void runTests() { 687 int err = 0; 688 689 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 690 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 691 float x = TestFPComparison2.FLOATS[i]; 692 float y = TestFPComparison2.FLOATS[j]; 693 int actual = test_float_BoolTest_ge_fixed_1_0(x, y); 694 int expected = golden_float_BoolTest_ge_fixed_1_0(x, y); 695 if (actual != expected) { 696 System.out.println("Float failed (ge), x: " + x + ", y: " + y + 697 ", actual: " + actual + ", expected: " + expected); 698 err++; 699 } 700 } 701 } 702 703 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 704 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 705 double x = TestFPComparison2.DOUBLES[i]; 706 double y = TestFPComparison2.DOUBLES[j]; 707 int actual = test_double_BoolTest_ge_fixed_1_0(x, y); 708 int expected = golden_double_BoolTest_ge_fixed_1_0(x, y); 709 if (actual != expected) { 710 System.out.println("Double failed (ge), x: " + x + ", y: " + y + 711 ", actual: " + actual + ", expected: " + expected); 712 err++; 713 } 714 } 715 } 716 717 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 718 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 719 float x = TestFPComparison2.FLOATS[i]; 720 float y = TestFPComparison2.FLOATS[j]; 721 int actual = test_float_BoolTest_ge_fixed_0_1(x, y); 722 int expected = golden_float_BoolTest_ge_fixed_0_1(x, y); 723 if (actual != expected) { 724 System.out.println("Float failed (ge, 0, 1), x: " + x + ", y: " + y + 725 ", actual: " + actual + ", expected: " + expected); 726 err++; 727 } 728 } 729 } 730 731 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 732 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 733 double x = TestFPComparison2.DOUBLES[i]; 734 double y = TestFPComparison2.DOUBLES[j]; 735 int actual = test_double_BoolTest_ge_fixed_0_1(x, y); 736 int expected = golden_double_BoolTest_ge_fixed_0_1(x, y); 737 if (actual != expected) { 738 System.out.println("Double failed (ge, 0, 1), x: " + x + ", y: " + y + 739 ", actual: " + actual + ", expected: " + expected); 740 err++; 741 } 742 } 743 } 744 745 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 746 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 747 float x = TestFPComparison2.FLOATS[i]; 748 float y = TestFPComparison2.FLOATS[j]; 749 int actual = test_float_BoolTest_ge_fixed_10_20(x, y); 750 int expected = golden_float_BoolTest_ge_fixed_10_20(x, y); 751 if (actual != expected) { 752 System.out.println("Float failed (ge, 10, 20), x: " + x + ", y: " + y + 753 ", actual: " + actual + ", expected: " + expected); 754 err++; 755 } 756 } 757 } 758 759 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 760 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 761 double x = TestFPComparison2.DOUBLES[i]; 762 double y = TestFPComparison2.DOUBLES[j]; 763 int actual = test_double_BoolTest_ge_fixed_10_20(x, y); 764 int expected = golden_double_BoolTest_ge_fixed_10_20(x, y); 765 if (actual != expected) { 766 System.out.println("Double failed (ge, 10, 20), x: " + x + ", y: " + y + 767 ", actual: " + actual + ", expected: " + expected); 768 err++; 769 } 770 } 771 } 772 773 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 774 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 775 float x = TestFPComparison2.FLOATS[i]; 776 float y = TestFPComparison2.FLOATS[j]; 777 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 778 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 779 int a = TestFPComparison2.INTS[m]; 780 int b = TestFPComparison2.INTS[n]; 781 int actual = test_float_BoolTest_ge_variable_results(x, y, a, b); 782 int expected = golden_float_BoolTest_ge_variable_results(x, y, a, b); 783 if (actual != expected) { 784 System.out.println("Float failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 785 ", actual: " + actual + ", expected: " + expected); 786 err++; 787 } 788 } 789 } 790 } 791 } 792 793 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 794 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 795 double x = TestFPComparison2.DOUBLES[i]; 796 double y = TestFPComparison2.DOUBLES[j]; 797 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 798 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 799 int a = TestFPComparison2.INTS[m]; 800 int b = TestFPComparison2.INTS[n]; 801 int actual = test_double_BoolTest_ge_variable_results(x, y, a, b); 802 int expected = golden_double_BoolTest_ge_variable_results(x, y, a, b); 803 if (actual != expected) { 804 System.out.println("Double failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 805 ", actual: " + actual + ", expected: " + expected); 806 err++; 807 } 808 } 809 } 810 } 811 } 812 813 if (err != 0) { 814 throw new RuntimeException("Some tests failed"); 815 } 816 } 817 } 818 819 class Test_ge_cmove_fp_2 { 820 @Test 821 @IR(counts = {IRNode.CMOVE_F, "1"}, 822 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 823 public static float test_float_BoolTest_ge_fixed_1_0(float x, float y) { 824 // return 1 825 // when either x or y is NaN 826 // when neither is NaN, and x < y 827 // return 0 828 // when neither is NaN, and x >= y 829 return !(x >= y) ? 1.0f : 0.0f; 830 } 831 @DontCompile 832 public static float golden_float_BoolTest_ge_fixed_1_0(float x, float y) { 833 return !(x >= y) ? 1.0f : 0.0f; 834 } 835 836 @Test 837 @IR(counts = {IRNode.CMOVE_F, "1"}, 838 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 839 public static float test_double_BoolTest_ge_fixed_1_0(double x, double y) { 840 // return 1 841 // when either x or y is NaN 842 // when neither is NaN, and x < y 843 // return 0 844 // when neither is NaN, and x >= y 845 return !(x >= y) ? 1.0f : 0.0f; 846 } 847 @DontCompile 848 public static float golden_double_BoolTest_ge_fixed_1_0(double x, double y) { 849 return !(x >= y) ? 1.0f : 0.0f; 850 } 851 852 @Test 853 @IR(counts = {IRNode.CMOVE_F, "1"}, 854 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 855 public static float test_float_BoolTest_ge_fixed_0_1(float x, float y) { 856 return !(x >= y) ? 0.0f : 1.0f; 857 } 858 @DontCompile 859 public static float golden_float_BoolTest_ge_fixed_0_1(float x, float y) { 860 return !(x >= y) ? 0.0f : 1.0f; 861 } 862 863 @Test 864 @IR(counts = {IRNode.CMOVE_F, "1"}, 865 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 866 public static float test_double_BoolTest_ge_fixed_0_1(double x, double y) { 867 return !(x >= y) ? 0.0f : 1.0f; 868 } 869 @DontCompile 870 public static float golden_double_BoolTest_ge_fixed_0_1(double x, double y) { 871 return !(x >= y) ? 0.0f : 1.0f; 872 } 873 874 @Test 875 @IR(counts = {IRNode.CMOVE_F, "1"}, 876 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 877 public static float test_float_BoolTest_ge_fixed_10_20(float x, float y) { 878 return !(x >= y) ? 10.0f : 20.0f; 879 } 880 @DontCompile 881 public static float golden_float_BoolTest_ge_fixed_10_20(float x, float y) { 882 return !(x >= y) ? 10.0f : 20.0f; 883 } 884 885 @Test 886 @IR(counts = {IRNode.CMOVE_F, "1"}, 887 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 888 public static float test_double_BoolTest_ge_fixed_10_20(double x, double y) { 889 return !(x >= y) ? 10.0f : 20.0f; 890 } 891 @DontCompile 892 public static float golden_double_BoolTest_ge_fixed_10_20(double x, double y) { 893 return !(x >= y) ? 10.0f : 20.0f; 894 } 895 896 @Test 897 @IR(counts = {IRNode.CMOVE_F, "1"}, 898 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 899 public static float test_float_BoolTest_ge_variable_results(float x, float y, float a, float b) { 900 return !(x >= y) ? a : b; 901 } 902 @DontCompile 903 public static float golden_float_BoolTest_ge_variable_results(float x, float y, float a, float b) { 904 return !(x >= y) ? a : b; 905 } 906 907 @Test 908 @IR(counts = {IRNode.CMOVE_F, "1"}, 909 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 910 public static float test_double_BoolTest_ge_variable_results(double x, double y, float a, float b) { 911 return !(x >= y) ? a : b; 912 } 913 @DontCompile 914 public static float golden_double_BoolTest_ge_variable_results(double x, double y, float a, float b) { 915 return !(x >= y) ? a : b; 916 } 917 918 @Run(test = {"test_float_BoolTest_ge_fixed_1_0", "test_double_BoolTest_ge_fixed_1_0", 919 "test_float_BoolTest_ge_fixed_0_1", "test_double_BoolTest_ge_fixed_0_1", 920 "test_float_BoolTest_ge_fixed_10_20", "test_double_BoolTest_ge_fixed_10_20", 921 "test_float_BoolTest_ge_variable_results", "test_double_BoolTest_ge_variable_results"}) 922 public void runTests() { 923 int err = 0; 924 925 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 926 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 927 float x = TestFPComparison2.FLOATS[i]; 928 float y = TestFPComparison2.FLOATS[j]; 929 float actual = test_float_BoolTest_ge_fixed_1_0(x, y); 930 float expected = golden_float_BoolTest_ge_fixed_1_0(x, y); 931 if (actual != expected) { 932 System.out.println("Float failed (ge), x: " + x + ", y: " + y + 933 ", actual: " + actual + ", expected: " + expected); 934 err++; 935 } 936 } 937 } 938 939 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 940 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 941 double x = TestFPComparison2.DOUBLES[i]; 942 double y = TestFPComparison2.DOUBLES[j]; 943 float actual = test_double_BoolTest_ge_fixed_1_0(x, y); 944 float expected = golden_double_BoolTest_ge_fixed_1_0(x, y); 945 if (actual != expected) { 946 System.out.println("Double failed (ge), x: " + x + ", y: " + y + 947 ", actual: " + actual + ", expected: " + expected); 948 err++; 949 } 950 } 951 } 952 953 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 954 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 955 float x = TestFPComparison2.FLOATS[i]; 956 float y = TestFPComparison2.FLOATS[j]; 957 float actual = test_float_BoolTest_ge_fixed_0_1(x, y); 958 float expected = golden_float_BoolTest_ge_fixed_0_1(x, y); 959 if (actual != expected) { 960 System.out.println("Float failed (ge, 0, 1), x: " + x + ", y: " + y + 961 ", actual: " + actual + ", expected: " + expected); 962 err++; 963 } 964 } 965 } 966 967 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 968 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 969 double x = TestFPComparison2.DOUBLES[i]; 970 double y = TestFPComparison2.DOUBLES[j]; 971 float actual = test_double_BoolTest_ge_fixed_0_1(x, y); 972 float expected = golden_double_BoolTest_ge_fixed_0_1(x, y); 973 if (actual != expected) { 974 System.out.println("Double failed (ge, 0, 1), x: " + x + ", y: " + y + 975 ", actual: " + actual + ", expected: " + expected); 976 err++; 977 } 978 } 979 } 980 981 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 982 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 983 float x = TestFPComparison2.FLOATS[i]; 984 float y = TestFPComparison2.FLOATS[j]; 985 float actual = test_float_BoolTest_ge_fixed_10_20(x, y); 986 float expected = golden_float_BoolTest_ge_fixed_10_20(x, y); 987 if (actual != expected) { 988 System.out.println("Float failed (ge, 10, 20), x: " + x + ", y: " + y + 989 ", actual: " + actual + ", expected: " + expected); 990 err++; 991 } 992 } 993 } 994 995 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 996 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 997 double x = TestFPComparison2.DOUBLES[i]; 998 double y = TestFPComparison2.DOUBLES[j]; 999 float actual = test_double_BoolTest_ge_fixed_10_20(x, y); 1000 float expected = golden_double_BoolTest_ge_fixed_10_20(x, y); 1001 if (actual != expected) { 1002 System.out.println("Double failed (ge, 10, 20), x: " + x + ", y: " + y + 1003 ", actual: " + actual + ", expected: " + expected); 1004 err++; 1005 } 1006 } 1007 } 1008 1009 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1010 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1011 float x = TestFPComparison2.FLOATS[i]; 1012 float y = TestFPComparison2.FLOATS[j]; 1013 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1014 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1015 float a = TestFPComparison2.FLOATS[m]; 1016 float b = TestFPComparison2.FLOATS[n]; 1017 float actual = test_float_BoolTest_ge_variable_results(x, y, a, b); 1018 float expected = golden_float_BoolTest_ge_variable_results(x, y, a, b); 1019 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1020 System.out.println("Float failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1021 ", actual: " + actual + ", expected: " + expected); 1022 err++; 1023 } 1024 } 1025 } 1026 } 1027 } 1028 1029 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1030 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1031 double x = TestFPComparison2.DOUBLES[i]; 1032 double y = TestFPComparison2.DOUBLES[j]; 1033 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1034 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1035 float a = TestFPComparison2.FLOATS[m]; 1036 float b = TestFPComparison2.FLOATS[n]; 1037 float actual = test_double_BoolTest_ge_variable_results(x, y, a, b); 1038 float expected = golden_double_BoolTest_ge_variable_results(x, y, a, b); 1039 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1040 System.out.println("Double failed (ge), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1041 ", actual: " + actual + ", expected: " + expected); 1042 err++; 1043 } 1044 } 1045 } 1046 } 1047 } 1048 1049 if (err != 0) { 1050 throw new RuntimeException("Some tests failed"); 1051 } 1052 } 1053 } 1054 1055 class Test_gt_1 { 1056 @Test 1057 @IR(counts = {IRNode.CMOVE_I, "1"}, 1058 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1059 public static int test_float_BoolTest_gt_fixed_1_0(float x, float y) { 1060 // return 1 1061 // when either x or y is NaN 1062 // when neither is NaN, and x >= y 1063 // return 0 1064 // when neither is NaN, and x < y 1065 return !(x < y) ? 1 : 0; 1066 } 1067 @DontCompile 1068 public static int golden_float_BoolTest_gt_fixed_1_0(float x, float y) { 1069 return !(x < y) ? 1 : 0; 1070 } 1071 1072 @Test 1073 @IR(counts = {IRNode.CMOVE_I, "1"}, 1074 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1075 public static int test_double_BoolTest_gt_fixed_1_0(double x, double y) { 1076 // return 1 1077 // when either x or y is NaN 1078 // when neither is NaN, and x >= y 1079 // return 0 1080 // when neither is NaN, and x < y 1081 return !(x < y) ? 1 : 0; 1082 } 1083 @DontCompile 1084 public static int golden_double_BoolTest_gt_fixed_1_0(double x, double y) { 1085 return !(x < y) ? 1 : 0; 1086 } 1087 1088 @Test 1089 @IR(counts = {IRNode.CMOVE_I, "1"}, 1090 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1091 public static int test_float_BoolTest_gt_fixed_0_1(float x, float y) { 1092 return !(x < y) ? 0 : 1; 1093 } 1094 @DontCompile 1095 public static int golden_float_BoolTest_gt_fixed_0_1(float x, float y) { 1096 return !(x < y) ? 0 : 1; 1097 } 1098 1099 @Test 1100 @IR(counts = {IRNode.CMOVE_I, "1"}, 1101 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1102 public static int test_double_BoolTest_gt_fixed_0_1(double x, double y) { 1103 return !(x < y) ? 0 : 1; 1104 } 1105 @DontCompile 1106 public static int golden_double_BoolTest_gt_fixed_0_1(double x, double y) { 1107 return !(x < y) ? 0 : 1; 1108 } 1109 1110 @Test 1111 @IR(counts = {IRNode.CMOVE_I, "1"}, 1112 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1113 public static int test_float_BoolTest_gt_fixed_10_20(float x, float y) { 1114 return !(x < y) ? 10 : 20; 1115 } 1116 @DontCompile 1117 public static int golden_float_BoolTest_gt_fixed_10_20(float x, float y) { 1118 return !(x < y) ? 10 : 20; 1119 } 1120 1121 @Test 1122 @IR(counts = {IRNode.CMOVE_I, "1"}, 1123 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1124 public static int test_double_BoolTest_gt_fixed_10_20(double x, double y) { 1125 return !(x < y) ? 10 : 20; 1126 } 1127 @DontCompile 1128 public static int golden_double_BoolTest_gt_fixed_10_20(double x, double y) { 1129 return !(x < y) ? 10 : 20; 1130 } 1131 1132 @Test 1133 @IR(counts = {IRNode.CMOVE_I, "1"}, 1134 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1135 public static int test_float_BoolTest_gt_variable_results(float x, float y, int a, int b) { 1136 return !(x < y) ? a : b; 1137 } 1138 @DontCompile 1139 public static int golden_float_BoolTest_gt_variable_results(float x, float y, int a, int b) { 1140 return !(x < y) ? a : b; 1141 } 1142 1143 @Test 1144 @IR(counts = {IRNode.CMOVE_I, "1"}, 1145 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1146 public static int test_double_BoolTest_gt_variable_results(double x, double y, int a, int b) { 1147 return !(x < y) ? a : b; 1148 } 1149 @DontCompile 1150 public static int golden_double_BoolTest_gt_variable_results(double x, double y, int a, int b) { 1151 return !(x < y) ? a : b; 1152 } 1153 1154 @Run(test = {"test_float_BoolTest_gt_fixed_1_0", "test_double_BoolTest_gt_fixed_1_0", 1155 "test_float_BoolTest_gt_fixed_0_1", "test_double_BoolTest_gt_fixed_0_1", 1156 "test_float_BoolTest_gt_fixed_10_20", "test_double_BoolTest_gt_fixed_10_20", 1157 "test_float_BoolTest_gt_variable_results", "test_double_BoolTest_gt_variable_results"}) 1158 public void runTests() { 1159 int err = 0; 1160 1161 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1162 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1163 float x = TestFPComparison2.FLOATS[i]; 1164 float y = TestFPComparison2.FLOATS[j]; 1165 int actual = test_float_BoolTest_gt_fixed_1_0(x, y); 1166 int expected = golden_float_BoolTest_gt_fixed_1_0(x, y); 1167 if (actual != expected) { 1168 System.out.println("Float failed (gt), x: " + x + ", y: " + y + 1169 ", actual: " + actual + ", expected: " + expected); 1170 err++; 1171 } 1172 } 1173 } 1174 1175 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1176 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1177 double x = TestFPComparison2.DOUBLES[i]; 1178 double y = TestFPComparison2.DOUBLES[j]; 1179 int actual = test_double_BoolTest_gt_fixed_1_0(x, y); 1180 int expected = golden_double_BoolTest_gt_fixed_1_0(x, y); 1181 if (actual != expected) { 1182 System.out.println("Double failed (gt), x: " + x + ", y: " + y + 1183 ", actual: " + actual + ", expected: " + expected); 1184 err++; 1185 } 1186 } 1187 } 1188 1189 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1190 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1191 float x = TestFPComparison2.FLOATS[i]; 1192 float y = TestFPComparison2.FLOATS[j]; 1193 int actual = test_float_BoolTest_gt_fixed_0_1(x, y); 1194 int expected = golden_float_BoolTest_gt_fixed_0_1(x, y); 1195 if (actual != expected) { 1196 System.out.println("Float failed (gt, 0, 1), x: " + x + ", y: " + y + 1197 ", actual: " + actual + ", expected: " + expected); 1198 err++; 1199 } 1200 } 1201 } 1202 1203 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1204 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1205 double x = TestFPComparison2.DOUBLES[i]; 1206 double y = TestFPComparison2.DOUBLES[j]; 1207 int actual = test_double_BoolTest_gt_fixed_0_1(x, y); 1208 int expected = golden_double_BoolTest_gt_fixed_0_1(x, y); 1209 if (actual != expected) { 1210 System.out.println("Double failed (gt, 0, 1), x: " + x + ", y: " + y + 1211 ", actual: " + actual + ", expected: " + expected); 1212 err++; 1213 } 1214 } 1215 } 1216 1217 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1218 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1219 float x = TestFPComparison2.FLOATS[i]; 1220 float y = TestFPComparison2.FLOATS[j]; 1221 int actual = test_float_BoolTest_gt_fixed_10_20(x, y); 1222 int expected = golden_float_BoolTest_gt_fixed_10_20(x, y); 1223 if (actual != expected) { 1224 System.out.println("Float failed (gt, 10, 20), x: " + x + ", y: " + y + 1225 ", actual: " + actual + ", expected: " + expected); 1226 err++; 1227 } 1228 } 1229 } 1230 1231 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1232 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1233 double x = TestFPComparison2.DOUBLES[i]; 1234 double y = TestFPComparison2.DOUBLES[j]; 1235 int actual = test_double_BoolTest_gt_fixed_10_20(x, y); 1236 int expected = golden_double_BoolTest_gt_fixed_10_20(x, y); 1237 if (actual != expected) { 1238 System.out.println("Double failed (gt, 10, 20), x: " + x + ", y: " + y + 1239 ", actual: " + actual + ", expected: " + expected); 1240 err++; 1241 } 1242 } 1243 } 1244 1245 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1246 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1247 float x = TestFPComparison2.FLOATS[i]; 1248 float y = TestFPComparison2.FLOATS[j]; 1249 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 1250 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 1251 int a = TestFPComparison2.INTS[m]; 1252 int b = TestFPComparison2.INTS[n]; 1253 int actual = test_float_BoolTest_gt_variable_results(x, y, a, b); 1254 int expected = golden_float_BoolTest_gt_variable_results(x, y, a, b); 1255 if (actual != expected) { 1256 System.out.println("Float failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1257 ", actual: " + actual + ", expected: " + expected); 1258 err++; 1259 } 1260 } 1261 } 1262 } 1263 } 1264 1265 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1266 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1267 double x = TestFPComparison2.DOUBLES[i]; 1268 double y = TestFPComparison2.DOUBLES[j]; 1269 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 1270 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 1271 int a = TestFPComparison2.INTS[m]; 1272 int b = TestFPComparison2.INTS[n]; 1273 int actual = test_double_BoolTest_gt_variable_results(x, y, a, b); 1274 int expected = golden_double_BoolTest_gt_variable_results(x, y, a, b); 1275 if (actual != expected) { 1276 System.out.println("Double failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1277 ", actual: " + actual + ", expected: " + expected); 1278 err++; 1279 } 1280 } 1281 } 1282 } 1283 } 1284 1285 if (err != 0) { 1286 throw new RuntimeException("Some tests failed"); 1287 } 1288 } 1289 } 1290 1291 class Test_gt_cmove_fp_1 { 1292 @Test 1293 @IR(counts = {IRNode.CMOVE_F, "1"}, 1294 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1295 public static float test_float_BoolTest_gt_fixed_1_0(float x, float y) { 1296 // return 1 1297 // when either x or y is NaN 1298 // when neither is NaN, and x >= y 1299 // return 0 1300 // when neither is NaN, and x < y 1301 return !(x < y) ? 1.0f : 0.0f; 1302 } 1303 @DontCompile 1304 public static float golden_float_BoolTest_gt_fixed_1_0(float x, float y) { 1305 return !(x < y) ? 1.0f : 0.0f; 1306 } 1307 1308 @Test 1309 @IR(counts = {IRNode.CMOVE_F, "1"}, 1310 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1311 public static float test_double_BoolTest_gt_fixed_1_0(double x, double y) { 1312 // return 1 1313 // when either x or y is NaN 1314 // when neither is NaN, and x >= y 1315 // return 0 1316 // when neither is NaN, and x < y 1317 return !(x < y) ? 1.0f : 0.0f; 1318 } 1319 @DontCompile 1320 public static float golden_double_BoolTest_gt_fixed_1_0(double x, double y) { 1321 return !(x < y) ? 1.0f : 0.0f; 1322 } 1323 1324 @Test 1325 @IR(counts = {IRNode.CMOVE_F, "1"}, 1326 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1327 public static float test_float_BoolTest_gt_fixed_0_1(float x, float y) { 1328 return !(x < y) ? 0.0f : 1.0f; 1329 } 1330 @DontCompile 1331 public static float golden_float_BoolTest_gt_fixed_0_1(float x, float y) { 1332 return !(x < y) ? 0.0f : 1.0f; 1333 } 1334 1335 @Test 1336 @IR(counts = {IRNode.CMOVE_F, "1"}, 1337 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1338 public static float test_double_BoolTest_gt_fixed_0_1(double x, double y) { 1339 return !(x < y) ? 0.0f : 1.0f; 1340 } 1341 @DontCompile 1342 public static float golden_double_BoolTest_gt_fixed_0_1(double x, double y) { 1343 return !(x < y) ? 0.0f : 1.0f; 1344 } 1345 1346 @Test 1347 @IR(counts = {IRNode.CMOVE_F, "1"}, 1348 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1349 public static float test_float_BoolTest_gt_fixed_10_20(float x, float y) { 1350 return !(x < y) ? 10.0f : 20.0f; 1351 } 1352 @DontCompile 1353 public static float golden_float_BoolTest_gt_fixed_10_20(float x, float y) { 1354 return !(x < y) ? 10.0f : 20.0f; 1355 } 1356 1357 @Test 1358 @IR(counts = {IRNode.CMOVE_F, "1"}, 1359 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1360 public static float test_double_BoolTest_gt_fixed_10_20(double x, double y) { 1361 return !(x < y) ? 10.0f : 20.0f; 1362 } 1363 @DontCompile 1364 public static float golden_double_BoolTest_gt_fixed_10_20(double x, double y) { 1365 return !(x < y) ? 10.0f : 20.0f; 1366 } 1367 1368 @Test 1369 @IR(counts = {IRNode.CMOVE_F, "1"}, 1370 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1371 public static float test_float_BoolTest_gt_variable_results(float x, float y, float a, float b) { 1372 return !(x < y) ? a : b; 1373 } 1374 @DontCompile 1375 public static float golden_float_BoolTest_gt_variable_results(float x, float y, float a, float b) { 1376 return !(x < y) ? a : b; 1377 } 1378 1379 @Test 1380 @IR(counts = {IRNode.CMOVE_F, "1"}, 1381 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1382 public static float test_double_BoolTest_gt_variable_results(double x, double y, float a, float b) { 1383 return !(x < y) ? a : b; 1384 } 1385 @DontCompile 1386 public static float golden_double_BoolTest_gt_variable_results(double x, double y, float a, float b) { 1387 return !(x < y) ? a : b; 1388 } 1389 1390 @Run(test = {"test_float_BoolTest_gt_fixed_1_0", "test_double_BoolTest_gt_fixed_1_0", 1391 "test_float_BoolTest_gt_fixed_0_1", "test_double_BoolTest_gt_fixed_0_1", 1392 "test_float_BoolTest_gt_fixed_10_20", "test_double_BoolTest_gt_fixed_10_20", 1393 "test_float_BoolTest_gt_variable_results", "test_double_BoolTest_gt_variable_results"}) 1394 public void runTests() { 1395 int err = 0; 1396 1397 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1398 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1399 float x = TestFPComparison2.FLOATS[i]; 1400 float y = TestFPComparison2.FLOATS[j]; 1401 float actual = test_float_BoolTest_gt_fixed_1_0(x, y); 1402 float expected = golden_float_BoolTest_gt_fixed_1_0(x, y); 1403 if (actual != expected) { 1404 System.out.println("Float failed (gt), x: " + x + ", y: " + y + 1405 ", actual: " + actual + ", expected: " + expected); 1406 err++; 1407 } 1408 } 1409 } 1410 1411 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1412 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1413 double x = TestFPComparison2.DOUBLES[i]; 1414 double y = TestFPComparison2.DOUBLES[j]; 1415 float actual = test_double_BoolTest_gt_fixed_1_0(x, y); 1416 float expected = golden_double_BoolTest_gt_fixed_1_0(x, y); 1417 if (actual != expected) { 1418 System.out.println("Double failed (gt), x: " + x + ", y: " + y + 1419 ", actual: " + actual + ", expected: " + expected); 1420 err++; 1421 } 1422 } 1423 } 1424 1425 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1426 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1427 float x = TestFPComparison2.FLOATS[i]; 1428 float y = TestFPComparison2.FLOATS[j]; 1429 float actual = test_float_BoolTest_gt_fixed_0_1(x, y); 1430 float expected = golden_float_BoolTest_gt_fixed_0_1(x, y); 1431 if (actual != expected) { 1432 System.out.println("Float failed (gt, 0, 1), x: " + x + ", y: " + y + 1433 ", actual: " + actual + ", expected: " + expected); 1434 err++; 1435 } 1436 } 1437 } 1438 1439 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1440 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1441 double x = TestFPComparison2.DOUBLES[i]; 1442 double y = TestFPComparison2.DOUBLES[j]; 1443 float actual = test_double_BoolTest_gt_fixed_0_1(x, y); 1444 float expected = golden_double_BoolTest_gt_fixed_0_1(x, y); 1445 if (actual != expected) { 1446 System.out.println("Double failed (gt, 0, 1), x: " + x + ", y: " + y + 1447 ", actual: " + actual + ", expected: " + expected); 1448 err++; 1449 } 1450 } 1451 } 1452 1453 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1454 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1455 float x = TestFPComparison2.FLOATS[i]; 1456 float y = TestFPComparison2.FLOATS[j]; 1457 float actual = test_float_BoolTest_gt_fixed_10_20(x, y); 1458 float expected = golden_float_BoolTest_gt_fixed_10_20(x, y); 1459 if (actual != expected) { 1460 System.out.println("Float failed (gt, 10, 20), x: " + x + ", y: " + y + 1461 ", actual: " + actual + ", expected: " + expected); 1462 err++; 1463 } 1464 } 1465 } 1466 1467 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1468 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1469 double x = TestFPComparison2.DOUBLES[i]; 1470 double y = TestFPComparison2.DOUBLES[j]; 1471 float actual = test_double_BoolTest_gt_fixed_10_20(x, y); 1472 float expected = golden_double_BoolTest_gt_fixed_10_20(x, y); 1473 if (actual != expected) { 1474 System.out.println("Double failed (gt, 10, 20), x: " + x + ", y: " + y + 1475 ", actual: " + actual + ", expected: " + expected); 1476 err++; 1477 } 1478 } 1479 } 1480 1481 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1482 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1483 float x = TestFPComparison2.FLOATS[i]; 1484 float y = TestFPComparison2.FLOATS[j]; 1485 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1486 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1487 float a = TestFPComparison2.FLOATS[m]; 1488 float b = TestFPComparison2.FLOATS[n]; 1489 float actual = test_float_BoolTest_gt_variable_results(x, y, a, b); 1490 float expected = golden_float_BoolTest_gt_variable_results(x, y, a, b); 1491 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1492 System.out.println("Float failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1493 ", actual: " + actual + ", expected: " + expected); 1494 err++; 1495 } 1496 } 1497 } 1498 } 1499 } 1500 1501 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1502 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1503 double x = TestFPComparison2.DOUBLES[i]; 1504 double y = TestFPComparison2.DOUBLES[j]; 1505 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1506 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1507 float a = TestFPComparison2.FLOATS[m]; 1508 float b = TestFPComparison2.FLOATS[n]; 1509 float actual = test_double_BoolTest_gt_variable_results(x, y, a, b); 1510 float expected = golden_double_BoolTest_gt_variable_results(x, y, a, b); 1511 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1512 System.out.println("Double failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1513 ", actual: " + actual + ", expected: " + expected); 1514 err++; 1515 } 1516 } 1517 } 1518 } 1519 } 1520 1521 if (err != 0) { 1522 throw new RuntimeException("Some tests failed"); 1523 } 1524 } 1525 } 1526 1527 class Test_gt_2 { 1528 @Test 1529 @IR(counts = {IRNode.CMOVE_I, "1"}, 1530 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1531 public static int test_float_BoolTest_gt_fixed_1_0(float x, float y) { 1532 // return 1 1533 // when either x or y is NaN 1534 // when neither is NaN, and x <= y 1535 // return 0 1536 // when neither is NaN, and x > y 1537 return !(x > y) ? 1 : 0; 1538 } 1539 @DontCompile 1540 public static int golden_float_BoolTest_gt_fixed_1_0(float x, float y) { 1541 return !(x > y) ? 1 : 0; 1542 } 1543 1544 @Test 1545 @IR(counts = {IRNode.CMOVE_I, "1"}, 1546 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1547 public static int test_double_BoolTest_gt_fixed_1_0(double x, double y) { 1548 // return 1 1549 // when either x or y is NaN 1550 // when neither is NaN, and x <= y 1551 // return 0 1552 // when neither is NaN, and x > y 1553 return !(x > y) ? 1 : 0; 1554 } 1555 @DontCompile 1556 public static int golden_double_BoolTest_gt_fixed_1_0(double x, double y) { 1557 return !(x > y) ? 1 : 0; 1558 } 1559 1560 @Test 1561 @IR(counts = {IRNode.CMOVE_I, "1"}, 1562 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1563 public static int test_float_BoolTest_gt_fixed_0_1(float x, float y) { 1564 return !(x > y) ? 0 : 1; 1565 } 1566 @DontCompile 1567 public static int golden_float_BoolTest_gt_fixed_0_1(float x, float y) { 1568 return !(x > y) ? 0 : 1; 1569 } 1570 1571 @Test 1572 @IR(counts = {IRNode.CMOVE_I, "1"}, 1573 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1574 public static int test_double_BoolTest_gt_fixed_0_1(double x, double y) { 1575 return !(x > y) ? 0 : 1; 1576 } 1577 @DontCompile 1578 public static int golden_double_BoolTest_gt_fixed_0_1(double x, double y) { 1579 return !(x > y) ? 0 : 1; 1580 } 1581 1582 @Test 1583 @IR(counts = {IRNode.CMOVE_I, "1"}, 1584 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1585 public static int test_float_BoolTest_gt_fixed_10_20(float x, float y) { 1586 return !(x > y) ? 10 : 20; 1587 } 1588 @DontCompile 1589 public static int golden_float_BoolTest_gt_fixed_10_20(float x, float y) { 1590 return !(x > y) ? 10 : 20; 1591 } 1592 1593 @Test 1594 @IR(counts = {IRNode.CMOVE_I, "1"}, 1595 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1596 public static int test_double_BoolTest_gt_fixed_10_20(double x, double y) { 1597 return !(x > y) ? 10 : 20; 1598 } 1599 @DontCompile 1600 public static int golden_double_BoolTest_gt_fixed_10_20(double x, double y) { 1601 return !(x > y) ? 10 : 20; 1602 } 1603 1604 @Test 1605 @IR(counts = {IRNode.CMOVE_I, "1"}, 1606 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1607 public static int test_float_BoolTest_gt_variable_results(float x, float y, int a, int b) { 1608 return !(x > y) ? a : b; 1609 } 1610 @DontCompile 1611 public static int golden_float_BoolTest_gt_variable_results(float x, float y, int a, int b) { 1612 return !(x > y) ? a : b; 1613 } 1614 1615 @Test 1616 @IR(counts = {IRNode.CMOVE_I, "1"}, 1617 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1618 public static int test_double_BoolTest_gt_variable_results(double x, double y, int a, int b) { 1619 return !(x > y) ? a : b; 1620 } 1621 @DontCompile 1622 public static int golden_double_BoolTest_gt_variable_results(double x, double y, int a, int b) { 1623 return !(x > y) ? a : b; 1624 } 1625 1626 @Run(test = {"test_float_BoolTest_gt_fixed_1_0", "test_double_BoolTest_gt_fixed_1_0", 1627 "test_float_BoolTest_gt_fixed_0_1", "test_double_BoolTest_gt_fixed_0_1", 1628 "test_float_BoolTest_gt_fixed_10_20", "test_double_BoolTest_gt_fixed_10_20", 1629 "test_float_BoolTest_gt_variable_results", "test_double_BoolTest_gt_variable_results"}) 1630 public void runTests() { 1631 int err = 0; 1632 1633 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1634 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1635 float x = TestFPComparison2.FLOATS[i]; 1636 float y = TestFPComparison2.FLOATS[j]; 1637 int actual = test_float_BoolTest_gt_fixed_1_0(x, y); 1638 int expected = golden_float_BoolTest_gt_fixed_1_0(x, y); 1639 if (actual != expected) { 1640 System.out.println("Float failed (gt), x: " + x + ", y: " + y + 1641 ", actual: " + actual + ", expected: " + expected); 1642 err++; 1643 } 1644 } 1645 } 1646 1647 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1648 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1649 double x = TestFPComparison2.DOUBLES[i]; 1650 double y = TestFPComparison2.DOUBLES[j]; 1651 int actual = test_double_BoolTest_gt_fixed_1_0(x, y); 1652 int expected = golden_double_BoolTest_gt_fixed_1_0(x, y); 1653 if (actual != expected) { 1654 System.out.println("Double failed (gt), x: " + x + ", y: " + y + 1655 ", actual: " + actual + ", expected: " + expected); 1656 err++; 1657 } 1658 } 1659 } 1660 1661 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1662 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1663 float x = TestFPComparison2.FLOATS[i]; 1664 float y = TestFPComparison2.FLOATS[j]; 1665 int actual = test_float_BoolTest_gt_fixed_0_1(x, y); 1666 int expected = golden_float_BoolTest_gt_fixed_0_1(x, y); 1667 if (actual != expected) { 1668 System.out.println("Float failed (gt, 0, 1), x: " + x + ", y: " + y + 1669 ", actual: " + actual + ", expected: " + expected); 1670 err++; 1671 } 1672 } 1673 } 1674 1675 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1676 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1677 double x = TestFPComparison2.DOUBLES[i]; 1678 double y = TestFPComparison2.DOUBLES[j]; 1679 int actual = test_double_BoolTest_gt_fixed_0_1(x, y); 1680 int expected = golden_double_BoolTest_gt_fixed_0_1(x, y); 1681 if (actual != expected) { 1682 System.out.println("Double failed (gt, 0, 1), x: " + x + ", y: " + y + 1683 ", actual: " + actual + ", expected: " + expected); 1684 err++; 1685 } 1686 } 1687 } 1688 1689 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1690 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1691 float x = TestFPComparison2.FLOATS[i]; 1692 float y = TestFPComparison2.FLOATS[j]; 1693 int actual = test_float_BoolTest_gt_fixed_10_20(x, y); 1694 int expected = golden_float_BoolTest_gt_fixed_10_20(x, y); 1695 if (actual != expected) { 1696 System.out.println("Float failed (gt, 10, 20), x: " + x + ", y: " + y + 1697 ", actual: " + actual + ", expected: " + expected); 1698 err++; 1699 } 1700 } 1701 } 1702 1703 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1704 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1705 double x = TestFPComparison2.DOUBLES[i]; 1706 double y = TestFPComparison2.DOUBLES[j]; 1707 int actual = test_double_BoolTest_gt_fixed_10_20(x, y); 1708 int expected = golden_double_BoolTest_gt_fixed_10_20(x, y); 1709 if (actual != expected) { 1710 System.out.println("Double failed (gt, 10, 20), x: " + x + ", y: " + y + 1711 ", actual: " + actual + ", expected: " + expected); 1712 err++; 1713 } 1714 } 1715 } 1716 1717 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1718 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1719 float x = TestFPComparison2.FLOATS[i]; 1720 float y = TestFPComparison2.FLOATS[j]; 1721 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 1722 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 1723 int a = TestFPComparison2.INTS[m]; 1724 int b = TestFPComparison2.INTS[n]; 1725 int actual = test_float_BoolTest_gt_variable_results(x, y, a, b); 1726 int expected = golden_float_BoolTest_gt_variable_results(x, y, a, b); 1727 if (actual != expected) { 1728 System.out.println("Float failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1729 ", actual: " + actual + ", expected: " + expected); 1730 err++; 1731 } 1732 } 1733 } 1734 } 1735 } 1736 1737 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1738 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1739 double x = TestFPComparison2.DOUBLES[i]; 1740 double y = TestFPComparison2.DOUBLES[j]; 1741 for (int m = 0; m < TestFPComparison2.INTS.length; m++) { 1742 for (int n = 0; n < TestFPComparison2.INTS.length; n++) { 1743 int a = TestFPComparison2.INTS[m]; 1744 int b = TestFPComparison2.INTS[n]; 1745 int actual = test_double_BoolTest_gt_variable_results(x, y, a, b); 1746 int expected = golden_double_BoolTest_gt_variable_results(x, y, a, b); 1747 if (actual != expected) { 1748 System.out.println("Double failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1749 ", actual: " + actual + ", expected: " + expected); 1750 err++; 1751 } 1752 } 1753 } 1754 } 1755 } 1756 1757 if (err != 0) { 1758 throw new RuntimeException("Some tests failed"); 1759 } 1760 } 1761 } 1762 1763 class Test_gt_cmove_fp_2 { 1764 @Test 1765 @IR(counts = {IRNode.CMOVE_F, "1"}, 1766 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1767 public static float test_float_BoolTest_gt_fixed_1_0(float x, float y) { 1768 // return 1 1769 // when either x or y is NaN 1770 // when neither is NaN, and x <= y 1771 // return 0 1772 // when neither is NaN, and x > y 1773 return !(x > y) ? 1.0f : 0.0f; 1774 } 1775 @DontCompile 1776 public static float golden_float_BoolTest_gt_fixed_1_0(float x, float y) { 1777 return !(x > y) ? 1.0f : 0.0f; 1778 } 1779 1780 @Test 1781 @IR(counts = {IRNode.CMOVE_F, "1"}, 1782 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1783 public static float test_double_BoolTest_gt_fixed_1_0(double x, double y) { 1784 // return 1 1785 // when either x or y is NaN 1786 // when neither is NaN, and x <= y 1787 // return 0 1788 // when neither is NaN, and x > y 1789 return !(x > y) ? 1.0f : 0.0f; 1790 } 1791 @DontCompile 1792 public static float golden_double_BoolTest_gt_fixed_1_0(double x, double y) { 1793 return !(x > y) ? 1.0f : 0.0f; 1794 } 1795 1796 @Test 1797 @IR(counts = {IRNode.CMOVE_F, "1"}, 1798 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1799 public static float test_float_BoolTest_gt_fixed_0_1(float x, float y) { 1800 return !(x > y) ? 0.0f : 1.0f; 1801 } 1802 @DontCompile 1803 public static float golden_float_BoolTest_gt_fixed_0_1(float x, float y) { 1804 return !(x > y) ? 0.0f : 1.0f; 1805 } 1806 1807 @Test 1808 @IR(counts = {IRNode.CMOVE_F, "1"}, 1809 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1810 public static float test_double_BoolTest_gt_fixed_0_1(double x, double y) { 1811 return !(x > y) ? 0.0f : 1.0f; 1812 } 1813 @DontCompile 1814 public static float golden_double_BoolTest_gt_fixed_0_1(double x, double y) { 1815 return !(x > y) ? 0.0f : 1.0f; 1816 } 1817 1818 @Test 1819 @IR(counts = {IRNode.CMOVE_F, "1"}, 1820 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1821 public static float test_float_BoolTest_gt_fixed_10_20(float x, float y) { 1822 return !(x > y) ? 10.0f : 20.0f; 1823 } 1824 @DontCompile 1825 public static float golden_float_BoolTest_gt_fixed_10_20(float x, float y) { 1826 return !(x > y) ? 10.0f : 20.0f; 1827 } 1828 1829 @Test 1830 @IR(counts = {IRNode.CMOVE_F, "1"}, 1831 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1832 public static float test_double_BoolTest_gt_fixed_10_20(double x, double y) { 1833 return !(x > y) ? 10.0f : 20.0f; 1834 } 1835 @DontCompile 1836 public static float golden_double_BoolTest_gt_fixed_10_20(double x, double y) { 1837 return !(x > y) ? 10.0f : 20.0f; 1838 } 1839 1840 @Test 1841 @IR(counts = {IRNode.CMOVE_F, "1"}, 1842 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1843 public static float test_float_BoolTest_gt_variable_results(float x, float y, float a, float b) { 1844 return !(x > y) ? a : b; 1845 } 1846 @DontCompile 1847 public static float golden_float_BoolTest_gt_variable_results(float x, float y, float a, float b) { 1848 return !(x > y) ? a : b; 1849 } 1850 1851 @Test 1852 @IR(counts = {IRNode.CMOVE_F, "1"}, 1853 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 1854 public static float test_double_BoolTest_gt_variable_results(double x, double y, float a, float b) { 1855 return !(x > y) ? a : b; 1856 } 1857 @DontCompile 1858 public static float golden_double_BoolTest_gt_variable_results(double x, double y, float a, float b) { 1859 return !(x > y) ? a : b; 1860 } 1861 1862 @Run(test = {"test_float_BoolTest_gt_fixed_1_0", "test_double_BoolTest_gt_fixed_1_0", 1863 "test_float_BoolTest_gt_fixed_0_1", "test_double_BoolTest_gt_fixed_0_1", 1864 "test_float_BoolTest_gt_fixed_10_20", "test_double_BoolTest_gt_fixed_10_20", 1865 "test_float_BoolTest_gt_variable_results", "test_double_BoolTest_gt_variable_results"}) 1866 public void runTests() { 1867 int err = 0; 1868 1869 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1870 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1871 float x = TestFPComparison2.FLOATS[i]; 1872 float y = TestFPComparison2.FLOATS[j]; 1873 float actual = test_float_BoolTest_gt_fixed_1_0(x, y); 1874 float expected = golden_float_BoolTest_gt_fixed_1_0(x, y); 1875 if (actual != expected) { 1876 System.out.println("Float failed (gt), x: " + x + ", y: " + y + 1877 ", actual: " + actual + ", expected: " + expected); 1878 err++; 1879 } 1880 } 1881 } 1882 1883 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1884 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1885 double x = TestFPComparison2.DOUBLES[i]; 1886 double y = TestFPComparison2.DOUBLES[j]; 1887 float actual = test_double_BoolTest_gt_fixed_1_0(x, y); 1888 float expected = golden_double_BoolTest_gt_fixed_1_0(x, y); 1889 if (actual != expected) { 1890 System.out.println("Double failed (gt), x: " + x + ", y: " + y + 1891 ", actual: " + actual + ", expected: " + expected); 1892 err++; 1893 } 1894 } 1895 } 1896 1897 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1898 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1899 float x = TestFPComparison2.FLOATS[i]; 1900 float y = TestFPComparison2.FLOATS[j]; 1901 float actual = test_float_BoolTest_gt_fixed_0_1(x, y); 1902 float expected = golden_float_BoolTest_gt_fixed_0_1(x, y); 1903 if (actual != expected) { 1904 System.out.println("Float failed (gt, 0, 1), x: " + x + ", y: " + y + 1905 ", actual: " + actual + ", expected: " + expected); 1906 err++; 1907 } 1908 } 1909 } 1910 1911 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1912 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1913 double x = TestFPComparison2.DOUBLES[i]; 1914 double y = TestFPComparison2.DOUBLES[j]; 1915 float actual = test_double_BoolTest_gt_fixed_0_1(x, y); 1916 float expected = golden_double_BoolTest_gt_fixed_0_1(x, y); 1917 if (actual != expected) { 1918 System.out.println("Double failed (gt, 0, 1), x: " + x + ", y: " + y + 1919 ", actual: " + actual + ", expected: " + expected); 1920 err++; 1921 } 1922 } 1923 } 1924 1925 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1926 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1927 float x = TestFPComparison2.FLOATS[i]; 1928 float y = TestFPComparison2.FLOATS[j]; 1929 float actual = test_float_BoolTest_gt_fixed_10_20(x, y); 1930 float expected = golden_float_BoolTest_gt_fixed_10_20(x, y); 1931 if (actual != expected) { 1932 System.out.println("Float failed (gt, 10, 20), x: " + x + ", y: " + y + 1933 ", actual: " + actual + ", expected: " + expected); 1934 err++; 1935 } 1936 } 1937 } 1938 1939 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1940 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1941 double x = TestFPComparison2.DOUBLES[i]; 1942 double y = TestFPComparison2.DOUBLES[j]; 1943 float actual = test_double_BoolTest_gt_fixed_10_20(x, y); 1944 float expected = golden_double_BoolTest_gt_fixed_10_20(x, y); 1945 if (actual != expected) { 1946 System.out.println("Double failed (gt, 10, 20), x: " + x + ", y: " + y + 1947 ", actual: " + actual + ", expected: " + expected); 1948 err++; 1949 } 1950 } 1951 } 1952 1953 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 1954 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 1955 float x = TestFPComparison2.FLOATS[i]; 1956 float y = TestFPComparison2.FLOATS[j]; 1957 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1958 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1959 float a = TestFPComparison2.FLOATS[m]; 1960 float b = TestFPComparison2.FLOATS[n]; 1961 float actual = test_float_BoolTest_gt_variable_results(x, y, a, b); 1962 float expected = golden_float_BoolTest_gt_variable_results(x, y, a, b); 1963 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1964 System.out.println("Float failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1965 ", actual: " + actual + ", expected: " + expected); 1966 err++; 1967 } 1968 } 1969 } 1970 } 1971 } 1972 1973 for (int i = 0; i < TestFPComparison2.DOUBLES.length; i++) { 1974 for (int j = 0; j < TestFPComparison2.DOUBLES.length; j++) { 1975 double x = TestFPComparison2.DOUBLES[i]; 1976 double y = TestFPComparison2.DOUBLES[j]; 1977 for (int m = 0; m < TestFPComparison2.FLOATS.length; m++) { 1978 for (int n = 0; n < TestFPComparison2.FLOATS.length; n++) { 1979 float a = TestFPComparison2.FLOATS[m]; 1980 float b = TestFPComparison2.FLOATS[n]; 1981 float actual = test_double_BoolTest_gt_variable_results(x, y, a, b); 1982 float expected = golden_double_BoolTest_gt_variable_results(x, y, a, b); 1983 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 1984 System.out.println("Double failed (gt), x: " + x + ", y: " + y + ", a: " + a + ", b: " + b + 1985 ", actual: " + actual + ", expected: " + expected); 1986 err++; 1987 } 1988 } 1989 } 1990 } 1991 } 1992 1993 if (err != 0) { 1994 throw new RuntimeException("Some tests failed"); 1995 } 1996 } 1997 } 1998 1999 class Test_cmov_fp_cmp_fp_ge_3 { 2000 @Test 2001 @IR(counts = {IRNode.CMOVE_F, "1"}, 2002 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2003 public static float test_float_BoolTest_gt_x_lt_0(float x) { 2004 return x < 0 ? 0 : x; 2005 } 2006 @DontCompile 2007 public static float golden_float_BoolTest_gt_x_lt_0(float x) { 2008 return x < 0 ? 0 : x; 2009 } 2010 2011 @Test 2012 @IR(counts = {IRNode.CMOVE_F, "1"}, 2013 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2014 public static float test_float_BoolTest_gt_x_gt_0(float x) { 2015 return x > 0 ? 0 : x; 2016 } 2017 @DontCompile 2018 public static float golden_float_BoolTest_gt_x_gt_0(float x) { 2019 return x > 0 ? 0 : x; 2020 } 2021 2022 @Test 2023 @IR(counts = {IRNode.CMOVE_F, "1"}, 2024 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2025 public static float test_float_BoolTest_gt_neg_x_lt_0(float x) { 2026 return !(x < 0) ? 0 : x; 2027 } 2028 @DontCompile 2029 public static float golden_float_BoolTest_gt_neg_x_lt_0(float x) { 2030 return !(x < 0) ? 0 : x; 2031 } 2032 2033 @Test 2034 @IR(counts = {IRNode.CMOVE_F, "1"}, 2035 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2036 public static float test_float_BoolTest_gt_neg_x_gt_0(float x) { 2037 return !(x > 0) ? 0 : x; 2038 } 2039 @DontCompile 2040 public static float golden_float_BoolTest_gt_neg_x_gt_0(float x) { 2041 return !(x > 0) ? 0 : x; 2042 } 2043 2044 @Run(test = {"test_float_BoolTest_gt_x_lt_0", "test_float_BoolTest_gt_x_gt_0", 2045 "test_float_BoolTest_gt_neg_x_lt_0", "test_float_BoolTest_gt_neg_x_gt_0",}) 2046 public void runTests() { 2047 int err = 0; 2048 2049 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2050 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2051 float x = TestFPComparison2.FLOATS[i]; 2052 float actual = test_float_BoolTest_gt_x_lt_0(x); 2053 float expected = golden_float_BoolTest_gt_x_lt_0(x); 2054 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2055 System.out.println("Float failed (lt, x, 0), x: " + x + 2056 ", actual: " + actual + ", expected: " + expected); 2057 err++; 2058 } 2059 } 2060 } 2061 2062 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2063 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2064 float x = TestFPComparison2.FLOATS[i]; 2065 float actual = test_float_BoolTest_gt_x_gt_0(x); 2066 float expected = golden_float_BoolTest_gt_x_gt_0(x); 2067 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2068 System.out.println("Float failed (gt, x, 0), x: " + x + 2069 ", actual: " + actual + ", expected: " + expected); 2070 err++; 2071 } 2072 } 2073 } 2074 2075 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2076 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2077 float x = TestFPComparison2.FLOATS[i]; 2078 float actual = test_float_BoolTest_gt_neg_x_lt_0(x); 2079 float expected = golden_float_BoolTest_gt_neg_x_lt_0(x); 2080 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2081 System.out.println("Float failed (neg lt, x, 0), x: " + x + 2082 ", actual: " + actual + ", expected: " + expected); 2083 err++; 2084 } 2085 } 2086 } 2087 2088 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2089 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2090 float x = TestFPComparison2.FLOATS[i]; 2091 float actual = test_float_BoolTest_gt_neg_x_gt_0(x); 2092 float expected = golden_float_BoolTest_gt_neg_x_gt_0(x); 2093 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2094 System.out.println("Float failed (neg gt, x, 0), x: " + x + 2095 ", actual: " + actual + ", expected: " + expected); 2096 err++; 2097 } 2098 } 2099 } 2100 2101 if (err != 0) { 2102 throw new RuntimeException("Some tests failed"); 2103 } 2104 } 2105 } 2106 2107 class Test_cmov_fp_cmp_fp_ge_4 { 2108 @Test 2109 @IR(counts = {IRNode.CMOVE_F, "1"}, 2110 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2111 public static float test_float_BoolTest_ge_x_le_0(float x) { 2112 return x <= 0 ? 0 : x; 2113 } 2114 @DontCompile 2115 public static float golden_float_BoolTest_ge_x_le_0(float x) { 2116 return x <= 0 ? 0 : x; 2117 } 2118 2119 @Test 2120 @IR(counts = {IRNode.CMOVE_F, "1"}, 2121 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2122 public static float test_float_BoolTest_ge_x_ge_0(float x) { 2123 return x >= 0 ? 0 : x; 2124 } 2125 @DontCompile 2126 public static float golden_float_BoolTest_ge_x_ge_0(float x) { 2127 return x >= 0 ? 0 : x; 2128 } 2129 2130 @Test 2131 @IR(counts = {IRNode.CMOVE_F, "1"}, 2132 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2133 public static float test_float_BoolTest_ge_neg_x_le_0(float x) { 2134 return !(x <= 0) ? 0 : x; 2135 } 2136 @DontCompile 2137 public static float golden_float_BoolTest_ge_neg_x_le_0(float x) { 2138 return !(x <= 0) ? 0 : x; 2139 } 2140 2141 @Test 2142 @IR(counts = {IRNode.CMOVE_F, "1"}, 2143 applyIfPlatformOr = {"riscv64", "true", "aarch64", "true"}) 2144 public static float test_float_BoolTest_ge_neg_x_ge_0(float x) { 2145 return !(x >= 0) ? 0 : x; 2146 } 2147 @DontCompile 2148 public static float golden_float_BoolTest_ge_neg_x_ge_0(float x) { 2149 return !(x >= 0) ? 0 : x; 2150 } 2151 2152 @Run(test = {"test_float_BoolTest_ge_x_le_0", "test_float_BoolTest_ge_x_ge_0", 2153 "test_float_BoolTest_ge_neg_x_le_0", "test_float_BoolTest_ge_neg_x_ge_0",}) 2154 public void runTests() { 2155 int err = 0; 2156 2157 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2158 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2159 float x = TestFPComparison2.FLOATS[i]; 2160 float actual = test_float_BoolTest_ge_x_le_0(x); 2161 float expected = golden_float_BoolTest_ge_x_le_0(x); 2162 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2163 System.out.println("Float failed (le, x, 0), x: " + x + 2164 ", actual: " + actual + ", expected: " + expected); 2165 err++; 2166 } 2167 } 2168 } 2169 2170 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2171 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2172 float x = TestFPComparison2.FLOATS[i]; 2173 float actual = test_float_BoolTest_ge_x_ge_0(x); 2174 float expected = golden_float_BoolTest_ge_x_ge_0(x); 2175 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2176 System.out.println("Float failed (ge, x, 0), x: " + x + 2177 ", actual: " + actual + ", expected: " + expected); 2178 err++; 2179 } 2180 } 2181 } 2182 2183 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2184 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2185 float x = TestFPComparison2.FLOATS[i]; 2186 float actual = test_float_BoolTest_ge_neg_x_le_0(x); 2187 float expected = golden_float_BoolTest_ge_neg_x_le_0(x); 2188 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2189 System.out.println("Float failed (neg le, x, 0), x: " + x + 2190 ", actual: " + actual + ", expected: " + expected); 2191 err++; 2192 } 2193 } 2194 } 2195 2196 for (int i = 0; i < TestFPComparison2.FLOATS.length; i++) { 2197 for (int j = 0; j < TestFPComparison2.FLOATS.length; j++) { 2198 float x = TestFPComparison2.FLOATS[i]; 2199 float actual = test_float_BoolTest_ge_neg_x_ge_0(x); 2200 float expected = golden_float_BoolTest_ge_neg_x_ge_0(x); 2201 if (actual != expected && (!Float.isNaN(actual) || !Float.isNaN(expected))) { 2202 System.out.println("Float failed (neg ge, x, 0), x: " + x + 2203 ", actual: " + actual + ", expected: " + expected); 2204 err++; 2205 } 2206 } 2207 } 2208 2209 if (err != 0) { 2210 throw new RuntimeException("Some tests failed"); 2211 } 2212 } 2213 } --- EOF ---