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