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