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 }