1 /* 2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /** 25 * @test TestNewAcmp 26 * @summary Verifies correctness of the new acmp bytecode. 27 * @library /testlibrary /test/lib /compiler/whitebox / 28 * @compile -XDemitQtypes -XDenableValueTypes -XDallowWithFieldOperator -XDallowFlattenabilityModifiers TestNewAcmp.java 29 * @run driver ClassFileInstaller sun.hotspot.WhiteBox 30 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 31 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 32 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 33 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 34 * compiler.valhalla.valuetypes.TestNewAcmp 0 35 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 36 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 37 * -XX:+AlwaysIncrementalInline 38 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 39 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 40 * compiler.valhalla.valuetypes.TestNewAcmp 0 41 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 42 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 43 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 44 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 45 * compiler.valhalla.valuetypes.TestNewAcmp 1 46 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 47 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 48 * -XX:+AlwaysIncrementalInline 49 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 50 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 51 * compiler.valhalla.valuetypes.TestNewAcmp 1 52 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 53 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 54 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 55 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 56 * compiler.valhalla.valuetypes.TestNewAcmp 2 57 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 58 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 59 * -XX:+AlwaysIncrementalInline 60 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 61 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 62 * compiler.valhalla.valuetypes.TestNewAcmp 2 63 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 64 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 65 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 66 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 67 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 68 * compiler.valhalla.valuetypes.TestNewAcmp 0 69 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 70 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 71 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 72 * -XX:+AlwaysIncrementalInline 73 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 74 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 75 * compiler.valhalla.valuetypes.TestNewAcmp 0 76 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 77 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 78 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 79 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 80 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 81 * compiler.valhalla.valuetypes.TestNewAcmp 1 82 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 83 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 84 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 85 * -XX:+AlwaysIncrementalInline 86 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 87 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 88 * compiler.valhalla.valuetypes.TestNewAcmp 1 89 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbatch 90 * -XX:+EnableValhalla -XX:TypeProfileLevel=222 91 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 92 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 93 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 94 * compiler.valhalla.valuetypes.TestNewAcmp 2 95 * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 96 * -XX:+WhiteBoxAPI -Xbatch -XX:+EnableValhalla -XX:TypeProfileLevel=222 97 * -XX:+UnlockExperimentalVMOptions -XX:ACmpOnValues=3 98 * -XX:+AlwaysIncrementalInline 99 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::test* 100 * -XX:CompileCommand=dontinline,compiler.valhalla.valuetypes.TestNewAcmp::cmp* 101 * compiler.valhalla.valuetypes.TestNewAcmp 2 102 */ 103 104 package compiler.valhalla.valuetypes; 105 106 import jdk.test.lib.Asserts; 107 import java.lang.annotation.Retention; 108 import java.lang.annotation.RetentionPolicy; 109 import java.lang.invoke.*; 110 import java.lang.reflect.Method; 111 import java.util.regex.Pattern; 112 import java.util.regex.Matcher; 113 import java.util.Arrays; 114 import sun.hotspot.WhiteBox; 115 116 interface MyInterface { 117 118 } 119 120 value class MyValue1 implements MyInterface { 121 final int x = 0; 122 123 static MyValue1 createDefault() { 124 return MyValue1.default; 125 } 126 127 static MyValue1 setX(MyValue1 v, int x) { 128 return __WithField(v.x, x); 129 } 130 } 131 132 value class MyValue2 implements MyInterface { 133 final int x = 0; 134 135 static MyValue2 createDefault() { 136 return MyValue2.default; 137 } 138 139 static MyValue2 setX(MyValue2 v, int x) { 140 return __WithField(v.x, x); 141 } 142 } 143 144 class MyObject implements MyInterface { 145 int x; 146 } 147 148 // Mark test methods that return always false 149 @Retention(RetentionPolicy.RUNTIME) 150 @interface AlwaysFalse { 151 int[] valid_for() default {1, 2}; 152 } 153 154 // Mark test methods that return always true 155 @Retention(RetentionPolicy.RUNTIME) 156 @interface AlwaysTrue { 157 int[] valid_for() default {1, 2}; 158 } 159 160 // Mark test methods that return false if the argument is null 161 @Retention(RetentionPolicy.RUNTIME) 162 @interface FalseIfNull { } 163 164 // Mark test methods that return true if the argument is null 165 @Retention(RetentionPolicy.RUNTIME) 166 @interface TrueIfNull { } 167 168 public class TestNewAcmp { 169 170 public boolean testEq01_1(Object u1, Object u2) { 171 return get(u1) == u2; // new acmp 172 } 173 174 public boolean testEq01_2(Object u1, Object u2) { 175 return u1 == get(u2); // new acmp 176 } 177 178 public boolean testEq01_3(Object u1, Object u2) { 179 return get(u1) == get(u2); // new acmp 180 } 181 182 @FalseIfNull 183 public boolean testEq01_4(Object u1, Object u2) { 184 return getNotNull(u1) == u2; // new acmp without null check 185 } 186 187 @FalseIfNull 188 public boolean testEq01_5(Object u1, Object u2) { 189 return u1 == getNotNull(u2); // new acmp without null check 190 } 191 192 @FalseIfNull 193 public boolean testEq01_6(Object u1, Object u2) { 194 return getNotNull(u1) == getNotNull(u2); // new acmp without null check 195 } 196 197 public boolean testEq02_1(MyValue1 v1, MyValue1 v2) { 198 return get(v1) == (Object)v2; // only true if both null 199 } 200 201 public boolean testEq02_2(MyValue1 v1, MyValue1 v2) { 202 return (Object)v1 == get(v2); // only true if both null 203 } 204 205 public boolean testEq02_3(MyValue1 v1, MyValue1 v2) { 206 return get(v1) == get(v2); // only true if both null 207 } 208 209 public boolean testEq03_1(MyValue1 v, Object u) { 210 return get(v) == u; // only true if both null 211 } 212 213 public boolean testEq03_2(MyValue1 v, Object u) { 214 return (Object)v == get(u); // only true if both null 215 } 216 217 public boolean testEq03_3(MyValue1 v, Object u) { 218 return get(v) == get(u); // only true if both null 219 } 220 221 public boolean testEq04_1(Object u, MyValue1 v) { 222 return get(u) == (Object)v; // only true if both null 223 } 224 225 public boolean testEq04_2(Object u, MyValue1 v) { 226 return u == get(v); // only true if both null 227 } 228 229 public boolean testEq04_3(Object u, MyValue1 v) { 230 return get(u) == get(v); // only true if both null 231 } 232 233 public boolean testEq05_1(MyObject o, MyValue1 v) { 234 return get(o) == (Object)v; // only true if both null 235 } 236 237 public boolean testEq05_2(MyObject o, MyValue1 v) { 238 return o == get(v); // only true if both null 239 } 240 241 public boolean testEq05_3(MyObject o, MyValue1 v) { 242 return get(o) == get(v); // only true if both null 243 } 244 245 public boolean testEq06_1(MyValue1 v, MyObject o) { 246 return get(v) == o; // only true if both null 247 } 248 249 public boolean testEq06_2(MyValue1 v, MyObject o) { 250 return (Object)v == get(o); // only true if both null 251 } 252 253 public boolean testEq06_3(MyValue1 v, MyObject o) { 254 return get(v) == get(o); // only true if both null 255 } 256 257 @AlwaysFalse 258 public boolean testEq07_1(MyValue1 v1, MyValue1 v2) { 259 return getNotNull(v1) == (Object)v2; // false 260 } 261 262 @AlwaysFalse 263 public boolean testEq07_2(MyValue1 v1, MyValue1 v2) { 264 return (Object)v1 == getNotNull(v2); // false 265 } 266 267 @AlwaysFalse 268 public boolean testEq07_3(MyValue1 v1, MyValue1 v2) { 269 return getNotNull(v1) == getNotNull(v2); // false 270 } 271 272 @AlwaysFalse 273 public boolean testEq08_1(MyValue1 v, Object u) { 274 return getNotNull(v) == u; // false 275 } 276 277 @AlwaysFalse 278 public boolean testEq08_2(MyValue1 v, Object u) { 279 return (Object)v == getNotNull(u); // false 280 } 281 282 @AlwaysFalse 283 public boolean testEq08_3(MyValue1 v, Object u) { 284 return getNotNull(v) == getNotNull(u); // false 285 } 286 287 @AlwaysFalse 288 public boolean testEq09_1(Object u, MyValue1 v) { 289 return getNotNull(u) == (Object)v; // false 290 } 291 292 @AlwaysFalse 293 public boolean testEq09_2(Object u, MyValue1 v) { 294 return u == getNotNull(v); // false 295 } 296 297 @AlwaysFalse 298 public boolean testEq09_3(Object u, MyValue1 v) { 299 return getNotNull(u) == getNotNull(v); // false 300 } 301 302 @AlwaysFalse 303 public boolean testEq10_1(MyObject o, MyValue1 v) { 304 return getNotNull(o) == (Object)v; // false 305 } 306 307 @AlwaysFalse 308 public boolean testEq10_2(MyObject o, MyValue1 v) { 309 return o == getNotNull(v); // false 310 } 311 312 @AlwaysFalse 313 public boolean testEq10_3(MyObject o, MyValue1 v) { 314 return getNotNull(o) == getNotNull(v); // false 315 } 316 317 @AlwaysFalse 318 public boolean testEq11_1(MyValue1 v, MyObject o) { 319 return getNotNull(v) == o; // false 320 } 321 322 @AlwaysFalse 323 public boolean testEq11_2(MyValue1 v, MyObject o) { 324 return (Object)v == getNotNull(o); // false 325 } 326 327 @AlwaysFalse 328 public boolean testEq11_3(MyValue1 v, MyObject o) { 329 return getNotNull(v) == getNotNull(o); // false 330 } 331 332 public boolean testEq12_1(MyObject o1, MyObject o2) { 333 return get(o1) == o2; // old acmp 334 } 335 336 public boolean testEq12_2(MyObject o1, MyObject o2) { 337 return o1 == get(o2); // old acmp 338 } 339 340 public boolean testEq12_3(MyObject o1, MyObject o2) { 341 return get(o1) == get(o2); // old acmp 342 } 343 344 public boolean testEq13_1(Object u, MyObject o) { 345 return get(u) == o; // old acmp 346 } 347 348 public boolean testEq13_2(Object u, MyObject o) { 349 return u == get(o); // old acmp 350 } 351 352 public boolean testEq13_3(Object u, MyObject o) { 353 return get(u) == get(o); // old acmp 354 } 355 356 public boolean testEq14_1(MyObject o, Object u) { 357 return get(o) == u; // old acmp 358 } 359 360 public boolean testEq14_2(MyObject o, Object u) { 361 return o == get(u); // old acmp 362 } 363 364 public boolean testEq14_3(MyObject o, Object u) { 365 return get(o) == get(u); // old acmp 366 } 367 368 public boolean testEq15_1(Object[] a, Object u) { 369 return get(a) == u; // old acmp 370 } 371 372 public boolean testEq15_2(Object[] a, Object u) { 373 return a == get(u); // old acmp 374 } 375 376 public boolean testEq15_3(Object[] a, Object u) { 377 return get(a) == get(u); // old acmp 378 } 379 380 public boolean testEq16_1(Object u, Object[] a) { 381 return get(u) == a; // old acmp 382 } 383 384 public boolean testEq16_2(Object u, Object[] a) { 385 return u == get(a); // old acmp 386 } 387 388 public boolean testEq16_3(Object u, Object[] a) { 389 return get(u) == get(a); // old acmp 390 } 391 392 public boolean testEq17_1(Object[] a, MyValue1 v) { 393 return get(a) == (Object)v; // only true if both null 394 } 395 396 public boolean testEq17_2(Object[] a, MyValue1 v) { 397 return a == get(v); // only true if both null 398 } 399 400 public boolean testEq17_3(Object[] a, MyValue1 v) { 401 return get(a) == get(v); // only true if both null 402 } 403 404 public boolean testEq18_1(MyValue1 v, Object[] a) { 405 return get(v) == a; // only true if both null 406 } 407 408 public boolean testEq18_2(MyValue1 v, Object[] a) { 409 return (Object)v == get(a); // only true if both null 410 } 411 412 public boolean testEq18_3(MyValue1 v, Object[] a) { 413 return get(v) == get(a); // only true if both null 414 } 415 416 @AlwaysFalse 417 public boolean testEq19_1(Object[] a, MyValue1 v) { 418 return getNotNull(a) == (Object)v; // false 419 } 420 421 @AlwaysFalse 422 public boolean testEq19_2(Object[] a, MyValue1 v) { 423 return a == getNotNull(v); // false 424 } 425 426 @AlwaysFalse 427 public boolean testEq19_3(Object[] a, MyValue1 v) { 428 return getNotNull(a) == getNotNull(v); // false 429 } 430 431 @AlwaysFalse 432 public boolean testEq20_1(MyValue1 v, Object[] a) { 433 return getNotNull(v) == a; // false 434 } 435 436 @AlwaysFalse 437 public boolean testEq20_2(MyValue1 v, Object[] a) { 438 return (Object)v == getNotNull(a); // false 439 } 440 441 @AlwaysFalse 442 public boolean testEq20_3(MyValue1 v, Object[] a) { 443 return getNotNull(v) == getNotNull(a); // false 444 } 445 446 public boolean testEq21_1(MyInterface u1, MyInterface u2) { 447 return get(u1) == u2; // new acmp 448 } 449 450 public boolean testEq21_2(MyInterface u1, MyInterface u2) { 451 return u1 == get(u2); // new acmp 452 } 453 454 public boolean testEq21_3(MyInterface u1, MyInterface u2) { 455 return get(u1) == get(u2); // new acmp 456 } 457 458 @FalseIfNull 459 public boolean testEq21_4(MyInterface u1, MyInterface u2) { 460 return getNotNull(u1) == u2; // new acmp without null check 461 } 462 463 @FalseIfNull 464 public boolean testEq21_5(MyInterface u1, MyInterface u2) { 465 return u1 == getNotNull(u2); // new acmp without null check 466 } 467 468 @FalseIfNull 469 public boolean testEq21_6(MyInterface u1, MyInterface u2) { 470 return getNotNull(u1) == getNotNull(u2); // new acmp without null check 471 } 472 473 public boolean testEq22_1(MyValue1 v, MyInterface u) { 474 return get(v) == u; // only true if both null 475 } 476 477 public boolean testEq22_2(MyValue1 v, MyInterface u) { 478 return (Object)v == get(u); // only true if both null 479 } 480 481 public boolean testEq22_3(MyValue1 v, MyInterface u) { 482 return get(v) == get(u); // only true if both null 483 } 484 485 public boolean testEq23_1(MyInterface u, MyValue1 v) { 486 return get(u) == (Object)v; // only true if both null 487 } 488 489 public boolean testEq23_2(MyInterface u, MyValue1 v) { 490 return u == get(v); // only true if both null 491 } 492 493 public boolean testEq23_3(MyInterface u, MyValue1 v) { 494 return get(u) == get(v); // only true if both null 495 } 496 497 @AlwaysFalse 498 public boolean testEq24_1(MyValue1 v, MyInterface u) { 499 return getNotNull(v) == u; // false 500 } 501 502 @AlwaysFalse 503 public boolean testEq24_2(MyValue1 v, MyInterface u) { 504 return (Object)v == getNotNull(u); // false 505 } 506 507 @AlwaysFalse 508 public boolean testEq24_3(MyValue1 v, MyInterface u) { 509 return getNotNull(v) == getNotNull(u); // false 510 } 511 512 @AlwaysFalse 513 public boolean testEq25_1(MyInterface u, MyValue1 v) { 514 return getNotNull(u) == (Object)v; // false 515 } 516 517 @AlwaysFalse 518 public boolean testEq25_2(MyInterface u, MyValue1 v) { 519 return u == getNotNull(v); // false 520 } 521 522 @AlwaysFalse 523 public boolean testEq25_3(MyInterface u, MyValue1 v) { 524 return getNotNull(u) == getNotNull(v); // false 525 } 526 527 public boolean testEq26_1(MyInterface u, MyObject o) { 528 return get(u) == o; // old acmp 529 } 530 531 public boolean testEq26_2(MyInterface u, MyObject o) { 532 return u == get(o); // old acmp 533 } 534 535 public boolean testEq26_3(MyInterface u, MyObject o) { 536 return get(u) == get(o); // old acmp 537 } 538 539 public boolean testEq27_1(MyObject o, MyInterface u) { 540 return get(o) == u; // old acmp 541 } 542 543 public boolean testEq27_2(MyObject o, MyInterface u) { 544 return o == get(u); // old acmp 545 } 546 547 public boolean testEq27_3(MyObject o, MyInterface u) { 548 return get(o) == get(u); // old acmp 549 } 550 551 public boolean testEq28_1(MyInterface[] a, MyInterface u) { 552 return get(a) == u; // old acmp 553 } 554 555 public boolean testEq28_2(MyInterface[] a, MyInterface u) { 556 return a == get(u); // old acmp 557 } 558 559 public boolean testEq28_3(MyInterface[] a, MyInterface u) { 560 return get(a) == get(u); // old acmp 561 } 562 563 public boolean testEq29_1(MyInterface u, MyInterface[] a) { 564 return get(u) == a; // old acmp 565 } 566 567 public boolean testEq29_2(MyInterface u, MyInterface[] a) { 568 return u == get(a); // old acmp 569 } 570 571 public boolean testEq29_3(MyInterface u, MyInterface[] a) { 572 return get(u) == get(a); // old acmp 573 } 574 575 public boolean testEq30_1(MyInterface[] a, MyValue1 v) { 576 return get(a) == (Object)v; // only true if both null 577 } 578 579 public boolean testEq30_2(MyInterface[] a, MyValue1 v) { 580 return a == get(v); // only true if both null 581 } 582 583 public boolean testEq30_3(MyInterface[] a, MyValue1 v) { 584 return get(a) == get(v); // only true if both null 585 } 586 587 public boolean testEq31_1(MyValue1 v, MyInterface[] a) { 588 return get(v) == a; // only true if both null 589 } 590 591 public boolean testEq31_2(MyValue1 v, MyInterface[] a) { 592 return (Object)v == get(a); // only true if both null 593 } 594 595 public boolean testEq31_3(MyValue1 v, MyInterface[] a) { 596 return get(v) == get(a); // only true if both null 597 } 598 599 @AlwaysFalse 600 public boolean testEq32_1(MyInterface[] a, MyValue1 v) { 601 return getNotNull(a) == (Object)v; // false 602 } 603 604 @AlwaysFalse 605 public boolean testEq32_2(MyInterface[] a, MyValue1 v) { 606 return a == getNotNull(v); // false 607 } 608 609 @AlwaysFalse 610 public boolean testEq32_3(MyInterface[] a, MyValue1 v) { 611 return getNotNull(a) == getNotNull(v); // false 612 } 613 614 @AlwaysFalse 615 public boolean testEq33_1(MyValue1 v, MyInterface[] a) { 616 return getNotNull(v) == a; // false 617 } 618 619 @AlwaysFalse 620 public boolean testEq33_2(MyValue1 v, MyInterface[] a) { 621 return (Object)v == getNotNull(a); // false 622 } 623 624 @AlwaysFalse 625 public boolean testEq33_3(MyValue1 v, MyInterface[] a) { 626 return getNotNull(v) == getNotNull(a); // false 627 } 628 629 630 // Null tests 631 632 public boolean testNull01_1(MyValue1 v) { 633 return (Object)v == null; // old acmp 634 } 635 636 public boolean testNull01_2(MyValue1 v) { 637 return get(v) == null; // old acmp 638 } 639 640 public boolean testNull01_3(MyValue1 v) { 641 return (Object)v == get((Object)null); // old acmp 642 } 643 644 public boolean testNull01_4(MyValue1 v) { 645 return get(v) == get((Object)null); // old acmp 646 } 647 648 public boolean testNull02_1(MyValue1 v) { 649 return null == (Object)v; // old acmp 650 } 651 652 public boolean testNull02_2(MyValue1 v) { 653 return get((Object)null) == (Object)v; // old acmp 654 } 655 656 public boolean testNull02_3(MyValue1 v) { 657 return null == get(v); // old acmp 658 } 659 660 public boolean testNull02_4(MyValue1 v) { 661 return get((Object)null) == get(v); // old acmp 662 } 663 664 public boolean testNull03_1(Object u) { 665 return u == null; // old acmp 666 } 667 668 public boolean testNull03_2(Object u) { 669 return get(u) == null; // old acmp 670 } 671 672 public boolean testNull03_3(Object u) { 673 return u == get((Object)null); // old acmp 674 } 675 676 public boolean testNull03_4(Object u) { 677 return get(u) == get((Object)null); // old acmp 678 } 679 680 public boolean testNull04_1(Object u) { 681 return null == u; // old acmp 682 } 683 684 public boolean testNull04_2(Object u) { 685 return get((Object)null) == u; // old acmp 686 } 687 688 public boolean testNull04_3(Object u) { 689 return null == get(u); // old acmp 690 } 691 692 public boolean testNull04_4(Object u) { 693 return get((Object)null) == get(u); // old acmp 694 } 695 696 public boolean testNull05_1(MyObject o) { 697 return o == null; // old acmp 698 } 699 700 public boolean testNull05_2(MyObject o) { 701 return get(o) == null; // old acmp 702 } 703 704 public boolean testNull05_3(MyObject o) { 705 return o == get((Object)null); // old acmp 706 } 707 708 public boolean testNull05_4(MyObject o) { 709 return get(o) == get((Object)null); // old acmp 710 } 711 712 public boolean testNull06_1(MyObject o) { 713 return null == o; // old acmp 714 } 715 716 public boolean testNull06_2(MyObject o) { 717 return get((Object)null) == o; // old acmp 718 } 719 720 public boolean testNull06_3(MyObject o) { 721 return null == get(o); // old acmp 722 } 723 724 public boolean testNull06_4(MyObject o) { 725 return get((Object)null) == get(o); // old acmp 726 } 727 728 public boolean testNull07_1(MyInterface u) { 729 return u == null; // old acmp 730 } 731 732 public boolean testNull07_2(MyInterface u) { 733 return get(u) == null; // old acmp 734 } 735 736 public boolean testNull07_3(MyInterface u) { 737 return u == get((Object)null); // old acmp 738 } 739 740 public boolean testNull07_4(MyInterface u) { 741 return get(u) == get((Object)null); // old acmp 742 } 743 744 public boolean testNull08_1(MyInterface u) { 745 return null == u; // old acmp 746 } 747 748 public boolean testNull08_2(MyInterface u) { 749 return get((Object)null) == u; // old acmp 750 } 751 752 public boolean testNull08_3(MyInterface u) { 753 return null == get(u); // old acmp 754 } 755 756 public boolean testNull08_4(MyInterface u) { 757 return get((Object)null) == get(u); // old acmp 758 } 759 760 // Same tests as above but negated 761 762 public boolean testNotEq01_1(Object u1, Object u2) { 763 return get(u1) != u2; // new acmp 764 } 765 766 public boolean testNotEq01_2(Object u1, Object u2) { 767 return u1 != get(u2); // new acmp 768 } 769 770 public boolean testNotEq01_3(Object u1, Object u2) { 771 return get(u1) != get(u2); // new acmp 772 } 773 774 @TrueIfNull 775 public boolean testNotEq01_4(Object u1, Object u2) { 776 return getNotNull(u1) != u2; // new acmp without null check 777 } 778 779 @TrueIfNull 780 public boolean testNotEq01_5(Object u1, Object u2) { 781 return u1 != getNotNull(u2); // new acmp without null check 782 } 783 784 @TrueIfNull 785 public boolean testNotEq01_6(Object u1, Object u2) { 786 return getNotNull(u1) != getNotNull(u2); // new acmp without null check 787 } 788 789 public boolean testNotEq02_1(MyValue1 v1, MyValue1 v2) { 790 return get(v1) != (Object)v2; // only false if both null 791 } 792 793 public boolean testNotEq02_2(MyValue1 v1, MyValue1 v2) { 794 return (Object)v1 != get(v2); // only false if both null 795 } 796 797 public boolean testNotEq02_3(MyValue1 v1, MyValue1 v2) { 798 return get(v1) != get(v2); // only false if both null 799 } 800 801 public boolean testNotEq03_1(MyValue1 v, Object u) { 802 return get(v) != u; // only false if both null 803 } 804 805 public boolean testNotEq03_2(MyValue1 v, Object u) { 806 return (Object)v != get(u); // only false if both null 807 } 808 809 public boolean testNotEq03_3(MyValue1 v, Object u) { 810 return get(v) != get(u); // only false if both null 811 } 812 813 public boolean testNotEq04_1(Object u, MyValue1 v) { 814 return get(u) != (Object)v; // only false if both null 815 } 816 817 public boolean testNotEq04_2(Object u, MyValue1 v) { 818 return u != get(v); // only false if both null 819 } 820 821 public boolean testNotEq04_3(Object u, MyValue1 v) { 822 return get(u) != get(v); // only false if both null 823 } 824 825 public boolean testNotEq05_1(MyObject o, MyValue1 v) { 826 return get(o) != (Object)v; // only false if both null 827 } 828 829 public boolean testNotEq05_2(MyObject o, MyValue1 v) { 830 return o != get(v); // only false if both null 831 } 832 833 public boolean testNotEq05_3(MyObject o, MyValue1 v) { 834 return get(o) != get(v); // only false if both null 835 } 836 837 public boolean testNotEq06_1(MyValue1 v, MyObject o) { 838 return get(v) != o; // only false if both null 839 } 840 841 public boolean testNotEq06_2(MyValue1 v, MyObject o) { 842 return (Object)v != get(o); // only false if both null 843 } 844 845 public boolean testNotEq06_3(MyValue1 v, MyObject o) { 846 return get(v) != get(o); // only false if both null 847 } 848 849 @AlwaysTrue 850 public boolean testNotEq07_1(MyValue1 v1, MyValue1 v2) { 851 return getNotNull(v1) != (Object)v2; // true 852 } 853 854 @AlwaysTrue 855 public boolean testNotEq07_2(MyValue1 v1, MyValue1 v2) { 856 return (Object)v1 != getNotNull(v2); // true 857 } 858 859 @AlwaysTrue 860 public boolean testNotEq07_3(MyValue1 v1, MyValue1 v2) { 861 return getNotNull(v1) != getNotNull(v2); // true 862 } 863 864 @AlwaysTrue 865 public boolean testNotEq08_1(MyValue1 v, Object u) { 866 return getNotNull(v) != u; // true 867 } 868 869 @AlwaysTrue 870 public boolean testNotEq08_2(MyValue1 v, Object u) { 871 return (Object)v != getNotNull(u); // true 872 } 873 874 @AlwaysTrue 875 public boolean testNotEq08_3(MyValue1 v, Object u) { 876 return getNotNull(v) != getNotNull(u); // true 877 } 878 879 @AlwaysTrue 880 public boolean testNotEq09_1(Object u, MyValue1 v) { 881 return getNotNull(u) != (Object)v; // true 882 } 883 884 @AlwaysTrue 885 public boolean testNotEq09_2(Object u, MyValue1 v) { 886 return u != getNotNull(v); // true 887 } 888 889 @AlwaysTrue 890 public boolean testNotEq09_3(Object u, MyValue1 v) { 891 return getNotNull(u) != getNotNull(v); // true 892 } 893 894 @AlwaysTrue 895 public boolean testNotEq10_1(MyObject o, MyValue1 v) { 896 return getNotNull(o) != (Object)v; // true 897 } 898 899 @AlwaysTrue 900 public boolean testNotEq10_2(MyObject o, MyValue1 v) { 901 return o != getNotNull(v); // true 902 } 903 904 @AlwaysTrue 905 public boolean testNotEq10_3(MyObject o, MyValue1 v) { 906 return getNotNull(o) != getNotNull(v); // true 907 } 908 909 @AlwaysTrue 910 public boolean testNotEq11_1(MyValue1 v, MyObject o) { 911 return getNotNull(v) != o; // true 912 } 913 914 @AlwaysTrue 915 public boolean testNotEq11_2(MyValue1 v, MyObject o) { 916 return (Object)v != getNotNull(o); // true 917 } 918 919 @AlwaysTrue 920 public boolean testNotEq11_3(MyValue1 v, MyObject o) { 921 return getNotNull(v) != getNotNull(o); // true 922 } 923 924 public boolean testNotEq12_1(MyObject o1, MyObject o2) { 925 return get(o1) != o2; // old acmp 926 } 927 928 public boolean testNotEq12_2(MyObject o1, MyObject o2) { 929 return o1 != get(o2); // old acmp 930 } 931 932 public boolean testNotEq12_3(MyObject o1, MyObject o2) { 933 return get(o1) != get(o2); // old acmp 934 } 935 936 public boolean testNotEq13_1(Object u, MyObject o) { 937 return get(u) != o; // old acmp 938 } 939 940 public boolean testNotEq13_2(Object u, MyObject o) { 941 return u != get(o); // old acmp 942 } 943 944 public boolean testNotEq13_3(Object u, MyObject o) { 945 return get(u) != get(o); // old acmp 946 } 947 948 public boolean testNotEq14_1(MyObject o, Object u) { 949 return get(o) != u; // old acmp 950 } 951 952 public boolean testNotEq14_2(MyObject o, Object u) { 953 return o != get(u); // old acmp 954 } 955 956 public boolean testNotEq14_3(MyObject o, Object u) { 957 return get(o) != get(u); // old acmp 958 } 959 960 public boolean testNotEq15_1(Object[] a, Object u) { 961 return get(a) != u; // old acmp 962 } 963 964 public boolean testNotEq15_2(Object[] a, Object u) { 965 return a != get(u); // old acmp 966 } 967 968 public boolean testNotEq15_3(Object[] a, Object u) { 969 return get(a) != get(u); // old acmp 970 } 971 972 public boolean testNotEq16_1(Object u, Object[] a) { 973 return get(u) != a; // old acmp 974 } 975 976 public boolean testNotEq16_2(Object u, Object[] a) { 977 return u != get(a); // old acmp 978 } 979 980 public boolean testNotEq16_3(Object u, Object[] a) { 981 return get(u) != get(a); // old acmp 982 } 983 984 public boolean testNotEq17_1(Object[] a, MyValue1 v) { 985 return get(a) != (Object)v; // only false if both null 986 } 987 988 public boolean testNotEq17_2(Object[] a, MyValue1 v) { 989 return a != get(v); // only false if both null 990 } 991 992 public boolean testNotEq17_3(Object[] a, MyValue1 v) { 993 return get(a) != get(v); // only false if both null 994 } 995 996 public boolean testNotEq18_1(MyValue1 v, Object[] a) { 997 return get(v) != a; // only false if both null 998 } 999 1000 public boolean testNotEq18_2(MyValue1 v, Object[] a) { 1001 return (Object)v != get(a); // only false if both null 1002 } 1003 1004 public boolean testNotEq18_3(MyValue1 v, Object[] a) { 1005 return get(v) != get(a); // only false if both null 1006 } 1007 1008 @AlwaysTrue 1009 public boolean testNotEq19_1(Object[] a, MyValue1 v) { 1010 return getNotNull(a) != (Object)v; // true 1011 } 1012 1013 @AlwaysTrue 1014 public boolean testNotEq19_2(Object[] a, MyValue1 v) { 1015 return a != getNotNull(v); // true 1016 } 1017 1018 @AlwaysTrue 1019 public boolean testNotEq19_3(Object[] a, MyValue1 v) { 1020 return getNotNull(a) != getNotNull(v); // true 1021 } 1022 1023 @AlwaysTrue 1024 public boolean testNotEq20_1(MyValue1 v, Object[] a) { 1025 return getNotNull(v) != a; // true 1026 } 1027 1028 @AlwaysTrue 1029 public boolean testNotEq20_2(MyValue1 v, Object[] a) { 1030 return (Object)v != getNotNull(a); // true 1031 } 1032 1033 @AlwaysTrue 1034 public boolean testNotEq20_3(MyValue1 v, Object[] a) { 1035 return getNotNull(v) != getNotNull(a); // true 1036 } 1037 1038 public boolean testNotEq21_1(MyInterface u1, MyInterface u2) { 1039 return get(u1) != u2; // new acmp 1040 } 1041 1042 public boolean testNotEq21_2(MyInterface u1, MyInterface u2) { 1043 return u1 != get(u2); // new acmp 1044 } 1045 1046 public boolean testNotEq21_3(MyInterface u1, MyInterface u2) { 1047 return get(u1) != get(u2); // new acmp 1048 } 1049 1050 @TrueIfNull 1051 public boolean testNotEq21_4(MyInterface u1, MyInterface u2) { 1052 return getNotNull(u1) != u2; // new acmp without null check 1053 } 1054 1055 @TrueIfNull 1056 public boolean testNotEq21_5(MyInterface u1, MyInterface u2) { 1057 return u1 != getNotNull(u2); // new acmp without null check 1058 } 1059 1060 @TrueIfNull 1061 public boolean testNotEq21_6(MyInterface u1, MyInterface u2) { 1062 return getNotNull(u1) != getNotNull(u2); // new acmp without null check 1063 } 1064 1065 public boolean testNotEq22_1(MyValue1 v, MyInterface u) { 1066 return get(v) != u; // only false if both null 1067 } 1068 1069 public boolean testNotEq22_2(MyValue1 v, MyInterface u) { 1070 return (Object)v != get(u); // only false if both null 1071 } 1072 1073 public boolean testNotEq22_3(MyValue1 v, MyInterface u) { 1074 return get(v) != get(u); // only false if both null 1075 } 1076 1077 public boolean testNotEq23_1(MyInterface u, MyValue1 v) { 1078 return get(u) != (Object)v; // only false if both null 1079 } 1080 1081 public boolean testNotEq23_2(MyInterface u, MyValue1 v) { 1082 return u != get(v); // only false if both null 1083 } 1084 1085 public boolean testNotEq23_3(MyInterface u, MyValue1 v) { 1086 return get(u) != get(v); // only false if both null 1087 } 1088 1089 @AlwaysTrue 1090 public boolean testNotEq24_1(MyValue1 v, MyInterface u) { 1091 return getNotNull(v) != u; // true 1092 } 1093 1094 @AlwaysTrue 1095 public boolean testNotEq24_2(MyValue1 v, MyInterface u) { 1096 return (Object)v != getNotNull(u); // true 1097 } 1098 1099 @AlwaysTrue 1100 public boolean testNotEq24_3(MyValue1 v, MyInterface u) { 1101 return getNotNull(v) != getNotNull(u); // true 1102 } 1103 1104 @AlwaysTrue 1105 public boolean testNotEq25_1(MyInterface u, MyValue1 v) { 1106 return getNotNull(u) != (Object)v; // true 1107 } 1108 1109 @AlwaysTrue 1110 public boolean testNotEq25_2(MyInterface u, MyValue1 v) { 1111 return u != getNotNull(v); // true 1112 } 1113 1114 @AlwaysTrue 1115 public boolean testNotEq25_3(MyInterface u, MyValue1 v) { 1116 return getNotNull(u) != getNotNull(v); // true 1117 } 1118 1119 public boolean testNotEq26_1(MyInterface u, MyObject o) { 1120 return get(u) != o; // old acmp 1121 } 1122 1123 public boolean testNotEq26_2(MyInterface u, MyObject o) { 1124 return u != get(o); // old acmp 1125 } 1126 1127 public boolean testNotEq26_3(MyInterface u, MyObject o) { 1128 return get(u) != get(o); // old acmp 1129 } 1130 1131 public boolean testNotEq27_1(MyObject o, MyInterface u) { 1132 return get(o) != u; // old acmp 1133 } 1134 1135 public boolean testNotEq27_2(MyObject o, MyInterface u) { 1136 return o != get(u); // old acmp 1137 } 1138 1139 public boolean testNotEq27_3(MyObject o, MyInterface u) { 1140 return get(o) != get(u); // old acmp 1141 } 1142 1143 public boolean testNotEq28_1(MyInterface[] a, MyInterface u) { 1144 return get(a) != u; // old acmp 1145 } 1146 1147 public boolean testNotEq28_2(MyInterface[] a, MyInterface u) { 1148 return a != get(u); // old acmp 1149 } 1150 1151 public boolean testNotEq28_3(MyInterface[] a, MyInterface u) { 1152 return get(a) != get(u); // old acmp 1153 } 1154 1155 public boolean testNotEq29_1(MyInterface u, MyInterface[] a) { 1156 return get(u) != a; // old acmp 1157 } 1158 1159 public boolean testNotEq29_2(MyInterface u, MyInterface[] a) { 1160 return u != get(a); // old acmp 1161 } 1162 1163 public boolean testNotEq29_3(MyInterface u, MyInterface[] a) { 1164 return get(u) != get(a); // old acmp 1165 } 1166 1167 public boolean testNotEq30_1(MyInterface[] a, MyValue1 v) { 1168 return get(a) != (Object)v; // only false if both null 1169 } 1170 1171 public boolean testNotEq30_2(MyInterface[] a, MyValue1 v) { 1172 return a != get(v); // only false if both null 1173 } 1174 1175 public boolean testNotEq30_3(MyInterface[] a, MyValue1 v) { 1176 return get(a) != get(v); // only false if both null 1177 } 1178 1179 public boolean testNotEq31_1(MyValue1 v, MyInterface[] a) { 1180 return get(v) != a; // only false if both null 1181 } 1182 1183 public boolean testNotEq31_2(MyValue1 v, MyInterface[] a) { 1184 return (Object)v != get(a); // only false if both null 1185 } 1186 1187 public boolean testNotEq31_3(MyValue1 v, MyInterface[] a) { 1188 return get(v) != get(a); // only false if both null 1189 } 1190 1191 @AlwaysTrue 1192 public boolean testNotEq32_1(MyInterface[] a, MyValue1 v) { 1193 return getNotNull(a) != (Object)v; // true 1194 } 1195 1196 @AlwaysTrue 1197 public boolean testNotEq32_2(MyInterface[] a, MyValue1 v) { 1198 return a != getNotNull(v); // true 1199 } 1200 1201 @AlwaysTrue 1202 public boolean testNotEq32_3(MyInterface[] a, MyValue1 v) { 1203 return getNotNull(a) != getNotNull(v); // true 1204 } 1205 1206 @AlwaysTrue 1207 public boolean testNotEq33_1(MyValue1 v, MyInterface[] a) { 1208 return getNotNull(v) != a; // true 1209 } 1210 1211 @AlwaysTrue 1212 public boolean testNotEq33_2(MyValue1 v, MyInterface[] a) { 1213 return (Object)v != getNotNull(a); // true 1214 } 1215 1216 @AlwaysTrue 1217 public boolean testNotEq33_3(MyValue1 v, MyInterface[] a) { 1218 return getNotNull(v) != getNotNull(a); // true 1219 } 1220 1221 // Null tests 1222 1223 public boolean testNotNull01_1(MyValue1 v) { 1224 return (Object)v != null; // old acmp 1225 } 1226 1227 public boolean testNotNull01_2(MyValue1 v) { 1228 return get(v) != null; // old acmp 1229 } 1230 1231 public boolean testNotNull01_3(MyValue1 v) { 1232 return (Object)v != get((Object)null); // old acmp 1233 } 1234 1235 public boolean testNotNull01_4(MyValue1 v) { 1236 return get(v) != get((Object)null); // old acmp 1237 } 1238 1239 public boolean testNotNull02_1(MyValue1 v) { 1240 return null != (Object)v; // old acmp 1241 } 1242 1243 public boolean testNotNull02_2(MyValue1 v) { 1244 return get((Object)null) != (Object)v; // old acmp 1245 } 1246 1247 public boolean testNotNull02_3(MyValue1 v) { 1248 return null != get(v); // old acmp 1249 } 1250 1251 public boolean testNotNull02_4(MyValue1 v) { 1252 return get((Object)null) != get(v); // old acmp 1253 } 1254 1255 public boolean testNotNull03_1(Object u) { 1256 return u != null; // old acmp 1257 } 1258 1259 public boolean testNotNull03_2(Object u) { 1260 return get(u) != null; // old acmp 1261 } 1262 1263 public boolean testNotNull03_3(Object u) { 1264 return u != get((Object)null); // old acmp 1265 } 1266 1267 public boolean testNotNull03_4(Object u) { 1268 return get(u) != get((Object)null); // old acmp 1269 } 1270 1271 public boolean testNotNull04_1(Object u) { 1272 return null != u; // old acmp 1273 } 1274 1275 public boolean testNotNull04_2(Object u) { 1276 return get((Object)null) != u; // old acmp 1277 } 1278 1279 public boolean testNotNull04_3(Object u) { 1280 return null != get(u); // old acmp 1281 } 1282 1283 public boolean testNotNull04_4(Object u) { 1284 return get((Object)null) != get(u); // old acmp 1285 } 1286 1287 public boolean testNotNull05_1(MyObject o) { 1288 return o != null; // old acmp 1289 } 1290 1291 public boolean testNotNull05_2(MyObject o) { 1292 return get(o) != null; // old acmp 1293 } 1294 1295 public boolean testNotNull05_3(MyObject o) { 1296 return o != get((Object)null); // old acmp 1297 } 1298 1299 public boolean testNotNull05_4(MyObject o) { 1300 return get(o) != get((Object)null); // old acmp 1301 } 1302 1303 public boolean testNotNull06_1(MyObject o) { 1304 return null != o; // old acmp 1305 } 1306 1307 public boolean testNotNull06_2(MyObject o) { 1308 return get((Object)null) != o; // old acmp 1309 } 1310 1311 public boolean testNotNull06_3(MyObject o) { 1312 return null != get(o); // old acmp 1313 } 1314 1315 public boolean testNotNull06_4(MyObject o) { 1316 return get((Object)null) != get(o); // old acmp 1317 } 1318 1319 public boolean testNotNull07_1(MyInterface u) { 1320 return u != null; // old acmp 1321 } 1322 1323 public boolean testNotNull07_2(MyInterface u) { 1324 return get(u) != null; // old acmp 1325 } 1326 1327 public boolean testNotNull07_3(MyInterface u) { 1328 return u != get((Object)null); // old acmp 1329 } 1330 1331 public boolean testNotNull07_4(MyInterface u) { 1332 return get(u) != get((Object)null); // old acmp 1333 } 1334 1335 public boolean testNotNull08_1(MyInterface u) { 1336 return null != u; // old acmp 1337 } 1338 1339 public boolean testNotNull08_2(MyInterface u) { 1340 return get((Object)null) != u; // old acmp 1341 } 1342 1343 public boolean testNotNull08_3(MyInterface u) { 1344 return null != get(u); // old acmp 1345 } 1346 1347 public boolean testNotNull08_4(MyInterface u) { 1348 return get((Object)null) != get(u); // old acmp 1349 } 1350 1351 // The following methods are used with -XX:+AlwaysIncrementalInline to hide exact types during parsing 1352 1353 public Object get(Object u) { 1354 return u; 1355 } 1356 1357 public Object getNotNull(Object u) { 1358 return (u != null) ? u : new Object(); 1359 } 1360 1361 public Object get(MyValue1 v) { 1362 return v; 1363 } 1364 1365 public Object getNotNull(MyValue1 v) { 1366 return ((Object)v != null) ? v : MyValue1.createDefault(); 1367 } 1368 1369 public Object get(MyObject o) { 1370 return o; 1371 } 1372 1373 public Object getNotNull(MyObject o) { 1374 return (o != null) ? o : MyValue1.createDefault(); 1375 } 1376 1377 public Object get(Object[] a) { 1378 return a; 1379 } 1380 1381 public Object getNotNull(Object[] a) { 1382 return (a != null) ? a : new Object[1]; 1383 } 1384 1385 public boolean trueIfNull(Method m) { 1386 return m.isAnnotationPresent(TrueIfNull.class); 1387 } 1388 1389 public boolean falseIfNull(Method m) { 1390 return m.isAnnotationPresent(FalseIfNull.class); 1391 } 1392 1393 public boolean alwaysTrue(Method m) { 1394 return m.isAnnotationPresent(AlwaysTrue.class) && 1395 Arrays.asList(((AlwaysTrue)m.getAnnotation(AlwaysTrue.class)).valid_for()).contains(ACmpOnValues); 1396 } 1397 1398 public boolean alwaysFalse(Method m) { 1399 return m.isAnnotationPresent(AlwaysFalse.class) && 1400 Arrays.asList(((AlwaysFalse)m.getAnnotation(AlwaysFalse.class)).valid_for()).contains(ACmpOnValues); 1401 } 1402 1403 public boolean isNegated(Method m) { 1404 return m.getName().startsWith("testNot"); 1405 } 1406 1407 // Tests with profiling 1408 public boolean cmpAlwaysEqual1(Object a, Object b) { 1409 return a == b; 1410 } 1411 1412 public boolean cmpAlwaysEqual2(Object a, Object b) { 1413 return a != b; 1414 } 1415 1416 public boolean cmpAlwaysEqual3(Object a) { 1417 return a == a; 1418 } 1419 1420 public boolean cmpAlwaysEqual4(Object a) { 1421 return a != a; 1422 } 1423 1424 public boolean cmpAlwaysUnEqual1(Object a, Object b) { 1425 return a == b; 1426 } 1427 1428 public boolean cmpAlwaysUnEqual2(Object a, Object b) { 1429 return a != b; 1430 } 1431 1432 public boolean cmpAlwaysUnEqual3(Object a) { 1433 return a == a; 1434 } 1435 1436 public boolean cmpAlwaysUnEqual4(Object a) { 1437 return a != a; 1438 } 1439 1440 public boolean cmpSometimesEqual1(Object a) { 1441 return a == a; 1442 } 1443 1444 public boolean cmpSometimesEqual2(Object a) { 1445 return a != a; 1446 } 1447 1448 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); 1449 protected static final int COMP_LEVEL_FULL_OPTIMIZATION = 4; 1450 protected static final long ACmpOnValues = (Long)WHITE_BOX.getVMFlag("ACmpOnValues"); 1451 1452 public void runTest(Method m, Object[] args, int warmup, int nullMode, boolean[][] equalities) throws Exception { 1453 Class<?>[] parameterTypes = m.getParameterTypes(); 1454 int parameterCount = parameterTypes.length; 1455 // Nullness mode for first argument 1456 // 0: default, 1: never null, 2: always null 1457 int start = (nullMode != 1) ? 0 : 1; 1458 int end = (nullMode != 2) ? args.length : 1; 1459 for (int i = start; i < end; ++i) { 1460 if (args[i] != null && !parameterTypes[0].isInstance(args[i])) { 1461 continue; 1462 } 1463 if (args[i] == null && parameterTypes[0] == MyValue1.class.asValueType()) { 1464 continue; 1465 } 1466 if (parameterCount == 1) { 1467 // Null checks 1468 System.out.print("Testing " + m.getName() + "(" + args[i] + ")"); 1469 // Avoid acmp in the computation of the expected result! 1470 boolean expected = isNegated(m) ? (i != 0) : (i == 0); 1471 for (int run = 0; run < warmup; ++run) { 1472 Boolean result = (Boolean)m.invoke(this, args[i]); 1473 if (result != expected && WHITE_BOX.isMethodCompiled(m, false)) { 1474 System.out.println(" = " + result); 1475 throw new RuntimeException("Test failed: should return " + expected); 1476 } 1477 } 1478 System.out.println(" = " + expected); 1479 } else { 1480 // Equality checks 1481 for (int j = 0; j < args.length; ++j) { 1482 if (args[j] != null && !parameterTypes[1].isInstance(args[j])) { 1483 continue; 1484 } 1485 if (args[j] == null && parameterTypes[1] == MyValue1.class.asValueType()) { 1486 continue; 1487 } 1488 System.out.print("Testing " + m.getName() + "(" + args[i] + ", " + args[j] + ")"); 1489 // Avoid acmp in the computation of the expected result! 1490 boolean equal = equalities[i][j]; 1491 equal = isNegated(m) ? !equal : equal; 1492 boolean expected = alwaysTrue(m) || ((i == 0 || j == 0) && trueIfNull(m)) || (!alwaysFalse(m) && equal && !(i == 0 && falseIfNull(m))); 1493 for (int run = 0; run < warmup; ++run) { 1494 Boolean result = (Boolean)m.invoke(this, args[i], args[j]); 1495 if (result != expected && WHITE_BOX.isMethodCompiled(m, false) && warmup == 1) { 1496 System.out.println(" = " + result); 1497 throw new RuntimeException("Test failed: should return " + expected); 1498 } 1499 } 1500 System.out.println(" = " + expected); 1501 } 1502 } 1503 } 1504 } 1505 1506 public void run(int nullMode) throws Exception { 1507 // Prepare test arguments 1508 Object[] args = { null, 1509 new Object(), 1510 new MyObject(), 1511 MyValue1.setX(MyValue1.createDefault(), 42), 1512 new Object[10], 1513 new MyObject[10], 1514 MyValue1.setX(MyValue1.createDefault(), 0x42), 1515 MyValue1.setX(MyValue1.createDefault(), 42), 1516 MyValue2.setX(MyValue2.createDefault(), 42), }; 1517 1518 boolean[][] equalities = { { true, false, false, false, false, false, false, false, false }, 1519 { false, true, false, false, false, false, false, false, false }, 1520 { false, false, true, false, false, false, false, false, false }, 1521 { false, false, false, ACmpOnValues == 3,false, false, false, ACmpOnValues == 3, false }, 1522 { false, false, false, false, true, false, false, false, false }, 1523 { false, false, false, false, false, true, false, false, false }, 1524 { false, false, false, false, false, false, ACmpOnValues == 3, false, false }, 1525 { false, false, false, ACmpOnValues == 3,false, false, false, ACmpOnValues == 3, false }, 1526 { false, false, false, false, false, false, false, false, ACmpOnValues == 3 } }; 1527 1528 // Run tests 1529 for (Method m : getClass().getMethods()) { 1530 if (m.getName().startsWith("test")) { 1531 // Do some warmup runs 1532 runTest(m, args, 1000, nullMode, equalities); 1533 // Make sure method is compiled 1534 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1535 Asserts.assertTrue(WHITE_BOX.isMethodCompiled(m, false), m + " not compiled"); 1536 // Run again to verify correctness of compiled code 1537 runTest(m, args, 1, nullMode, equalities); 1538 } 1539 } 1540 1541 for (int i = 0; i < 10_000; ++i) { 1542 Asserts.assertTrue(cmpAlwaysEqual1(args[1], args[1])); 1543 Asserts.assertFalse(cmpAlwaysEqual2(args[1], args[1])); 1544 Asserts.assertTrue(cmpAlwaysEqual3(args[1])); 1545 Asserts.assertFalse(cmpAlwaysEqual4(args[1])); 1546 1547 Asserts.assertFalse(cmpAlwaysUnEqual1(args[1], args[2])); 1548 Asserts.assertTrue(cmpAlwaysUnEqual2(args[1], args[2])); 1549 Asserts.assertFalse(cmpAlwaysUnEqual3(args[3])); 1550 Asserts.assertTrue(cmpAlwaysUnEqual4(args[3])); 1551 1552 int idx = i % args.length; 1553 Asserts.assertEQ(cmpSometimesEqual1(args[idx]), args[idx] == null || !args[idx].getClass().isValue()); 1554 Asserts.assertNE(cmpSometimesEqual2(args[idx]), args[idx] == null || !args[idx].getClass().isValue()); 1555 } 1556 } 1557 1558 public static void main(String[] args) throws Exception { 1559 if (Boolean.getBoolean("test.c1")) { 1560 System.out.println("new acmp is not implemented for C1"); 1561 return; 1562 } 1563 1564 int nullMode = Integer.valueOf(args[0]); 1565 TestNewAcmp t = new TestNewAcmp(); 1566 t.run(nullMode); 1567 } 1568 } 1569