1 /* 2 * Copyright (c) 2019, 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 package compiler.valhalla.valuetypes; 25 26 import jdk.test.lib.Asserts; 27 import java.lang.reflect.Method; 28 import java.util.Arrays; 29 30 /* 31 * @test 32 * @summary Test nullable value type arrays 33 * @library /testlibrary /test/lib /compiler/whitebox / 34 * @requires os.simpleArch == "x64" 35 * @compile TestNullableArrays.java 36 * @run driver ClassFileInstaller sun.hotspot.WhiteBox jdk.test.lib.Platform 37 * @run main/othervm/timeout=300 -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions 38 * -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI 39 * compiler.valhalla.valuetypes.ValueTypeTest 40 * compiler.valhalla.valuetypes.TestNullableArrays 41 */ 42 public class TestNullableArrays extends ValueTypeTest { 43 // Unlike C2, C1 intrinsics never deoptimize System.arraycopy. Instead, we fall back to 44 // a normal method invocation when encountering flattened arrays. 45 private static void assertDeoptimizedByC2(Method m) { 46 int CompLevel_none = 0, // Interpreter 47 CompLevel_simple = 1, // C1 48 CompLevel_limited_profile = 2, // C1, invocation & backedge counters 49 CompLevel_full_profile = 3, // C1, invocation & backedge counters + mdo 50 CompLevel_full_optimization = 4; // C2 or JVMCI 51 52 if (USE_COMPILER && !XCOMP && WHITE_BOX.isMethodCompiled(m, false) && 53 WHITE_BOX.getMethodCompilationLevel(m, false) >= CompLevel_full_optimization) { 54 throw new RuntimeException("Type check should have caused it to deoptimize"); 55 } 56 } 57 58 // Extra VM parameters for some test scenarios. See ValueTypeTest.getVMParameters() 59 @Override 60 public String[] getExtraVMParameters(int scenario) { 61 switch (scenario) { 62 case 2: return new String[] {"-XX:-MonomorphicArrayCheck", "-XX:-UncommonNullCast"}; 63 case 3: return new String[] {"-XX:-MonomorphicArrayCheck", "-XX:-UncommonNullCast"}; 64 case 4: return new String[] {"-XX:-MonomorphicArrayCheck", "-XX:-UncommonNullCast"}; 65 case 5: return new String[] {"-XX:-MonomorphicArrayCheck", "-XX:-UncommonNullCast"}; 66 } 67 return null; 68 } 69 70 public static void main(String[] args) throws Throwable { 71 TestNullableArrays test = new TestNullableArrays(); 72 test.run(args, MyValue1.class, MyValue2.class, MyValue2Inline.class); 73 } 74 75 // Helper methods 76 77 protected long hash() { 78 return hash(rI, rL); 79 } 80 81 protected long hash(int x, long y) { 82 return MyValue1.createWithFieldsInline(x, y).hash(); 83 } 84 85 private static final MyValue1 testValue1 = MyValue1.createWithFieldsInline(rI, rL); 86 87 // Test nullable value type array creation and initialization 88 @Test(valid = ValueTypeArrayFlattenOff, failOn = LOAD) 89 @Test(valid = ValueTypeArrayFlattenOn) 90 public MyValue1?[] test1(int len) { 91 MyValue1?[] va = new MyValue1?[len]; 92 if (len > 0) { 93 va[0] = null; 94 } 95 for (int i = 1; i < len; ++i) { 96 va[i] = MyValue1.createWithFieldsDontInline(rI, rL); 97 } 98 return va; 99 } 100 101 @DontCompile 102 public void test1_verifier(boolean warmup) { 103 int len = Math.abs(rI % 10); 104 MyValue1?[] va = test1(len); 105 if (len > 0) { 106 Asserts.assertEQ(va[0], null); 107 } 108 for (int i = 1; i < len; ++i) { 109 Asserts.assertEQ(va[i].hash(), hash()); 110 } 111 } 112 113 // Test creation of a value type array and element access 114 @Test() 115 // TODO fix 116 // @Test(failOn = ALLOC + ALLOCA + LOOP + LOAD + STORE + TRAP) 117 public long test2() { 118 MyValue1?[] va = new MyValue1?[1]; 119 va[0] = MyValue1.createWithFieldsInline(rI, rL); 120 return va[0].hash(); 121 } 122 123 @DontCompile 124 public void test2_verifier(boolean warmup) { 125 long result = test2(); 126 Asserts.assertEQ(result, hash()); 127 } 128 129 // Test receiving a value type array from the interpreter, 130 // updating its elements in a loop and computing a hash. 131 @Test(failOn = ALLOCA) 132 public long test3(MyValue1?[] va) { 133 long result = 0; 134 for (int i = 0; i < 10; ++i) { 135 if (va[i] != null) { 136 result += va[i].hash(); 137 } 138 va[i] = MyValue1.createWithFieldsInline(rI + 1, rL + 1); 139 } 140 va[0] = null; 141 return result; 142 } 143 144 @DontCompile 145 public void test3_verifier(boolean warmup) { 146 MyValue1?[] va = new MyValue1?[10]; 147 long expected = 0; 148 for (int i = 1; i < 10; ++i) { 149 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL + i); 150 expected += va[i].hash(); 151 } 152 long result = test3(va); 153 Asserts.assertEQ(expected, result); 154 Asserts.assertEQ(va[0], null); 155 for (int i = 1; i < 10; ++i) { 156 if (va[i].hash() != hash(rI + 1, rL + 1)) { 157 Asserts.assertEQ(va[i].hash(), hash(rI + 1, rL + 1)); 158 } 159 } 160 } 161 162 // Test returning a value type array received from the interpreter 163 @Test(failOn = ALLOC + ALLOCA + LOAD + STORE + LOOP + TRAP) 164 public MyValue1?[] test4(MyValue1?[] va) { 165 return va; 166 } 167 168 @DontCompile 169 public void test4_verifier(boolean warmup) { 170 MyValue1?[] va = new MyValue1?[10]; 171 for (int i = 0; i < 10; ++i) { 172 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL + i); 173 } 174 va = test4(va); 175 for (int i = 0; i < 10; ++i) { 176 Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i)); 177 } 178 } 179 180 // Merge value type arrays created from two branches 181 @Test 182 public MyValue1?[] test5(boolean b) { 183 MyValue1?[] va; 184 if (b) { 185 va = new MyValue1?[5]; 186 for (int i = 0; i < 5; ++i) { 187 va[i] = MyValue1.createWithFieldsInline(rI, rL); 188 } 189 va[4] = null; 190 } else { 191 va = new MyValue1?[10]; 192 for (int i = 0; i < 10; ++i) { 193 va[i] = MyValue1.createWithFieldsInline(rI + i, rL + i); 194 } 195 va[9] = null; 196 } 197 long sum = va[0].hashInterpreted(); 198 if (b) { 199 va[0] = MyValue1.createWithFieldsDontInline(rI, sum); 200 } else { 201 va[0] = MyValue1.createWithFieldsDontInline(rI + 1, sum + 1); 202 } 203 return va; 204 } 205 206 @DontCompile 207 public void test5_verifier(boolean warmup) { 208 MyValue1?[] va = test5(true); 209 Asserts.assertEQ(va.length, 5); 210 Asserts.assertEQ(va[0].hash(), hash(rI, hash())); 211 for (int i = 1; i < 4; ++i) { 212 Asserts.assertEQ(va[i].hash(), hash()); 213 } 214 Asserts.assertEQ(va[4], null); 215 va = test5(false); 216 Asserts.assertEQ(va.length, 10); 217 Asserts.assertEQ(va[0].hash(), hash(rI + 1, hash(rI, rL) + 1)); 218 for (int i = 1; i < 9; ++i) { 219 Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i)); 220 } 221 Asserts.assertEQ(va[9], null); 222 } 223 224 // Test creation of value type array with single element 225 @Test(failOn = ALLOCA + LOOP + LOAD + TRAP) 226 public MyValue1? test6() { 227 MyValue1?[] va = new MyValue1?[1]; 228 return va[0]; 229 } 230 231 @DontCompile 232 public void test6_verifier(boolean warmup) { 233 MyValue1?[] va = new MyValue1?[1]; 234 MyValue1? v = test6(); 235 Asserts.assertEQ(v, null); 236 } 237 238 // Test default initialization of value type arrays 239 @Test(failOn = LOAD) 240 public MyValue1?[] test7(int len) { 241 return new MyValue1?[len]; 242 } 243 244 @DontCompile 245 public void test7_verifier(boolean warmup) { 246 int len = Math.abs(rI % 10); 247 MyValue1?[] va = test7(len); 248 for (int i = 0; i < len; ++i) { 249 Asserts.assertEQ(va[i], null); 250 va[i] = null; 251 } 252 } 253 254 // Test creation of value type array with zero length 255 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP) 256 public MyValue1?[] test8() { 257 return new MyValue1?[0]; 258 } 259 260 @DontCompile 261 public void test8_verifier(boolean warmup) { 262 MyValue1?[] va = test8(); 263 Asserts.assertEQ(va.length, 0); 264 } 265 266 static MyValue1?[] test9_va; 267 268 // Test that value type array loaded from field has correct type 269 @Test(failOn = LOOP) 270 public long test9() { 271 return test9_va[0].hash(); 272 } 273 274 @DontCompile 275 public void test9_verifier(boolean warmup) { 276 test9_va = new MyValue1?[1]; 277 test9_va[0] = testValue1; 278 long result = test9(); 279 Asserts.assertEQ(result, hash()); 280 } 281 282 // Multi-dimensional arrays 283 @Test 284 public MyValue1?[][][] test10(int len1, int len2, int len3) { 285 MyValue1?[][][] arr = new MyValue1?[len1][len2][len3]; 286 for (int i = 0; i < len1; i++) { 287 for (int j = 0; j < len2; j++) { 288 for (int k = 0; k < len3; k++) { 289 arr[i][j][k] = MyValue1.createWithFieldsDontInline(rI + i , rL + j + k); 290 if (k == 0) { 291 arr[i][j][k] = null; 292 } 293 } 294 } 295 } 296 return arr; 297 } 298 299 @DontCompile 300 public void test10_verifier(boolean warmup) { 301 MyValue1?[][][] arr = test10(2, 3, 4); 302 for (int i = 0; i < 2; i++) { 303 for (int j = 0; j < 3; j++) { 304 for (int k = 0; k < 4; k++) { 305 if (k == 0) { 306 Asserts.assertEQ(arr[i][j][k], null); 307 } else { 308 Asserts.assertEQ(arr[i][j][k].hash(), MyValue1.createWithFieldsDontInline(rI + i , rL + j + k).hash()); 309 } 310 arr[i][j][k] = null; 311 } 312 } 313 } 314 } 315 316 @Test 317 public void test11(MyValue1?[][][] arr, long[] res) { 318 int l = 0; 319 for (int i = 0; i < arr.length; i++) { 320 for (int j = 0; j < arr[i].length; j++) { 321 for (int k = 0; k < arr[i][j].length; k++) { 322 if (arr[i][j][k] != null) { 323 res[l] = arr[i][j][k].hash(); 324 } 325 arr[i][j][k] = null; 326 l++; 327 } 328 } 329 } 330 } 331 332 @DontCompile 333 public void test11_verifier(boolean warmup) { 334 MyValue1?[][][] arr = new MyValue1?[2][3][4]; 335 long[] res = new long[2*3*4]; 336 long[] verif = new long[2*3*4]; 337 int l = 0; 338 for (int i = 0; i < 2; i++) { 339 for (int j = 0; j < 3; j++) { 340 for (int k = 0; k < 4; k++) { 341 if (j != 2) { 342 arr[i][j][k] = MyValue1.createWithFieldsDontInline(rI + i, rL + j + k); 343 verif[l] = arr[i][j][k].hash(); 344 } 345 l++; 346 } 347 } 348 } 349 test11(arr, res); 350 for (int i = 0; i < verif.length; i++) { 351 Asserts.assertEQ(res[i], verif[i]); 352 } 353 } 354 355 // Array load out of bounds (upper bound) at compile time 356 @Test 357 public int test12() { 358 int arraySize = Math.abs(rI) % 10; 359 MyValue1?[] va = new MyValue1?[arraySize]; 360 361 for (int i = 0; i < arraySize; i++) { 362 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL); 363 } 364 365 try { 366 return va[arraySize + 1].x; 367 } catch (ArrayIndexOutOfBoundsException e) { 368 return rI; 369 } 370 } 371 372 public void test12_verifier(boolean warmup) { 373 Asserts.assertEQ(test12(), rI); 374 } 375 376 // Array load out of bounds (lower bound) at compile time 377 @Test 378 public int test13() { 379 int arraySize = Math.abs(rI) % 10; 380 MyValue1?[] va = new MyValue1?[arraySize]; 381 382 for (int i = 0; i < arraySize; i++) { 383 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL); 384 } 385 386 try { 387 return va[-arraySize].x; 388 } catch (ArrayIndexOutOfBoundsException e) { 389 return rI; 390 } 391 } 392 393 public void test13_verifier(boolean warmup) { 394 Asserts.assertEQ(test13(), rI); 395 } 396 397 // Array load out of bound not known to compiler (both lower and upper bound) 398 @Test 399 public int test14(MyValue1?[] va, int index) { 400 return va[index].x; 401 } 402 403 public void test14_verifier(boolean warmup) { 404 int arraySize = Math.abs(rI) % 10; 405 MyValue1?[] va = new MyValue1?[arraySize]; 406 407 for (int i = 0; i < arraySize; i++) { 408 va[i] = MyValue1.createWithFieldsDontInline(rI, rL); 409 } 410 411 int result; 412 for (int i = -20; i < 20; i++) { 413 try { 414 result = test14(va, i); 415 } catch (ArrayIndexOutOfBoundsException e) { 416 result = rI; 417 } 418 Asserts.assertEQ(result, rI); 419 } 420 } 421 422 // Array store out of bounds (upper bound) at compile time 423 @Test 424 public int test15() { 425 int arraySize = Math.abs(rI) % 10; 426 MyValue1?[] va = new MyValue1?[arraySize]; 427 428 try { 429 for (int i = 0; i <= arraySize; i++) { 430 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL); 431 } 432 return rI - 1; 433 } catch (ArrayIndexOutOfBoundsException e) { 434 return rI; 435 } 436 } 437 438 public void test15_verifier(boolean warmup) { 439 Asserts.assertEQ(test15(), rI); 440 } 441 442 // Array store out of bounds (lower bound) at compile time 443 @Test 444 public int test16() { 445 int arraySize = Math.abs(rI) % 10; 446 MyValue1?[] va = new MyValue1?[arraySize]; 447 448 try { 449 for (int i = -1; i <= arraySize; i++) { 450 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL); 451 } 452 return rI - 1; 453 } catch (ArrayIndexOutOfBoundsException e) { 454 return rI; 455 } 456 } 457 458 public void test16_verifier(boolean warmup) { 459 Asserts.assertEQ(test16(), rI); 460 } 461 462 // Array store out of bound not known to compiler (both lower and upper bound) 463 @Test 464 public int test17(MyValue1?[] va, int index, MyValue1 vt) { 465 va[index] = vt; 466 return va[index].x; 467 } 468 469 @DontCompile 470 public void test17_verifier(boolean warmup) { 471 int arraySize = Math.abs(rI) % 10; 472 MyValue1?[] va = new MyValue1?[arraySize]; 473 474 for (int i = 0; i < arraySize; i++) { 475 va[i] = MyValue1.createWithFieldsDontInline(rI, rL); 476 } 477 478 MyValue1 vt = MyValue1.createWithFieldsDontInline(rI + 1, rL); 479 int result; 480 for (int i = -20; i < 20; i++) { 481 try { 482 result = test17(va, i, vt); 483 } catch (ArrayIndexOutOfBoundsException e) { 484 result = rI + 1; 485 } 486 Asserts.assertEQ(result, rI + 1); 487 } 488 489 for (int i = 0; i < arraySize; i++) { 490 Asserts.assertEQ(va[i].x, rI + 1); 491 } 492 } 493 494 // clone() as stub call 495 @Test 496 public MyValue1?[] test18(MyValue1?[] va) { 497 return va.clone(); 498 } 499 500 @DontCompile 501 public void test18_verifier(boolean warmup) { 502 int len = Math.abs(rI) % 10; 503 MyValue1?[] va1 = new MyValue1?[len]; 504 MyValue1[] va2 = new MyValue1[len]; 505 for (int i = 1; i < len; ++i) { 506 va1[i] = testValue1; 507 va2[i] = testValue1; 508 } 509 MyValue1?[] result1 = test18(va1); 510 if (len > 0) { 511 Asserts.assertEQ(result1[0], null); 512 } 513 for (int i = 1; i < len; ++i) { 514 Asserts.assertEQ(result1[i].hash(), va1[i].hash()); 515 } 516 // make sure we do deopt: GraphKit::new_array assumes an 517 // array of references 518 for (int j = 0; j < 10; j++) { 519 MyValue1?[] result2 = test18(va2); 520 521 for (int i = 0; i < len; ++i) { 522 Asserts.assertEQ(result2[i].hash(), va2[i].hash()); 523 } 524 } 525 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test18")) { 526 MyValue1?[] result2 = test18(va2); 527 for (int i = 0; i < len; ++i) { 528 Asserts.assertEQ(result2[i].hash(), va2[i].hash()); 529 } 530 } 531 } 532 533 // clone() as series of loads/stores 534 static MyValue1?[] test19_orig = null; 535 536 @Test 537 public MyValue1?[] test19() { 538 MyValue1?[] va = new MyValue1?[8]; 539 for (int i = 1; i < va.length; ++i) { 540 va[i] = MyValue1.createWithFieldsInline(rI, rL); 541 } 542 test19_orig = va; 543 544 return va.clone(); 545 } 546 547 @DontCompile 548 public void test19_verifier(boolean warmup) { 549 MyValue1?[] result = test19(); 550 Asserts.assertEQ(result[0], null); 551 for (int i = 1; i < test19_orig.length; ++i) { 552 Asserts.assertEQ(result[i].hash(), test19_orig[i].hash()); 553 } 554 } 555 556 // arraycopy() of value type array with oop fields 557 @Test 558 public void test20(MyValue1?[] src, MyValue1?[] dst) { 559 System.arraycopy(src, 0, dst, 0, src.length); 560 } 561 562 @DontCompile 563 public void test20_verifier(boolean warmup) { 564 int len = Math.abs(rI) % 10; 565 MyValue1?[] src1 = new MyValue1?[len]; 566 MyValue1?[] src2 = new MyValue1?[len]; 567 MyValue1[] src3 = new MyValue1[len]; 568 MyValue1[] src4 = new MyValue1[len]; 569 MyValue1?[] dst1 = new MyValue1?[len]; 570 MyValue1[] dst2 = new MyValue1[len]; 571 MyValue1?[] dst3 = new MyValue1?[len]; 572 MyValue1[] dst4 = new MyValue1[len]; 573 if (len > 0) { 574 src2[0] = testValue1; 575 } 576 for (int i = 1; i < len; ++i) { 577 src1[i] = testValue1; 578 src2[i] = testValue1; 579 src3[i] = testValue1; 580 src4[i] = testValue1; 581 } 582 test20(src1, dst1); 583 test20(src2, dst2); 584 test20(src3, dst3); 585 test20(src4, dst4); 586 if (len > 0) { 587 Asserts.assertEQ(dst1[0], null); 588 Asserts.assertEQ(dst2[0].hash(), src2[0].hash()); 589 Asserts.assertEQ(dst3[0].hash(), src3[0].hash()); 590 Asserts.assertEQ(dst4[0].hash(), src4[0].hash()); 591 } 592 for (int i = 1; i < len; ++i) { 593 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 594 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 595 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 596 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 597 } 598 } 599 600 // arraycopy() of value type array with no oop field 601 @Test 602 public void test21(MyValue2?[] src, MyValue2?[] dst) { 603 System.arraycopy(src, 0, dst, 0, src.length); 604 } 605 606 @DontCompile 607 public void test21_verifier(boolean warmup) { 608 int len = Math.abs(rI) % 10; 609 MyValue2?[] src1 = new MyValue2?[len]; 610 MyValue2?[] src2 = new MyValue2?[len]; 611 MyValue2[] src3 = new MyValue2[len]; 612 MyValue2[] src4 = new MyValue2[len]; 613 MyValue2?[] dst1 = new MyValue2?[len]; 614 MyValue2[] dst2 = new MyValue2[len]; 615 MyValue2?[] dst3 = new MyValue2?[len]; 616 MyValue2[] dst4 = new MyValue2[len]; 617 if (len > 0) { 618 src2[0] = MyValue2.createWithFieldsInline(rI, true); 619 } 620 for (int i = 1; i < len; ++i) { 621 src1[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 622 src2[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 623 src3[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 624 src4[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 625 } 626 test21(src1, dst1); 627 test21(src2, dst2); 628 test21(src3, dst3); 629 test21(src4, dst4); 630 if (len > 0) { 631 Asserts.assertEQ(dst1[0], null); 632 Asserts.assertEQ(dst2[0].hash(), src2[0].hash()); 633 Asserts.assertEQ(dst3[0].hash(), src3[0].hash()); 634 Asserts.assertEQ(dst4[0].hash(), src4[0].hash()); 635 } 636 for (int i = 1; i < len; ++i) { 637 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 638 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 639 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 640 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 641 } 642 } 643 644 // arraycopy() of value type array with oop field and tightly 645 // coupled allocation as dest 646 @Test 647 public MyValue1?[] test22(MyValue1?[] src) { 648 MyValue1?[] dst = new MyValue1?[src.length]; 649 System.arraycopy(src, 0, dst, 0, src.length); 650 return dst; 651 } 652 653 @DontCompile 654 public void test22_verifier(boolean warmup) { 655 int len = Math.abs(rI) % 10; 656 MyValue1?[] src1 = new MyValue1?[len]; 657 MyValue1[] src2 = new MyValue1[len]; 658 for (int i = 1; i < len; ++i) { 659 src1[i] = testValue1; 660 src2[i] = testValue1; 661 } 662 MyValue1?[] dst1 = test22(src1); 663 MyValue1?[] dst2 = test22(src2); 664 if (len > 0) { 665 Asserts.assertEQ(dst1[0], null); 666 Asserts.assertEQ(dst2[0].hash(), MyValue1.default.hash()); 667 } 668 for (int i = 1; i < len; ++i) { 669 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 670 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 671 } 672 } 673 674 // arraycopy() of value type array with oop fields and tightly 675 // coupled allocation as dest 676 @Test 677 public MyValue1?[] test23(MyValue1?[] src) { 678 MyValue1?[] dst = new MyValue1?[src.length + 10]; 679 System.arraycopy(src, 0, dst, 5, src.length); 680 return dst; 681 } 682 683 @DontCompile 684 public void test23_verifier(boolean warmup) { 685 int len = Math.abs(rI) % 10; 686 MyValue1?[] src1 = new MyValue1?[len]; 687 MyValue1[] src2 = new MyValue1[len]; 688 for (int i = 0; i < len; ++i) { 689 src1[i] = testValue1; 690 src2[i] = testValue1; 691 } 692 MyValue1?[] dst1 = test23(src1); 693 MyValue1?[] dst2 = test23(src2); 694 for (int i = 0; i < 5; ++i) { 695 Asserts.assertEQ(dst1[i], null); 696 Asserts.assertEQ(dst2[i], null); 697 } 698 for (int i = 5; i < len; ++i) { 699 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 700 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 701 } 702 } 703 704 // arraycopy() of value type array passed as Object 705 @Test 706 public void test24(MyValue1?[] src, Object dst) { 707 System.arraycopy(src, 0, dst, 0, src.length); 708 } 709 710 @DontCompile 711 public void test24_verifier(boolean warmup) { 712 int len = Math.abs(rI) % 10; 713 MyValue1?[] src1 = new MyValue1?[len]; 714 MyValue1?[] src2 = new MyValue1?[len]; 715 MyValue1[] src3 = new MyValue1[len]; 716 MyValue1[] src4 = new MyValue1[len]; 717 MyValue1?[] dst1 = new MyValue1?[len]; 718 MyValue1[] dst2 = new MyValue1[len]; 719 MyValue1?[] dst3 = new MyValue1?[len]; 720 MyValue1[] dst4 = new MyValue1[len]; 721 if (len > 0) { 722 src2[0] = testValue1; 723 } 724 for (int i = 1; i < len; ++i) { 725 src1[i] = testValue1; 726 src2[i] = testValue1; 727 src3[i] = testValue1; 728 src4[i] = testValue1; 729 } 730 test24(src1, dst1); 731 test24(src2, dst2); 732 test24(src3, dst3); 733 test24(src4, dst4); 734 if (len > 0) { 735 Asserts.assertEQ(dst1[0], null); 736 Asserts.assertEQ(dst2[0].hash(), src2[0].hash()); 737 Asserts.assertEQ(dst3[0].hash(), src3[0].hash()); 738 Asserts.assertEQ(dst4[0].hash(), src4[0].hash()); 739 } 740 for (int i = 1; i < len; ++i) { 741 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 742 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 743 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 744 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 745 } 746 } 747 748 // short arraycopy() with no oop field 749 @Test 750 public void test25(MyValue2?[] src, MyValue2?[] dst) { 751 System.arraycopy(src, 0, dst, 0, 8); 752 } 753 754 @DontCompile 755 public void test25_verifier(boolean warmup) { 756 MyValue2?[] src1 = new MyValue2?[8]; 757 MyValue2?[] src2 = new MyValue2?[8]; 758 MyValue2[] src3 = new MyValue2[8]; 759 MyValue2[] src4 = new MyValue2[8]; 760 MyValue2?[] dst1 = new MyValue2?[8]; 761 MyValue2[] dst2 = new MyValue2[8]; 762 MyValue2?[] dst3 = new MyValue2?[8]; 763 MyValue2[] dst4 = new MyValue2[8]; 764 src2[0] = MyValue2.createWithFieldsInline(rI, true); 765 for (int i = 1; i < 8; ++i) { 766 src1[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 767 src2[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 768 src3[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 769 src4[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 770 } 771 test25(src1, dst1); 772 test25(src2, dst2); 773 test25(src3, dst3); 774 test25(src4, dst4); 775 Asserts.assertEQ(dst1[0], null); 776 Asserts.assertEQ(dst2[0].hash(), src2[0].hash()); 777 Asserts.assertEQ(dst3[0].hash(), src3[0].hash()); 778 Asserts.assertEQ(dst4[0].hash(), src4[0].hash()); 779 for (int i = 1; i < 8; ++i) { 780 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 781 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 782 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 783 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 784 } 785 } 786 787 // short arraycopy() with oop fields 788 @Test 789 public void test26(MyValue1?[] src, MyValue1?[] dst) { 790 System.arraycopy(src, 0, dst, 0, 8); 791 } 792 793 @DontCompile 794 public void test26_verifier(boolean warmup) { 795 MyValue1?[] src1 = new MyValue1?[8]; 796 MyValue1?[] src2 = new MyValue1?[8]; 797 MyValue1[] src3 = new MyValue1[8]; 798 MyValue1[] src4 = new MyValue1[8]; 799 MyValue1?[] dst1 = new MyValue1?[8]; 800 MyValue1[] dst2 = new MyValue1[8]; 801 MyValue1?[] dst3 = new MyValue1?[8]; 802 MyValue1[] dst4 = new MyValue1[8]; 803 src2[0] = testValue1; 804 for (int i = 1; i < 8 ; ++i) { 805 src1[i] = testValue1; 806 src2[i] = testValue1; 807 src3[i] = testValue1; 808 src4[i] = testValue1; 809 } 810 test26(src1, dst1); 811 test26(src2, dst2); 812 test26(src3, dst3); 813 test26(src4, dst4); 814 Asserts.assertEQ(dst1[0], null); 815 Asserts.assertEQ(dst2[0].hash(), src2[0].hash()); 816 Asserts.assertEQ(dst3[0].hash(), src3[0].hash()); 817 Asserts.assertEQ(dst4[0].hash(), src4[0].hash()); 818 for (int i = 1; i < 8; ++i) { 819 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 820 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 821 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 822 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 823 } 824 } 825 826 // short arraycopy() with oop fields and offsets 827 @Test 828 public void test27(MyValue1?[] src, MyValue1?[] dst) { 829 System.arraycopy(src, 1, dst, 2, 6); 830 } 831 832 @DontCompile 833 public void test27_verifier(boolean warmup) { 834 MyValue1?[] src1 = new MyValue1?[8]; 835 MyValue1?[] src2 = new MyValue1?[8]; 836 MyValue1[] src3 = new MyValue1[8]; 837 MyValue1[] src4 = new MyValue1[8]; 838 MyValue1?[] dst1 = new MyValue1?[8]; 839 MyValue1[] dst2 = new MyValue1[8]; 840 MyValue1?[] dst3 = new MyValue1?[8]; 841 MyValue1[] dst4 = new MyValue1[8]; 842 for (int i = 1; i < 8; ++i) { 843 src1[i] = testValue1; 844 src2[i] = testValue1; 845 src3[i] = testValue1; 846 src4[i] = testValue1; 847 } 848 test27(src1, dst1); 849 test27(src2, dst2); 850 test27(src3, dst3); 851 test27(src4, dst4); 852 for (int i = 0; i < 2; ++i) { 853 Asserts.assertEQ(dst1[i], null); 854 Asserts.assertEQ(dst2[i].hash(), MyValue1.default.hash()); 855 Asserts.assertEQ(dst3[i], null); 856 Asserts.assertEQ(dst4[i].hash(), MyValue1.default.hash()); 857 } 858 for (int i = 2; i < 8; ++i) { 859 Asserts.assertEQ(src1[i].hash(), dst1[i].hash()); 860 Asserts.assertEQ(src2[i].hash(), dst2[i].hash()); 861 Asserts.assertEQ(src3[i].hash(), dst3[i].hash()); 862 Asserts.assertEQ(src4[i].hash(), dst4[i].hash()); 863 } 864 } 865 866 // non escaping allocations 867 // TODO fix 868 // @Test(failOn = ALLOCA + LOOP + LOAD + TRAP) 869 public MyValue2? test28() { 870 MyValue2?[] src = new MyValue2?[10]; 871 src[0] = null; 872 MyValue2?[] dst = (MyValue2?[])src.clone(); 873 return dst[0]; 874 } 875 876 @DontCompile 877 public void test28_verifier(boolean warmup) { 878 MyValue2 v = MyValue2.createWithFieldsInline(rI, false); 879 MyValue2? result = test28(); 880 Asserts.assertEQ(result, null); 881 } 882 883 // non escaping allocations 884 @Test(failOn = ALLOCA + LOOP + TRAP) 885 public MyValue2? test29(MyValue2?[] src) { 886 MyValue2?[] dst = new MyValue2?[10]; 887 System.arraycopy(src, 0, dst, 0, 10); 888 return dst[0]; 889 } 890 891 @DontCompile 892 public void test29_verifier(boolean warmup) { 893 MyValue2?[] src = new MyValue2?[10]; 894 for (int i = 0; i < 10; ++i) { 895 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 896 } 897 MyValue2? v = test29(src); 898 Asserts.assertEQ(src[0].hash(), v.hash()); 899 } 900 901 // non escaping allocation with uncommon trap that needs 902 // eliminated value type array element as debug info 903 @Test 904 @Warmup(10000) 905 public MyValue2? test30(MyValue2?[] src, boolean flag) { 906 MyValue2?[] dst = new MyValue2?[10]; 907 System.arraycopy(src, 0, dst, 0, 10); 908 if (flag) { } 909 return dst[0]; 910 } 911 912 @DontCompile 913 public void test30_verifier(boolean warmup) { 914 MyValue2?[] src = new MyValue2?[10]; 915 for (int i = 0; i < 10; ++i) { 916 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 917 } 918 MyValue2? v = test30(src, false); 919 Asserts.assertEQ(src[0].hash(), v.hash()); 920 } 921 922 // non escaping allocation with memory phi 923 @Test() 924 // TODO fix 925 // @Test(failOn = ALLOC + ALLOCA + LOOP + LOAD + TRAP) 926 public long test31(boolean b, boolean deopt) { 927 MyValue2?[] src = new MyValue2?[1]; 928 if (b) { 929 src[0] = MyValue2.createWithFieldsInline(rI, true); 930 } else { 931 src[0] = MyValue2.createWithFieldsInline(rI, false); 932 } 933 if (deopt) { 934 // uncommon trap 935 WHITE_BOX.deoptimizeMethod(tests.get(getClass().getSimpleName() + "::test31")); 936 } 937 return src[0].hash(); 938 } 939 940 @DontCompile 941 public void test31_verifier(boolean warmup) { 942 MyValue2 v1 = MyValue2.createWithFieldsInline(rI, true); 943 long result1 = test31(true, !warmup); 944 Asserts.assertEQ(result1, v1.hash()); 945 MyValue2 v2 = MyValue2.createWithFieldsInline(rI, false); 946 long result2 = test31(false, !warmup); 947 Asserts.assertEQ(result2, v2.hash()); 948 } 949 950 // Tests with Object arrays and clone/arraycopy 951 // clone() as stub call 952 @Test 953 public Object[] test32(Object[] va) { 954 return va.clone(); 955 } 956 957 @DontCompile 958 public void test32_verifier(boolean warmup) { 959 int len = Math.abs(rI) % 10; 960 MyValue1?[] va1 = new MyValue1?[len]; 961 MyValue1[] va2 = new MyValue1[len]; 962 for (int i = 1; i < len; ++i) { 963 va1[i] = testValue1; 964 va2[i] = testValue1; 965 } 966 MyValue1?[] result1 = (MyValue1?[])test32(va1); 967 MyValue1?[] result2 = (MyValue1?[])test32(va2); 968 if (len > 0) { 969 Asserts.assertEQ(result1[0], null); 970 Asserts.assertEQ(result2[0].hash(), MyValue1.default.hash()); 971 } 972 for (int i = 1; i < len; ++i) { 973 Asserts.assertEQ(((MyValue1)result1[i]).hash(), ((MyValue1)va1[i]).hash()); 974 Asserts.assertEQ(((MyValue1)result2[i]).hash(), ((MyValue1)va2[i]).hash()); 975 } 976 } 977 978 @Test 979 public Object[] test33(Object[] va) { 980 return va.clone(); 981 } 982 983 @DontCompile 984 public void test33_verifier(boolean warmup) { 985 int len = Math.abs(rI) % 10; 986 Object[] va = new Object[len]; 987 for (int i = 0; i < len; ++i) { 988 va[i] = testValue1; 989 } 990 Object[] result = test33(va); 991 for (int i = 0; i < len; ++i) { 992 Asserts.assertEQ(((MyValue1)result[i]).hash(), ((MyValue1)va[i]).hash()); 993 } 994 } 995 996 // clone() as series of loads/stores 997 static Object[] test34_orig = null; 998 999 @ForceInline 1000 public Object[] test34_helper(boolean flag) { 1001 Object[] va = null; 1002 if (flag) { 1003 va = new MyValue1?[8]; 1004 for (int i = 0; i < va.length; ++i) { 1005 va[i] = MyValue1.createWithFieldsDontInline(rI, rL); 1006 } 1007 } else { 1008 va = new Object[8]; 1009 } 1010 return va; 1011 } 1012 1013 @Test 1014 public Object[] test34(boolean flag) { 1015 Object[] va = test34_helper(flag); 1016 test34_orig = va; 1017 return va.clone(); 1018 } 1019 1020 @DontCompile 1021 public void test34_verifier(boolean warmup) { 1022 test34(false); 1023 for (int i = 0; i < 10; i++) { // make sure we do deopt 1024 Object[] result = test34(true); 1025 verify(test34_orig, result); 1026 } 1027 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test34")) { 1028 Object[] result = test34(true); 1029 verify(test34_orig, result); 1030 } 1031 } 1032 1033 static void verify(Object[] src, Object[] dst) { 1034 for (int i = 0; i < src.length; ++i) { 1035 if (src[i] != null) { 1036 Asserts.assertEQ(((MyInterface)src[i]).hash(), ((MyInterface)dst[i]).hash()); 1037 } else { 1038 Asserts.assertEQ(dst[i], null); 1039 } 1040 } 1041 } 1042 1043 static void verify(MyValue1?[] src, MyValue1?[] dst) { 1044 for (int i = 0; i < src.length; ++i) { 1045 if (src[i] != null) { 1046 Asserts.assertEQ(src[i].hash(), dst[i].hash()); 1047 } else { 1048 Asserts.assertEQ(dst[i], null); 1049 } 1050 } 1051 } 1052 1053 static void verify(MyValue1?[] src, Object[] dst) { 1054 for (int i = 0; i < src.length; ++i) { 1055 if (src[i] != null) { 1056 Asserts.assertEQ(src[i].hash(), ((MyInterface)dst[i]).hash()); 1057 } else { 1058 Asserts.assertEQ(dst[i], null); 1059 } 1060 } 1061 } 1062 1063 static void verify(MyValue2?[] src, MyValue2?[] dst) { 1064 for (int i = 0; i < src.length; ++i) { 1065 if (src[i] != null) { 1066 Asserts.assertEQ(src[i].hash(), dst[i].hash()); 1067 } else { 1068 Asserts.assertEQ(dst[i], null); 1069 } 1070 } 1071 } 1072 1073 static void verify(MyValue2?[] src, Object[] dst) { 1074 for (int i = 0; i < src.length; ++i) { 1075 if (src[i] != null) { 1076 Asserts.assertEQ(src[i].hash(), ((MyInterface)dst[i]).hash()); 1077 } else { 1078 Asserts.assertEQ(dst[i], null); 1079 } 1080 } 1081 } 1082 1083 static boolean compile_and_run_again_if_deoptimized(boolean warmup, String test) { 1084 if (!warmup) { 1085 Method m = tests.get(test); 1086 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false)) { 1087 if (!ValueTypeArrayFlatten && !XCOMP) { 1088 throw new RuntimeException("Unexpected deoptimization"); 1089 } 1090 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1091 return true; 1092 } 1093 } 1094 return false; 1095 } 1096 1097 // arraycopy() of value type array of unknown size 1098 @Test 1099 public void test35(Object src, Object dst, int len) { 1100 System.arraycopy(src, 0, dst, 0, len); 1101 } 1102 1103 @DontCompile 1104 public void test35_verifier(boolean warmup) { 1105 int len = Math.abs(rI) % 10; 1106 MyValue1?[] src = new MyValue1?[len]; 1107 MyValue1?[] dst = new MyValue1?[len]; 1108 for (int i = 1; i < len; ++i) { 1109 src[i] = testValue1; 1110 } 1111 test35(src, dst, src.length); 1112 verify(src, dst); 1113 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test35")) { 1114 test35(src, dst, src.length); 1115 verify(src, dst); 1116 } 1117 } 1118 1119 @Test 1120 public void test36(Object src, MyValue2?[] dst) { 1121 System.arraycopy(src, 0, dst, 0, dst.length); 1122 } 1123 1124 @DontCompile 1125 public void test36_verifier(boolean warmup) { 1126 int len = Math.abs(rI) % 10; 1127 MyValue2?[] src = new MyValue2?[len]; 1128 MyValue2?[] dst = new MyValue2?[len]; 1129 for (int i = 1; i < len; ++i) { 1130 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1131 } 1132 test36(src, dst); 1133 verify(src, dst); 1134 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test36")) { 1135 test36(src, dst); 1136 verify(src, dst); 1137 } 1138 } 1139 1140 @Test 1141 public void test37(MyValue2?[] src, Object dst) { 1142 System.arraycopy(src, 0, dst, 0, src.length); 1143 } 1144 1145 @DontCompile 1146 public void test37_verifier(boolean warmup) { 1147 int len = Math.abs(rI) % 10; 1148 MyValue2?[] src = new MyValue2?[len]; 1149 MyValue2?[] dst = new MyValue2?[len]; 1150 for (int i = 1; i < len; ++i) { 1151 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1152 } 1153 test37(src, dst); 1154 verify(src, dst); 1155 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test37")) { 1156 test37(src, dst); 1157 verify(src, dst); 1158 } 1159 } 1160 1161 @Test 1162 @Warmup(1) // Avoid early compilation 1163 public void test38(Object src, MyValue2?[] dst) { 1164 System.arraycopy(src, 0, dst, 0, dst.length); 1165 } 1166 1167 @DontCompile 1168 public void test38_verifier(boolean warmup) { 1169 int len = Math.abs(rI) % 10; 1170 Object[] src = new Object[len]; 1171 MyValue2?[] dst = new MyValue2?[len]; 1172 for (int i = 1; i < len; ++i) { 1173 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1174 } 1175 test38(src, dst); 1176 verify(dst, src); 1177 if (!warmup) { 1178 Method m = tests.get("TestNullableArrays::test38"); 1179 assertDeoptimizedByC2(m); 1180 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1181 test38(src, dst); 1182 verify(dst, src); 1183 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1184 throw new RuntimeException("unexpected deoptimization"); 1185 } 1186 } 1187 } 1188 1189 @Test 1190 public void test39(MyValue2?[] src, Object dst) { 1191 System.arraycopy(src, 0, dst, 0, src.length); 1192 } 1193 1194 @DontCompile 1195 public void test39_verifier(boolean warmup) { 1196 int len = Math.abs(rI) % 10; 1197 MyValue2?[] src = new MyValue2?[len]; 1198 Object[] dst = new Object[len]; 1199 for (int i = 1; i < len; ++i) { 1200 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1201 } 1202 test39(src, dst); 1203 verify(src, dst); 1204 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test39")) { 1205 test39(src, dst); 1206 verify(src, dst); 1207 } 1208 } 1209 1210 @Test 1211 @Warmup(1) // Avoid early compilation 1212 public void test40(Object[] src, Object dst) { 1213 System.arraycopy(src, 0, dst, 0, src.length); 1214 } 1215 1216 @DontCompile 1217 public void test40_verifier(boolean warmup) { 1218 int len = Math.abs(rI) % 10; 1219 Object[] src = new Object[len]; 1220 MyValue2?[] dst = new MyValue2?[len]; 1221 for (int i = 1; i < len; ++i) { 1222 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1223 } 1224 test40(src, dst); 1225 verify(dst, src); 1226 if (!warmup) { 1227 Method m = tests.get("TestNullableArrays::test40"); 1228 assertDeoptimizedByC2(m); 1229 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1230 test40(src, dst); 1231 verify(dst, src); 1232 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1233 throw new RuntimeException("unexpected deoptimization"); 1234 } 1235 } 1236 } 1237 1238 @Test 1239 public void test41(Object src, Object[] dst) { 1240 System.arraycopy(src, 0, dst, 0, dst.length); 1241 } 1242 1243 @DontCompile 1244 public void test41_verifier(boolean warmup) { 1245 int len = Math.abs(rI) % 10; 1246 MyValue2?[] src = new MyValue2?[len]; 1247 Object[] dst = new Object[len]; 1248 for (int i = 1; i < len; ++i) { 1249 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1250 } 1251 test41(src, dst); 1252 verify(src, dst); 1253 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test41")) { 1254 test41(src, dst); 1255 verify(src, dst); 1256 } 1257 } 1258 1259 @Test 1260 public void test42(Object[] src, Object[] dst) { 1261 System.arraycopy(src, 0, dst, 0, src.length); 1262 } 1263 1264 @DontCompile 1265 public void test42_verifier(boolean warmup) { 1266 int len = Math.abs(rI) % 10; 1267 Object[] src = new Object[len]; 1268 Object[] dst = new Object[len]; 1269 for (int i = 1; i < len; ++i) { 1270 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1271 } 1272 test42(src, dst); 1273 verify(src, dst); 1274 if (!warmup) { 1275 Method m = tests.get("TestNullableArrays::test42"); 1276 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1277 throw new RuntimeException("unexpected deoptimization"); 1278 } 1279 } 1280 } 1281 1282 // short arraycopy()'s 1283 @Test 1284 public void test43(Object src, Object dst) { 1285 System.arraycopy(src, 0, dst, 0, 8); 1286 } 1287 1288 @DontCompile 1289 public void test43_verifier(boolean warmup) { 1290 MyValue1?[] src = new MyValue1?[8]; 1291 MyValue1?[] dst = new MyValue1?[8]; 1292 for (int i = 1; i < 8; ++i) { 1293 src[i] = testValue1; 1294 } 1295 test43(src, dst); 1296 verify(src, dst); 1297 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test43")) { 1298 test43(src, dst); 1299 verify(src, dst); 1300 } 1301 } 1302 1303 @Test 1304 public void test44(Object src, MyValue2?[] dst) { 1305 System.arraycopy(src, 0, dst, 0, 8); 1306 } 1307 1308 @DontCompile 1309 public void test44_verifier(boolean warmup) { 1310 MyValue2?[] src = new MyValue2?[8]; 1311 MyValue2?[] dst = new MyValue2?[8]; 1312 for (int i = 1; i < 8; ++i) { 1313 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1314 } 1315 test44(src, dst); 1316 verify(src, dst); 1317 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test44")) { 1318 test44(src, dst); 1319 verify(src, dst); 1320 } 1321 } 1322 1323 @Test 1324 public void test45(MyValue2?[] src, Object dst) { 1325 System.arraycopy(src, 0, dst, 0, 8); 1326 } 1327 1328 @DontCompile 1329 public void test45_verifier(boolean warmup) { 1330 MyValue2?[] src = new MyValue2?[8]; 1331 MyValue2?[] dst = new MyValue2?[8]; 1332 for (int i = 1; i < 8; ++i) { 1333 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1334 } 1335 test45(src, dst); 1336 verify(src, dst); 1337 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test45")) { 1338 test45(src, dst); 1339 verify(src, dst); 1340 } 1341 } 1342 1343 @Test 1344 @Warmup(1) // Avoid early compilation 1345 public void test46(Object[] src, MyValue2?[] dst) { 1346 System.arraycopy(src, 0, dst, 0, 8); 1347 } 1348 1349 @DontCompile 1350 public void test46_verifier(boolean warmup) { 1351 Object[] src = new Object[8]; 1352 MyValue2?[] dst = new MyValue2?[8]; 1353 for (int i = 1; i < 8; ++i) { 1354 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1355 } 1356 test46(src, dst); 1357 verify(dst, src); 1358 if (!warmup) { 1359 Method m = tests.get("TestNullableArrays::test46"); 1360 assertDeoptimizedByC2(m); 1361 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1362 test46(src, dst); 1363 verify(dst, src); 1364 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1365 throw new RuntimeException("unexpected deoptimization"); 1366 } 1367 } 1368 } 1369 1370 @Test 1371 public void test47(MyValue2?[] src, Object[] dst) { 1372 System.arraycopy(src, 0, dst, 0, 8); 1373 } 1374 1375 @DontCompile 1376 public void test47_verifier(boolean warmup) { 1377 MyValue2?[] src = new MyValue2?[8]; 1378 Object[] dst = new Object[8]; 1379 for (int i = 1; i < 8; ++i) { 1380 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1381 } 1382 test47(src, dst); 1383 verify(src, dst); 1384 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test47")) { 1385 test47(src, dst); 1386 verify(src, dst); 1387 } 1388 } 1389 1390 @Test 1391 @Warmup(1) // Avoid early compilation 1392 public void test48(Object[] src, Object dst) { 1393 System.arraycopy(src, 0, dst, 0, 8); 1394 } 1395 1396 @DontCompile 1397 public void test48_verifier(boolean warmup) { 1398 Object[] src = new Object[8]; 1399 MyValue2?[] dst = new MyValue2?[8]; 1400 for (int i = 1; i < 8; ++i) { 1401 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1402 } 1403 test48(src, dst); 1404 verify(dst, src); 1405 if (!warmup) { 1406 Method m = tests.get("TestNullableArrays::test48"); 1407 assertDeoptimizedByC2(m); 1408 WHITE_BOX.enqueueMethodForCompilation(m, COMP_LEVEL_FULL_OPTIMIZATION); 1409 test48(src, dst); 1410 verify(dst, src); 1411 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1412 throw new RuntimeException("unexpected deoptimization"); 1413 } 1414 } 1415 } 1416 1417 @Test 1418 public void test49(Object src, Object[] dst) { 1419 System.arraycopy(src, 0, dst, 0, 8); 1420 } 1421 1422 @DontCompile 1423 public void test49_verifier(boolean warmup) { 1424 MyValue2?[] src = new MyValue2?[8]; 1425 Object[] dst = new Object[8]; 1426 for (int i = 1; i < 8; ++i) { 1427 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1428 } 1429 test49(src, dst); 1430 verify(src, dst); 1431 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test49")) { 1432 test49(src, dst); 1433 verify(src, dst); 1434 } 1435 } 1436 1437 @Test 1438 public void test50(Object[] src, Object[] dst) { 1439 System.arraycopy(src, 0, dst, 0, 8); 1440 } 1441 1442 @DontCompile 1443 public void test50_verifier(boolean warmup) { 1444 Object[] src = new Object[8]; 1445 Object[] dst = new Object[8]; 1446 for (int i = 1; i < 8; ++i) { 1447 src[i] = MyValue2.createWithFieldsInline(rI, (i % 2) == 0); 1448 } 1449 test50(src, dst); 1450 verify(src, dst); 1451 if (!warmup) { 1452 Method m = tests.get("TestNullableArrays::test50"); 1453 if (USE_COMPILER && !WHITE_BOX.isMethodCompiled(m, false) && !XCOMP) { 1454 throw new RuntimeException("unexpected deoptimization"); 1455 } 1456 } 1457 } 1458 1459 @Test 1460 public MyValue1?[] test51(MyValue1?[] va) { 1461 return Arrays.copyOf(va, va.length, MyValue1?[].class); 1462 } 1463 1464 @DontCompile 1465 public void test51_verifier(boolean warmup) { 1466 int len = Math.abs(rI) % 10; 1467 MyValue1?[] va = new MyValue1?[len]; 1468 for (int i = 1; i < len; ++i) { 1469 va[i] = testValue1; 1470 } 1471 MyValue1?[] result = test51(va); 1472 verify(va, result); 1473 } 1474 1475 static final MyValue1?[] test52_va = new MyValue1?[8]; 1476 1477 @Test 1478 public MyValue1?[] test52() { 1479 return Arrays.copyOf(test52_va, 8, MyValue1?[].class); 1480 } 1481 1482 @DontCompile 1483 public void test52_verifier(boolean warmup) { 1484 for (int i = 1; i < 8; ++i) { 1485 test52_va[i] = testValue1; 1486 } 1487 MyValue1?[] result = test52(); 1488 verify(test52_va, result); 1489 } 1490 1491 @Test 1492 public MyValue1?[] test53(Object[] va) { 1493 return Arrays.copyOf(va, va.length, MyValue1?[].class); 1494 } 1495 1496 @DontCompile 1497 public void test53_verifier(boolean warmup) { 1498 int len = Math.abs(rI) % 10; 1499 MyValue1?[] va = new MyValue1?[len]; 1500 for (int i = 1; i < len; ++i) { 1501 va[i] = testValue1; 1502 } 1503 MyValue1?[] result = test53(va); 1504 verify(result, va); 1505 } 1506 1507 @Test 1508 public Object[] test54(MyValue1?[] va) { 1509 return Arrays.copyOf(va, va.length, Object[].class); 1510 } 1511 1512 @DontCompile 1513 public void test54_verifier(boolean warmup) { 1514 int len = Math.abs(rI) % 10; 1515 MyValue1?[] va = new MyValue1?[len]; 1516 for (int i = 1; i < len; ++i) { 1517 va[i] = testValue1; 1518 } 1519 Object[] result = test54(va); 1520 verify(va, result); 1521 } 1522 1523 @Test 1524 public Object[] test55(Object[] va) { 1525 return Arrays.copyOf(va, va.length, Object[].class); 1526 } 1527 1528 @DontCompile 1529 public void test55_verifier(boolean warmup) { 1530 int len = Math.abs(rI) % 10; 1531 MyValue1?[] va = new MyValue1?[len]; 1532 for (int i = 1; i < len; ++i) { 1533 va[i] = testValue1; 1534 } 1535 Object[] result = test55(va); 1536 verify(va, result); 1537 } 1538 1539 @Test 1540 public MyValue1?[] test56(Object[] va) { 1541 return Arrays.copyOf(va, va.length, MyValue1?[].class); 1542 } 1543 1544 @DontCompile 1545 public void test56_verifier(boolean warmup) { 1546 int len = Math.abs(rI) % 10; 1547 Object[] va = new Object[len]; 1548 for (int i = 1; i < len; ++i) { 1549 va[i] = testValue1; 1550 } 1551 MyValue1?[] result = test56(va); 1552 verify(result, va); 1553 } 1554 1555 @Test 1556 public Object[] test57(Object[] va, Class klass) { 1557 return Arrays.copyOf(va, va.length, klass); 1558 } 1559 1560 @DontCompile 1561 public void test57_verifier(boolean warmup) { 1562 int len = Math.abs(rI) % 10; 1563 Object[] va = new MyValue1?[len]; 1564 for (int i = 1; i < len; ++i) { 1565 va[i] = testValue1; 1566 } 1567 Object[] result = test57(va, MyValue1?[].class); 1568 verify(va, result); 1569 } 1570 1571 @Test 1572 public Object[] test58(MyValue1?[] va, Class klass) { 1573 return Arrays.copyOf(va, va.length, klass); 1574 } 1575 1576 @DontCompile 1577 public void test58_verifier(boolean warmup) { 1578 int len = Math.abs(rI) % 10; 1579 MyValue1?[] va = new MyValue1?[len]; 1580 for (int i = 1; i < len; ++i) { 1581 va[i] = testValue1; 1582 } 1583 for (int i = 1; i < 10; i++) { 1584 Object[] result = test58(va, MyValue1?[].class); 1585 verify(va, result); 1586 } 1587 if (compile_and_run_again_if_deoptimized(warmup, "TestNullableArrays::test58")) { 1588 Object[] result = test58(va, MyValue1?[].class); 1589 verify(va, result); 1590 } 1591 } 1592 1593 @Test 1594 public Object[] test59(MyValue1?[] va) { 1595 return Arrays.copyOf(va, va.length+1, MyValue1?[].class); 1596 } 1597 1598 @DontCompile 1599 public void test59_verifier(boolean warmup) { 1600 int len = Math.abs(rI) % 10; 1601 MyValue1?[] va = new MyValue1?[len]; 1602 MyValue1?[] verif = new MyValue1?[len+1]; 1603 for (int i = 1; i < len; ++i) { 1604 va[i] = testValue1; 1605 verif[i] = va[i]; 1606 } 1607 Object[] result = test59(va); 1608 verify(verif, result); 1609 } 1610 1611 @Test 1612 public Object[] test60(Object[] va, Class klass) { 1613 return Arrays.copyOf(va, va.length+1, klass); 1614 } 1615 1616 @DontCompile 1617 public void test60_verifier(boolean warmup) { 1618 int len = Math.abs(rI) % 10; 1619 MyValue1?[] va = new MyValue1?[len]; 1620 MyValue1?[] verif = new MyValue1?[len+1]; 1621 for (int i = 1; i < len; ++i) { 1622 va[i] = testValue1; 1623 verif[i] = (MyValue1)va[i]; 1624 } 1625 Object[] result = test60(va, MyValue1?[].class); 1626 verify(verif, result); 1627 } 1628 1629 @Test 1630 public Object[] test61(Object[] va, Class klass) { 1631 return Arrays.copyOf(va, va.length+1, klass); 1632 } 1633 1634 @DontCompile 1635 public void test61_verifier(boolean warmup) { 1636 int len = Math.abs(rI) % 10; 1637 Object[] va = new Integer[len]; 1638 for (int i = 1; i < len; ++i) { 1639 va[i] = new Integer(rI); 1640 } 1641 Object[] result = test61(va, Integer[].class); 1642 for (int i = 0; i < va.length; ++i) { 1643 Asserts.assertEQ(va[i], result[i]); 1644 } 1645 } 1646 1647 @ForceInline 1648 public Object[] test62_helper(int i, MyValue1?[] va, Integer[] oa) { 1649 Object[] arr = null; 1650 if (i == 10) { 1651 arr = oa; 1652 } else { 1653 arr = va; 1654 } 1655 return arr; 1656 } 1657 1658 @Test 1659 public Object[] test62(MyValue1?[] va, Integer[] oa) { 1660 int i = 0; 1661 for (; i < 10; i++); 1662 1663 Object[] arr = test62_helper(i, va, oa); 1664 1665 return Arrays.copyOf(arr, arr.length+1, arr.getClass()); 1666 } 1667 1668 @DontCompile 1669 public void test62_verifier(boolean warmup) { 1670 int len = Math.abs(rI) % 10; 1671 MyValue1?[] va = new MyValue1?[len]; 1672 Integer[] oa = new Integer[len]; 1673 for (int i = 1; i < len; ++i) { 1674 oa[i] = new Integer(rI); 1675 } 1676 test62_helper(42, va, oa); 1677 Object[] result = test62(va, oa); 1678 for (int i = 0; i < va.length; ++i) { 1679 Asserts.assertEQ(oa[i], result[i]); 1680 } 1681 } 1682 1683 @ForceInline 1684 public Object[] test63_helper(int i, MyValue1?[] va, Integer[] oa) { 1685 Object[] arr = null; 1686 if (i == 10) { 1687 arr = va; 1688 } else { 1689 arr = oa; 1690 } 1691 return arr; 1692 } 1693 1694 @Test 1695 public Object[] test63(MyValue1?[] va, Integer[] oa) { 1696 int i = 0; 1697 for (; i < 10; i++); 1698 1699 Object[] arr = test63_helper(i, va, oa); 1700 1701 return Arrays.copyOf(arr, arr.length+1, arr.getClass()); 1702 } 1703 1704 @DontCompile 1705 public void test63_verifier(boolean warmup) { 1706 int len = Math.abs(rI) % 10; 1707 MyValue1?[] va = new MyValue1?[len]; 1708 MyValue1?[] verif = new MyValue1?[len+1]; 1709 for (int i = 1; i < len; ++i) { 1710 va[i] = testValue1; 1711 verif[i] = va[i]; 1712 } 1713 Integer[] oa = new Integer[len]; 1714 test63_helper(42, va, oa); 1715 Object[] result = test63(va, oa); 1716 verify(verif, result); 1717 } 1718 1719 // Test default initialization of value type arrays: small array 1720 @Test 1721 public MyValue1?[] test64() { 1722 return new MyValue1?[8]; 1723 } 1724 1725 @DontCompile 1726 public void test64_verifier(boolean warmup) { 1727 MyValue1?[] va = test64(); 1728 for (int i = 0; i < 8; ++i) { 1729 Asserts.assertEQ(va[i], null); 1730 } 1731 } 1732 1733 // Test default initialization of value type arrays: large array 1734 @Test 1735 public MyValue1?[] test65() { 1736 return new MyValue1?[32]; 1737 } 1738 1739 @DontCompile 1740 public void test65_verifier(boolean warmup) { 1741 MyValue1?[] va = test65(); 1742 for (int i = 0; i < 32; ++i) { 1743 Asserts.assertEQ(va[i], null); 1744 } 1745 } 1746 1747 // Check init store elimination 1748 @Test 1749 public MyValue1?[] test66(MyValue1? vt) { 1750 MyValue1?[] va = new MyValue1?[1]; 1751 va[0] = vt; 1752 return va; 1753 } 1754 1755 @DontCompile 1756 public void test66_verifier(boolean warmup) { 1757 MyValue1? vt = MyValue1.createWithFieldsDontInline(rI, rL); 1758 MyValue1?[] va = test66(vt); 1759 Asserts.assertEQ(va[0].hashPrimitive(), vt.hashPrimitive()); 1760 } 1761 1762 // Zeroing elimination and arraycopy 1763 @Test 1764 public MyValue1?[] test67(MyValue1?[] src) { 1765 MyValue1?[] dst = new MyValue1?[16]; 1766 System.arraycopy(src, 0, dst, 0, 13); 1767 return dst; 1768 } 1769 1770 @DontCompile 1771 public void test67_verifier(boolean warmup) { 1772 MyValue1?[] va = new MyValue1?[16]; 1773 MyValue1?[] var = test67(va); 1774 for (int i = 0; i < 16; ++i) { 1775 Asserts.assertEQ(var[i], null); 1776 } 1777 } 1778 1779 // A store with a default value can be eliminated 1780 @Test 1781 public MyValue1?[] test68() { 1782 MyValue1?[] va = new MyValue1?[2]; 1783 va[0] = va[1]; 1784 return va; 1785 } 1786 1787 @DontCompile 1788 public void test68_verifier(boolean warmup) { 1789 MyValue1?[] va = test68(); 1790 for (int i = 0; i < 2; ++i) { 1791 Asserts.assertEQ(va[i], null); 1792 } 1793 } 1794 1795 // Requires individual stores to init array 1796 @Test 1797 public MyValue1?[] test69(MyValue1? vt) { 1798 MyValue1?[] va = new MyValue1?[4]; 1799 va[0] = vt; 1800 va[3] = vt; 1801 return va; 1802 } 1803 1804 @DontCompile 1805 public void test69_verifier(boolean warmup) { 1806 MyValue1? vt = MyValue1.createWithFieldsDontInline(rI, rL); 1807 MyValue1?[] va = new MyValue1?[4]; 1808 va[0] = vt; 1809 va[3] = vt; 1810 MyValue1?[] var = test69(vt); 1811 for (int i = 0; i < va.length; ++i) { 1812 Asserts.assertEQ(va[i], var[i]); 1813 } 1814 } 1815 1816 // A store with a default value can be eliminated: same as test68 1817 // but store is farther away from allocation 1818 @Test 1819 public MyValue1?[] test70(MyValue1?[] other) { 1820 other[1] = other[0]; 1821 MyValue1?[] va = new MyValue1?[2]; 1822 other[0] = va[1]; 1823 va[0] = va[1]; 1824 return va; 1825 } 1826 1827 @DontCompile 1828 public void test70_verifier(boolean warmup) { 1829 MyValue1?[] va = new MyValue1?[2]; 1830 MyValue1?[] var = test70(va); 1831 for (int i = 0; i < 2; ++i) { 1832 Asserts.assertEQ(va[i], var[i]); 1833 } 1834 } 1835 1836 // EA needs to consider oop fields in flattened arrays 1837 @Test 1838 public void test71() { 1839 int len = 10; 1840 MyValue2?[] src = new MyValue2?[len]; 1841 MyValue2?[] dst = new MyValue2?[len]; 1842 for (int i = 1; i < len; ++i) { 1843 src[i] = MyValue2.createWithFieldsDontInline(rI, (i % 2) == 0); 1844 } 1845 System.arraycopy(src, 0, dst, 0, src.length); 1846 for (int i = 0; i < len; ++i) { 1847 if (src[i] == null) { 1848 Asserts.assertEQ(dst[i], null); 1849 } else { 1850 Asserts.assertEQ(src[i].hash(), dst[i].hash()); 1851 } 1852 } 1853 } 1854 1855 @DontCompile 1856 public void test71_verifier(boolean warmup) { 1857 test71(); 1858 } 1859 1860 // Test EA with leaf call to 'store_unknown_value' 1861 @Test 1862 public void test72(Object[] o, boolean b, Object element) { 1863 Object[] arr1 = new Object[10]; 1864 Object[] arr2 = new Object[10]; 1865 if (b) { 1866 arr1 = o; 1867 } 1868 arr1[0] = element; 1869 arr2[0] = element; 1870 } 1871 1872 @DontCompile 1873 public void test72_verifier(boolean warmup) { 1874 Object[] arr = new Object[1]; 1875 Object elem = new Object(); 1876 test72(arr, true, elem); 1877 test72(arr, false, elem); 1878 } 1879 1880 @Test 1881 public void test73(Object[] oa, MyValue1? v, Object o) { 1882 // TestLWorld.test38 use a C1 Phi node for the array. This test 1883 // adds the case where the stored value is a C1 Phi node. 1884 Object o2 = (o == null) ? v : o; 1885 oa[0] = v; // The stored value is known to be flattenable 1886 oa[1] = o; // The stored value may be flattenable 1887 oa[2] = o2; // The stored value may be flattenable (a C1 Phi node) 1888 oa[0] = oa; // The stored value is known to be not flattenable (an Object[]) 1889 } 1890 1891 @DontCompile 1892 public void test73_verifier(boolean warmup) { 1893 MyValue1? v0 = MyValue1.createWithFieldsDontInline(rI, rL); 1894 MyValue1? v1 = MyValue1.createWithFieldsDontInline(rI+1, rL+1); 1895 MyValue1?[] arr = new MyValue1?[3]; 1896 try { 1897 test73(arr, v0, v1); 1898 throw new RuntimeException("ArrayStoreException expected"); 1899 } catch (ArrayStoreException t) { 1900 // expected 1901 } 1902 Asserts.assertEQ(arr[0].hash(), v0.hash()); 1903 Asserts.assertEQ(arr[1].hash(), v1.hash()); 1904 Asserts.assertEQ(arr[2].hash(), v1.hash()); 1905 } 1906 1907 // Some more array clone tests 1908 @ForceInline 1909 public Object[] test74_helper(int i, MyValue1?[] va, Integer[] oa) { 1910 Object[] arr = null; 1911 if (i == 10) { 1912 arr = oa; 1913 } else { 1914 arr = va; 1915 } 1916 return arr; 1917 } 1918 1919 @Test 1920 public Object[] test74(MyValue1?[] va, Integer[] oa) { 1921 int i = 0; 1922 for (; i < 10; i++); 1923 1924 Object[] arr = test74_helper(i, va, oa); 1925 return arr.clone(); 1926 } 1927 1928 @DontCompile 1929 public void test74_verifier(boolean warmup) { 1930 int len = Math.abs(rI) % 10; 1931 MyValue1?[] va = new MyValue1?[len]; 1932 Integer[] oa = new Integer[len]; 1933 for (int i = 1; i < len; ++i) { 1934 oa[i] = new Integer(rI); 1935 } 1936 test74_helper(42, va, oa); 1937 Object[] result = test74(va, oa); 1938 1939 for (int i = 0; i < va.length; ++i) { 1940 Asserts.assertEQ(oa[i], result[i]); 1941 // Check that array has correct storage properties (null-ok) 1942 result[i] = null; 1943 } 1944 } 1945 1946 @ForceInline 1947 public Object[] test75_helper(int i, MyValue1?[] va, Integer[] oa) { 1948 Object[] arr = null; 1949 if (i == 10) { 1950 arr = va; 1951 } else { 1952 arr = oa; 1953 } 1954 return arr; 1955 } 1956 1957 @Test 1958 public Object[] test75(MyValue1?[] va, Integer[] oa) { 1959 int i = 0; 1960 for (; i < 10; i++); 1961 1962 Object[] arr = test75_helper(i, va, oa); 1963 return arr.clone(); 1964 } 1965 1966 @DontCompile 1967 public void test75_verifier(boolean warmup) { 1968 int len = Math.abs(rI) % 10; 1969 MyValue1?[] va = new MyValue1?[len]; 1970 MyValue1?[] verif = new MyValue1?[len]; 1971 for (int i = 1; i < len; ++i) { 1972 va[i] = testValue1; 1973 verif[i] = va[i]; 1974 } 1975 Integer[] oa = new Integer[len]; 1976 test75_helper(42, va, oa); 1977 Object[] result = test75(va, oa); 1978 verify(verif, result); 1979 if (len > 0) { 1980 // Check that array has correct storage properties (null-ok) 1981 result[0] = null; 1982 } 1983 } 1984 1985 // Test mixing nullable and non-nullable arrays 1986 @Test 1987 public Object[] test76(MyValue1[] vva, MyValue1?[] vba, MyValue1 vt, Object[] out, int n) { 1988 Object[] result = null; 1989 if (n == 0) { 1990 result = vva; 1991 } else if (n == 1) { 1992 result = vba; 1993 } else if (n == 2) { 1994 result = new MyValue1[42]; 1995 } else if (n == 3) { 1996 result = new MyValue1?[42]; 1997 } 1998 result[0] = vt; 1999 out[0] = result[1]; 2000 return result; 2001 } 2002 2003 @DontCompile 2004 public void test76_verifier(boolean warmup) { 2005 MyValue1 vt = testValue1; 2006 Object[] out = new Object[1]; 2007 MyValue1[] vva = new MyValue1[42]; 2008 MyValue1[] vva_r = new MyValue1[42]; 2009 vva_r[0] = vt; 2010 MyValue1?[] vba = new MyValue1?[42]; 2011 MyValue1?[] vba_r = new MyValue1?[42]; 2012 vba_r[0] = vt; 2013 Object[] result = test76(vva, vba, vt, out, 0); 2014 verify(result, vva_r); 2015 Asserts.assertEQ(out[0], vva_r[1]); 2016 result = test76(vva, vba, vt, out, 1); 2017 verify(result, vba_r); 2018 Asserts.assertEQ(out[0], vba_r[1]); 2019 result = test76(vva, vba, vt, out, 2); 2020 verify(result, vva_r); 2021 Asserts.assertEQ(out[0], vva_r[1]); 2022 result = test76(vva, vba, vt, out, 3); 2023 verify(result, vba_r); 2024 Asserts.assertEQ(out[0], vba_r[1]); 2025 } 2026 2027 @Test 2028 public Object[] test77(boolean b) { 2029 Object[] va; 2030 if (b) { 2031 va = new MyValue1?[5]; 2032 for (int i = 0; i < 5; ++i) { 2033 va[i] = testValue1; 2034 } 2035 } else { 2036 va = new MyValue1[10]; 2037 for (int i = 0; i < 10; ++i) { 2038 va[i] = MyValue1.createWithFieldsInline(rI + i, rL + i); 2039 } 2040 } 2041 long sum = ((MyValue1)va[0]).hashInterpreted(); 2042 if (b) { 2043 va[0] = MyValue1.createWithFieldsDontInline(rI, sum); 2044 } else { 2045 va[0] = MyValue1.createWithFieldsDontInline(rI + 1, sum + 1); 2046 } 2047 return va; 2048 } 2049 2050 @DontCompile 2051 public void test77_verifier(boolean warmup) { 2052 Object[] va = test77(true); 2053 Asserts.assertEQ(va.length, 5); 2054 Asserts.assertEQ(((MyValue1)va[0]).hash(), hash(rI, hash())); 2055 for (int i = 1; i < 5; ++i) { 2056 Asserts.assertEQ(((MyValue1)va[i]).hash(), hash()); 2057 } 2058 va = test77(false); 2059 Asserts.assertEQ(va.length, 10); 2060 Asserts.assertEQ(((MyValue1)va[0]).hash(), hash(rI + 1, hash(rI, rL) + 1)); 2061 for (int i = 1; i < 10; ++i) { 2062 Asserts.assertEQ(((MyValue1)va[i]).hash(), hash(rI + i, rL + i)); 2063 } 2064 } 2065 2066 // Same as test76 but with non value type array cases 2067 @Test 2068 public Object[] test78(MyValue1[] vva, MyValue1?[] vba, Object val, Object[] out, int n) { 2069 Object[] result = null; 2070 if (n == 0) { 2071 result = vva; 2072 } else if (n == 1) { 2073 result = vba; 2074 } else if (n == 2) { 2075 result = new MyValue1[42]; 2076 } else if (n == 3) { 2077 result = new MyValue1?[42]; 2078 } else if (n == 4) { 2079 result = new Integer[42]; 2080 } 2081 result[0] = val; 2082 out[0] = result[1]; 2083 return result; 2084 } 2085 2086 @DontCompile 2087 public void test78_verifier(boolean warmup) { 2088 MyValue1 vt = testValue1; 2089 Integer i = new Integer(42); 2090 Object[] out = new Object[1]; 2091 MyValue1[] vva = new MyValue1[42]; 2092 MyValue1[] vva_r = new MyValue1[42]; 2093 vva_r[0] = vt; 2094 MyValue1?[] vba = new MyValue1?[42]; 2095 MyValue1?[] vba_r = new MyValue1?[42]; 2096 vba_r[0] = vt; 2097 Object[] result = test78(vva, vba, vt, out, 0); 2098 verify(result, vva_r); 2099 Asserts.assertEQ(out[0], vva_r[1]); 2100 result = test78(vva, vba, vt, out, 1); 2101 verify(result, vba_r); 2102 Asserts.assertEQ(out[0], vba_r[1]); 2103 result = test78(vva, vba, vt, out, 2); 2104 verify(result, vva_r); 2105 Asserts.assertEQ(out[0], vva_r[1]); 2106 result = test78(vva, vba, vt, out, 3); 2107 verify(result, vba_r); 2108 Asserts.assertEQ(out[0], vba_r[1]); 2109 result = test78(vva, vba, i, out, 4); 2110 Asserts.assertEQ(result[0], i); 2111 Asserts.assertEQ(out[0], null); 2112 } 2113 2114 // Test widening conversions from [Q to [L 2115 @Test(failOn = ALLOC + ALLOCA + STORE) 2116 public static MyValue1?[] test79(MyValue1[] va) { 2117 return va; 2118 } 2119 2120 @DontCompile 2121 public void test79_verifier(boolean warmup) { 2122 MyValue1[] va = new MyValue1[1]; 2123 va[0] = testValue1; 2124 MyValue1?[] res = test79(va); 2125 Asserts.assertEquals(res[0].hash(), testValue1.hash()); 2126 try { 2127 res[0] = null; 2128 throw new RuntimeException("NullPointerException expected"); 2129 } catch (NullPointerException npe) { 2130 // Expected 2131 } 2132 res[0] = testValue1; 2133 test79(null); // Should not throw NPE 2134 } 2135 2136 // Same as test79 but with explicit cast and Object return 2137 @Test(failOn = ALLOC + ALLOCA + STORE) 2138 public static Object[] test80(MyValue1[] va) { 2139 return (MyValue1?[])va; 2140 } 2141 2142 @DontCompile 2143 public void test80_verifier(boolean warmup) { 2144 MyValue1[] va = new MyValue1[1]; 2145 va[0] = testValue1; 2146 Object[] res = test80(va); 2147 Asserts.assertEquals(((MyValue1)res[0]).hash(), testValue1.hash()); 2148 try { 2149 res[0] = null; 2150 throw new RuntimeException("NullPointerException expected"); 2151 } catch (NullPointerException npe) { 2152 // Expected 2153 } 2154 res[0] = testValue1; 2155 test80(null); // Should not throw NPE 2156 } 2157 2158 // Test mixing widened and boxed array type 2159 @Test() 2160 public static long test81(MyValue1[] va1, MyValue1?[] va2, MyValue1 vt, boolean b, boolean shouldThrow) { 2161 MyValue1?[] result = b ? va1 : va2; 2162 try { 2163 result[0] = vt; 2164 } catch (NullPointerException npe) { 2165 // Ignored 2166 } 2167 return result[1].hash(); 2168 } 2169 2170 @DontCompile 2171 public void test81_verifier(boolean warmup) { 2172 MyValue1[] va = new MyValue1[2]; 2173 MyValue1?[] vaB = new MyValue1?[2]; 2174 va[1] = testValue1; 2175 vaB[1] = testValue1; 2176 long res = test81(va, vaB, testValue1, true, true); 2177 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2178 Asserts.assertEquals(res, testValue1.hash()); 2179 res = test81(va, vaB, testValue1, false, false); 2180 Asserts.assertEquals(vaB[0].hash(), testValue1.hash()); 2181 Asserts.assertEquals(res, testValue1.hash()); 2182 res = test81(va, va, testValue1, false, true); 2183 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2184 Asserts.assertEquals(res, testValue1.hash()); 2185 } 2186 2187 // Same as test81 but more cases and null writes 2188 @Test() 2189 public static long test82(MyValue1[] va1, MyValue1?[] va2, MyValue1 vt1, MyValue1? vt2, int i, boolean shouldThrow) { 2190 MyValue1?[] result = null; 2191 if (i == 0) { 2192 result = va1; 2193 } else if (i == 1) { 2194 result = va2; 2195 } else if (i == 2) { 2196 result = new MyValue1?[2]; 2197 result[1] = vt1; 2198 } else if (i == 3) { 2199 result = new MyValue1[2]; 2200 result[1] = vt1; 2201 } 2202 try { 2203 result[0] = (i <= 1) ? null : vt2; 2204 if (shouldThrow) { 2205 throw new RuntimeException("NullPointerException expected"); 2206 } 2207 } catch (NullPointerException npe) { 2208 Asserts.assertTrue(shouldThrow, "NullPointerException thrown"); 2209 } 2210 result[0] = vt1; 2211 return result[1].hash(); 2212 } 2213 2214 @DontCompile 2215 public void test82_verifier(boolean warmup) { 2216 MyValue1[] va = new MyValue1[2]; 2217 MyValue1?[] vaB = new MyValue1?[2]; 2218 va[1] = testValue1; 2219 vaB[1] = testValue1; 2220 long res = test82(va, vaB, testValue1, testValue1, 0, true); 2221 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2222 Asserts.assertEquals(res, testValue1.hash()); 2223 res = test82(va, vaB, testValue1, testValue1, 1, false); 2224 Asserts.assertEquals(vaB[0].hash(), testValue1.hash()); 2225 Asserts.assertEquals(res, testValue1.hash()); 2226 res = test82(va, va, testValue1, testValue1, 1, true); 2227 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2228 Asserts.assertEquals(res, testValue1.hash()); 2229 res = test82(va, va, testValue1, null, 2, false); 2230 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2231 Asserts.assertEquals(res, testValue1.hash()); 2232 res = test82(va, va, testValue1, null, 3, true); 2233 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2234 Asserts.assertEquals(res, testValue1.hash()); 2235 } 2236 2237 @Test(failOn = ALLOC + ALLOCA + STORE) 2238 public static long test83(MyValue1[] va) { 2239 MyValue1?[] result = va; 2240 return result[0].hash(); 2241 } 2242 2243 @DontCompile 2244 public void test83_verifier(boolean warmup) { 2245 MyValue1[] va = new MyValue1[42]; 2246 va[0] = testValue1; 2247 long res = test83(va); 2248 Asserts.assertEquals(res, testValue1.hash()); 2249 } 2250 2251 @Test(failOn = ALLOC + ALLOCA + STORE) 2252 public static MyValue1?[] test84(MyValue1 vt1, MyValue1? vt2) { 2253 MyValue1?[] result = new MyValue1[2]; 2254 result[0] = vt1; 2255 result[1] = vt2; 2256 return result; 2257 } 2258 2259 @DontCompile 2260 public void test84_verifier(boolean warmup) { 2261 MyValue1?[] res = test84(testValue1, testValue1); 2262 Asserts.assertEquals(res[0].hash(), testValue1.hash()); 2263 Asserts.assertEquals(res[1].hash(), testValue1.hash()); 2264 try { 2265 test84(testValue1, null); 2266 throw new RuntimeException("NullPointerException expected"); 2267 } catch (NullPointerException npe) { 2268 // Expected 2269 } 2270 } 2271 2272 @Test() 2273 public static long test85(MyValue1?[] va, MyValue1 val) { 2274 va[0] = val; 2275 return va[1].hash(); 2276 } 2277 2278 @DontCompile 2279 public void test85_verifier(boolean warmup) { 2280 MyValue1[] va = new MyValue1[2]; 2281 MyValue1?[] vab = new MyValue1?[2]; 2282 va[1] = testValue1; 2283 vab[1] = testValue1; 2284 long res = test85(va, testValue1); 2285 Asserts.assertEquals(res, testValue1.hash()); 2286 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2287 res = test85(vab, testValue1); 2288 Asserts.assertEquals(res, testValue1.hash()); 2289 Asserts.assertEquals(vab[0].hash(), testValue1.hash()); 2290 } 2291 2292 // Same as test85 but with box value 2293 @Test() 2294 public static long test86(MyValue1?[] va, MyValue1? val) { 2295 va[0] = val; 2296 return va[1].hash(); 2297 } 2298 2299 @DontCompile 2300 public void test86_verifier(boolean warmup) { 2301 MyValue1[] va = new MyValue1[2]; 2302 MyValue1?[] vab = new MyValue1?[2]; 2303 va[1] = testValue1; 2304 vab[1] = testValue1; 2305 long res = test86(va, testValue1); 2306 Asserts.assertEquals(res, testValue1.hash()); 2307 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2308 try { 2309 test86(va, null); 2310 throw new RuntimeException("NullPointerException expected"); 2311 } catch (NullPointerException npe) { 2312 // Expected 2313 } 2314 res = test86(vab, testValue1); 2315 Asserts.assertEquals(res, testValue1.hash()); 2316 Asserts.assertEquals(vab[0].hash(), testValue1.hash()); 2317 res = test86(vab, null); 2318 Asserts.assertEquals(res, testValue1.hash()); 2319 Asserts.assertEquals(vab[0], null); 2320 } 2321 2322 // Test initialization of nullable array with constant 2323 @Test() 2324 public long test87() { 2325 MyValue1?[] va = new MyValue1?[1]; 2326 va[0] = testValue1; 2327 return va[0].hash(); 2328 } 2329 2330 @DontCompile 2331 public void test87_verifier(boolean warmup) { 2332 long result = test87(); 2333 Asserts.assertEQ(result, hash()); 2334 } 2335 2336 // Test narrowing conversion from [L to [Q 2337 @Test(failOn = ALLOC + ALLOCA + STORE) 2338 public static MyValue1[] test88(MyValue1?[] va) { 2339 return (MyValue1[])va; 2340 } 2341 2342 @DontCompile 2343 public void test88_verifier(boolean warmup) { 2344 MyValue1[] va = new MyValue1[1]; 2345 va[0] = testValue1; 2346 MyValue1[] res = test88(va); 2347 Asserts.assertEquals(res[0].hash(), testValue1.hash()); 2348 res[0] = testValue1; 2349 test88(null); // Should not throw NPE 2350 try { 2351 test88(new MyValue1?[1]); 2352 throw new RuntimeException("ClassCastException expected"); 2353 } catch (ClassCastException cce) { 2354 // Expected 2355 } 2356 } 2357 2358 // Same as test88 but with explicit cast and Object argument 2359 @Test(failOn = ALLOC + ALLOCA + STORE) 2360 public static MyValue1[] test89(Object[] va) { 2361 return (MyValue1[])va; 2362 } 2363 2364 @DontCompile 2365 public void test89_verifier(boolean warmup) { 2366 MyValue1[] va = new MyValue1[1]; 2367 va[0] = testValue1; 2368 MyValue1[] res = test89(va); 2369 Asserts.assertEquals(((MyValue1)res[0]).hash(), testValue1.hash()); 2370 res[0] = testValue1; 2371 test89(null); // Should not throw NPE 2372 try { 2373 test89(new MyValue1?[1]); 2374 throw new RuntimeException("ClassCastException expected"); 2375 } catch (ClassCastException cce) { 2376 // Expected 2377 } 2378 } 2379 2380 // More cast tests 2381 @Test() 2382 public static MyValue1?[] test90(Object va) { 2383 return (MyValue1?[])va; 2384 } 2385 2386 @DontCompile 2387 public void test90_verifier(boolean warmup) { 2388 MyValue1[] va = new MyValue1[1]; 2389 MyValue1?[] vab = new MyValue1?[1]; 2390 try { 2391 // Trigger some ClassCastExceptions so C2 does not add an uncommon trap 2392 test90(new Integer[0]); 2393 } catch (ClassCastException cce) { 2394 // Expected 2395 } 2396 test90(va); 2397 test90(vab); 2398 test90(null); 2399 } 2400 2401 @Test() 2402 public static MyValue1?[] test91(Object[] va) { 2403 return (MyValue1?[])va; 2404 } 2405 2406 @DontCompile 2407 public void test91_verifier(boolean warmup) { 2408 MyValue1[] va = new MyValue1[1]; 2409 MyValue1?[] vab = new MyValue1?[1]; 2410 try { 2411 // Trigger some ClassCastExceptions so C2 does not add an uncommon trap 2412 test91(new Integer[0]); 2413 } catch (ClassCastException cce) { 2414 // Expected 2415 } 2416 test91(va); 2417 test91(vab); 2418 test91(null); 2419 } 2420 2421 // Test if arraycopy intrinsic correctly checks for flattened source array 2422 @Test() 2423 public static void test92(MyValue1?[] src, MyValue1?[] dst) { 2424 System.arraycopy(src, 0, dst, 0, 2); 2425 } 2426 2427 @DontCompile 2428 public void test92_verifier(boolean warmup) { 2429 MyValue1[] va = new MyValue1[2]; 2430 MyValue1?[] vab = new MyValue1?[2]; 2431 va[0] = testValue1; 2432 vab[0] = testValue1; 2433 test92(va, vab); 2434 Asserts.assertEquals(va[0], vab[0]); 2435 Asserts.assertEquals(va[1], vab[1]); 2436 } 2437 2438 @Test() 2439 public static void test93(Object src, MyValue1?[] dst) { 2440 System.arraycopy(src, 0, dst, 0, 2); 2441 } 2442 2443 @DontCompile 2444 public void test93_verifier(boolean warmup) { 2445 MyValue1[] va = new MyValue1[2]; 2446 MyValue1?[] vab = new MyValue1?[2]; 2447 va[0] = testValue1; 2448 vab[0] = testValue1; 2449 test93(va, vab); 2450 Asserts.assertEquals(va[0], vab[0]); 2451 Asserts.assertEquals(va[1], vab[1]); 2452 } 2453 2454 // Test non-escaping allocation with arraycopy 2455 // that does not modify loaded array element. 2456 @Test() 2457 public static long test94() { 2458 MyValue1?[] src = new MyValue1?[8]; 2459 MyValue1[] dst = new MyValue1[8]; 2460 for (int i = 1; i < 8; ++i) { 2461 src[i] = testValue1; 2462 } 2463 System.arraycopy(src, 1, dst, 2, 6); 2464 return dst[0].hash(); 2465 } 2466 2467 @DontCompile 2468 public static void test94_verifier(boolean warmup) { 2469 long result = test94(); 2470 Asserts.assertEquals(result, MyValue1.default.hash()); 2471 } 2472 2473 // Test meeting constant TypeInstPtr with ValueTypeNode 2474 @ForceInline 2475 public long test95_callee() { 2476 MyValue1?[] va = new MyValue1?[1]; 2477 va[0] = testValue1; 2478 return va[0].hashInterpreted(); 2479 } 2480 2481 @Test() 2482 @Warmup(0) 2483 public long test95() { 2484 return test95_callee(); 2485 } 2486 2487 @DontCompile 2488 public void test95_verifier(boolean warmup) { 2489 long result = test95(); 2490 Asserts.assertEQ(result, hash()); 2491 } 2492 2493 // Matrix multiplication test to exercise type flow analysis with nullable value arrays 2494 inline static class Complex { 2495 private final double re; 2496 private final double im; 2497 2498 Complex(double re, double im) { 2499 this.re = re; 2500 this.im = im; 2501 } 2502 2503 public Complex add(Complex that) { 2504 return new Complex(this.re + that.re, this.im + that.im); 2505 } 2506 2507 public Complex mul(Complex that) { 2508 return new Complex(this.re * that.re - this.im * that.im, 2509 this.re * that.im + this.im * that.re); 2510 } 2511 } 2512 2513 @Test() 2514 public Complex?[][] test96(Complex?[][] A, Complex?[][] B) { 2515 int size = A.length; 2516 Complex?[][] R = new Complex?[size][size]; 2517 for (int i = 0; i < size; i++) { 2518 for (int k = 0; k < size; k++) { 2519 Complex? aik = A[i][k]; 2520 for (int j = 0; j < size; j++) { 2521 R[i][j] = B[i][j].add(aik.mul((Complex)B[k][j])); 2522 } 2523 } 2524 } 2525 return R; 2526 } 2527 2528 static Complex?[][] test96_A = new Complex?[10][10]; 2529 static Complex?[][] test96_B = new Complex?[10][10]; 2530 static Complex?[][] test96_R; 2531 2532 static { 2533 for (int i = 0; i < 10; i++) { 2534 for (int j = 0; j < 10; j++) { 2535 test96_A[i][j] = new Complex(rI, rI); 2536 test96_B[i][j] = new Complex(rI, rI); 2537 } 2538 } 2539 } 2540 2541 @DontCompile 2542 public void test96_verifier(boolean warmup) { 2543 Complex?[][] result = test96(test96_A, test96_B); 2544 if (test96_R == null) { 2545 test96_R = result; 2546 } 2547 for (int i = 0; i < 10; i++) { 2548 for (int j = 0; j < 10; j++) { 2549 Asserts.assertEQ(result[i][j], test96_R[i][j]); 2550 } 2551 } 2552 } 2553 2554 // Test loads from vararg arrays 2555 @Test(failOn = LOAD_UNKNOWN_VALUE) 2556 public static Object test97(Object... args) { 2557 return args[0]; 2558 } 2559 2560 @DontCompile 2561 public static void test97_verifier(boolean warmup) { 2562 Object obj = new Object(); 2563 Object result = test97(obj); 2564 Asserts.assertEquals(result, obj); 2565 Integer[] myInt = new Integer[1]; 2566 myInt[0] = rI; 2567 result = test97((Object[])myInt); 2568 Asserts.assertEquals(result, rI); 2569 } 2570 2571 @Test() 2572 public static Object test98(Object... args) { 2573 return args[0]; 2574 } 2575 2576 @DontCompile 2577 public static void test98_verifier(boolean warmup) { 2578 Object obj = new Object(); 2579 Object result = test98(obj); 2580 Asserts.assertEquals(result, obj); 2581 Integer[] myInt = new Integer[1]; 2582 myInt[0] = rI; 2583 result = test98((Object[])myInt); 2584 Asserts.assertEquals(result, rI); 2585 if (!warmup) { 2586 MyValue1[] va = new MyValue1[1]; 2587 MyValue1?[] vab = new MyValue1?[1]; 2588 result = test98((Object[])va); 2589 Asserts.assertEquals(((MyValue1)result).hash(), MyValue1.default.hash()); 2590 result = test98((Object[])vab); 2591 Asserts.assertEquals(result, null); 2592 } 2593 } 2594 2595 @Test() 2596 public static Object test99(Object... args) { 2597 return args[0]; 2598 } 2599 2600 @DontCompile 2601 public static void test99_verifier(boolean warmup) { 2602 Object obj = new Object(); 2603 Object result = test99(obj); 2604 Asserts.assertEquals(result, obj); 2605 Integer[] myInt = new Integer[1]; 2606 myInt[0] = rI; 2607 result = test99((Object[])myInt); 2608 Asserts.assertEquals(result, rI); 2609 if (!warmup) { 2610 try { 2611 test99((Object[])null); 2612 throw new RuntimeException("No NPE thrown"); 2613 } catch (NullPointerException npe) { 2614 // Expected 2615 } 2616 } 2617 } 2618 2619 @Test() 2620 public static Object test100(Object... args) { 2621 return args[0]; 2622 } 2623 2624 @DontCompile 2625 public static void test100_verifier(boolean warmup) { 2626 Object obj = new Object(); 2627 Object result = test100(obj); 2628 Asserts.assertEquals(result, obj); 2629 Integer[] myInt = new Integer[1]; 2630 myInt[0] = rI; 2631 result = test100((Object[])myInt); 2632 Asserts.assertEquals(result, rI); 2633 if (!warmup) { 2634 try { 2635 test100(); 2636 throw new RuntimeException("No AIOOBE thrown"); 2637 } catch (ArrayIndexOutOfBoundsException aioobe) { 2638 // Expected 2639 } 2640 } 2641 } 2642 2643 // Test stores to varag arrays 2644 @Test(failOn = STORE_UNKNOWN_VALUE) 2645 public static void test101(Object val, Object... args) { 2646 args[0] = val; 2647 } 2648 2649 @DontCompile 2650 public static void test101_verifier(boolean warmup) { 2651 Object obj = new Object(); 2652 test101(obj, obj); 2653 Integer[] myInt = new Integer[1]; 2654 test101(rI, (Object[])myInt); 2655 Asserts.assertEquals(myInt[0], rI); 2656 test101(null, (Object[])myInt); 2657 Asserts.assertEquals(myInt[0], null); 2658 } 2659 2660 @Test() 2661 public static void test102(Object val, Object... args) { 2662 args[0] = val; 2663 } 2664 2665 @DontCompile 2666 public static void test102_verifier(boolean warmup) { 2667 Object obj = new Object(); 2668 test102(obj, obj); 2669 Integer[] myInt = new Integer[1]; 2670 test102(rI, (Object[])myInt); 2671 Asserts.assertEquals(myInt[0], rI); 2672 test102(null, (Object[])myInt); 2673 Asserts.assertEquals(myInt[0], null); 2674 if (!warmup) { 2675 MyValue1[] va = new MyValue1[1]; 2676 MyValue1?[] vab = new MyValue1?[1]; 2677 test102(testValue1, (Object[])va); 2678 Asserts.assertEquals(va[0].hash(), testValue1.hash()); 2679 test102(testValue1, (Object[])vab); 2680 Asserts.assertEquals(vab[0].hash(), testValue1.hash()); 2681 test102(null, (Object[])vab); 2682 Asserts.assertEquals(vab[0], null); 2683 } 2684 } 2685 2686 @Test() 2687 public static void test103(Object val, Object... args) { 2688 args[0] = val; 2689 } 2690 2691 @DontCompile 2692 public static void test103_verifier(boolean warmup) { 2693 Object obj = new Object(); 2694 test103(obj, obj); 2695 Integer[] myInt = new Integer[1]; 2696 test103(rI, (Object[])myInt); 2697 Asserts.assertEquals(myInt[0], rI); 2698 test103(null, (Object[])myInt); 2699 Asserts.assertEquals(myInt[0], null); 2700 if (!warmup) { 2701 MyValue1[] va = new MyValue1[1]; 2702 try { 2703 test103(null, (Object[])va); 2704 throw new RuntimeException("No NPE thrown"); 2705 } catch (NullPointerException npe) { 2706 // Expected 2707 } 2708 } 2709 } 2710 2711 @Test() 2712 public static void test104(Object val, Object... args) { 2713 args[0] = val; 2714 } 2715 2716 @DontCompile 2717 public static void test104_verifier(boolean warmup) { 2718 Object obj = new Object(); 2719 test104(obj, obj); 2720 Integer[] myInt = new Integer[1]; 2721 test104(rI, (Object[])myInt); 2722 Asserts.assertEquals(myInt[0], rI); 2723 test104(null, (Object[])myInt); 2724 Asserts.assertEquals(myInt[0], null); 2725 if (!warmup) { 2726 try { 2727 test104(testValue1); 2728 throw new RuntimeException("No AIOOBE thrown"); 2729 } catch (ArrayIndexOutOfBoundsException aioobe) { 2730 // Expected 2731 } 2732 } 2733 } 2734 2735 @Test() 2736 public static void test105(Object val, Object... args) { 2737 args[0] = val; 2738 } 2739 2740 @DontCompile 2741 public static void test105_verifier(boolean warmup) { 2742 Object obj = new Object(); 2743 test105(obj, obj); 2744 Integer[] myInt = new Integer[1]; 2745 test105(rI, (Object[])myInt); 2746 Asserts.assertEquals(myInt[0], rI); 2747 test105(null, (Object[])myInt); 2748 Asserts.assertEquals(myInt[0], null); 2749 if (!warmup) { 2750 try { 2751 test105(testValue1, (Object[])null); 2752 throw new RuntimeException("No NPE thrown"); 2753 } catch (NullPointerException npe) { 2754 // Expected 2755 } 2756 } 2757 } 2758 2759 @Test() 2760 public static Object[] test106(Object[] dst, Object... args) { 2761 // Access array to speculate on non-flatness 2762 if (args[0] == null) { 2763 args[0] = testValue1; 2764 } 2765 System.arraycopy(args, 0, dst, 0, args.length); 2766 System.arraycopy(dst, 0, args, 0, dst.length); 2767 Object[] clone = args.clone(); 2768 if (clone[0] == null) { 2769 throw new RuntimeException("Unexpected null"); 2770 } 2771 return Arrays.copyOf(args, args.length, Object[].class); 2772 } 2773 2774 @DontCompile 2775 public static void test106_verifier(boolean warmup) { 2776 Object[] dst = new Object[1]; 2777 Object obj = new Object(); 2778 Object[] result = test106(dst, obj); 2779 Asserts.assertEquals(result[0], obj); 2780 Integer[] myInt = new Integer[1]; 2781 myInt[0] = rI; 2782 result = test106(myInt, (Object[])myInt); 2783 Asserts.assertEquals(result[0], rI); 2784 if (!warmup) { 2785 MyValue1[] va = new MyValue1[1]; 2786 MyValue1?[] vab = new MyValue1?[1]; 2787 result = test106(va, (Object[])va); 2788 Asserts.assertEquals(((MyValue1)result[0]).hash(), MyValue1.default.hash()); 2789 result = test106(vab, (Object[])vab); 2790 Asserts.assertEquals(((MyValue1)result[0]).hash(), testValue1.hash()); 2791 } 2792 } 2793 }