1 /*
2 * Copyright (c) 2016, 2017, 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 // TODO add bugid and summary
25
26 /*
27 * @test
28 * @library /testlibrary /test/lib /compiler/whitebox /
29 * @requires os.simpleArch == "x64"
30 * @modules java.base/jdk.internal.misc:+open
31 * @compile -XDenableValueTypes ValueCapableClass1.java ValueCapableClass2.java ValueTypeTestBench.java
32 * @run main ClassFileInstaller sun.hotspot.WhiteBox
33 * @run main ClassFileInstaller jdk.test.lib.Platform
34 * @run main/othervm -Xbootclasspath/a:. -ea -noverify -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
35 * -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI -XX:-TieredCompilation -XX:+VerifyAdapterSharing
36 * -XX:+EnableValhalla -XX:+EnableMVT -XX:+ValueTypePassFieldsAsArgs -XX:+ValueTypeReturnedAsFields -XX:+ValueArrayFlatten
37 * -XX:ValueArrayElemMaxFlatSize=-1 -XX:ValueArrayElemMaxFlatOops=-1 -XX:+FullGCALotWithValueTypes
38 * compiler.valhalla.valuetypes.ValueTypeTestBench
39 * @run main/othervm -Xbootclasspath/a:. -ea -noverify -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
40 * -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI -XX:-TieredCompilation
41 * -XX:+EnableValhalla -XX:+EnableMVT -XX:-ValueTypePassFieldsAsArgs -XX:-ValueTypeReturnedAsFields -XX:-ValueArrayFlatten
42 * compiler.valhalla.valuetypes.ValueTypeTestBench
43 * @run main/othervm -Xbootclasspath/a:. -ea -noverify -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
44 * -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI -XX:-TieredCompilation -XX:+AlwaysIncrementalInline
45 * -XX:+EnableValhalla -XX:+EnableMVT -XX:+ValueTypePassFieldsAsArgs -XX:+ValueTypeReturnedAsFields -XX:+ValueArrayFlatten
46 * -XX:ValueArrayElemMaxFlatSize=-1 -XX:ValueArrayElemMaxFlatOops=-1
47 * compiler.valhalla.valuetypes.ValueTypeTestBench
48 */
49
50 package compiler.valhalla.valuetypes;
51
52 import compiler.whitebox.CompilerWhiteBoxTest;
53 import jdk.internal.misc.Unsafe;
54 import jdk.test.lib.Asserts;
55 import jdk.test.lib.management.InputArguments;
56 import jdk.test.lib.Platform;
57 import jdk.test.lib.process.ProcessTools;
58 import jdk.test.lib.process.OutputAnalyzer;
59 import jdk.test.lib.Utils;
60 import sun.hotspot.WhiteBox;
61
62 import java.lang.annotation.Retention;
63 import java.lang.annotation.RetentionPolicy;
64 import java.lang.annotation.Repeatable;
65 import java.lang.invoke.*;
66 import java.lang.reflect.Method;
67 import java.util.ArrayList;
68 import java.util.Arrays;
69 import java.util.Hashtable;
70 import java.util.LinkedHashMap;
71 import java.util.List;
72 import java.util.Map;
73 import java.util.regex.Matcher;
74 import java.util.regex.Pattern;
75 import jdk.experimental.value.*;
76
77 // Test value types
78 __ByValue final class MyValue1 {
79 static int s;
80 static final long sf = ValueTypeTestBench.rL;
81 final int x;
82 final long y;
83 final short z;
84 final Integer o;
85 final int[] oa;
86 final MyValue2 v1;
87 final MyValue2 v2;
88 static final MyValue2 v3 = MyValue2.createWithFieldsInline(ValueTypeTestBench.rI, true);
89 final int c;
90
91 private MyValue1(int x, long y, short z, Integer o, int[] oa, MyValue2 v1, MyValue2 v2, int c) {
92 s = x;
93 this.x = x;
94 this.y = y;
95 this.z = z;
96 this.o = o;
97 this.oa = oa;
98 this.v1 = v1;
99 this.v2 = v2;
100 this.c = c;
101 }
102
103 private MyValue1() {
104 s = 0;
105 this.x = 0;
106 this.y = 0;
107 this.z = 0;
108 this.o = null;
109 this.oa = null;
110 this.v1 = MyValue2.createDefaultInline();
111 this.v2 = MyValue2.createDefaultInline();
112 this.c = 0;
113 }
114
115 @DontInline
116 __ValueFactory static MyValue1 createDefaultDontInline() {
117 return __MakeDefault MyValue1();
118 }
119
120 @ForceInline
121 __ValueFactory static MyValue1 createDefaultInline() {
122 return __MakeDefault MyValue1();
123 }
124
125 @DontInline
126 static MyValue1 createWithFieldsDontInline(int x, long y) {
127 MyValue1 v = createDefaultInline();
128 v = setX(v, x);
129 v = setY(v, y);
130 v = setZ(v, (short)x);
131 v = setO(v, new Integer(x));
132 int[] oa = {x};
133 v = setOA(v, oa);
134 v = setV1(v, MyValue2.createWithFieldsInline(x, x < y));
135 v = setV2(v, MyValue2.createWithFieldsInline(x, x > y));
136 v = setC(v, ValueTypeTestBench.rI);
137 return v;
138 }
139
140 @ForceInline
141 static MyValue1 createWithFieldsInline(int x, long y) {
142 MyValue1 v = createDefaultInline();
143 v = setX(v, x);
144 v = setY(v, y);
145 v = setZ(v, (short)x);
146 v = setO(v, new Integer(x));
147 int[] oa = {x};
148 v = setOA(v, oa);
149 v = setV1(v, MyValue2.createWithFieldsInline(x, x < y));
150 v = setV2(v, MyValue2.createWithFieldsInline(x, x > y));
151 v = setC(v, ValueTypeTestBench.rI);
152 return v;
153 }
154
155 // Hash only primitive and value type fields to avoid NullPointerException
156 @ForceInline
157 public long hashPrimitive() {
158 return s + sf + x + y + z + c + v1.hash() + v2.hash() + v3.hash();
159 }
160
161 @ForceInline
162 public long hash() {
163 return hashPrimitive() + o + oa[0];
164 }
165
166 @DontCompile
167 public long hashInterpreted() {
168 return s + sf + x + y + z + o + oa[0] + c + v1.hashInterpreted() + v2.hashInterpreted() + v3.hashInterpreted();
169 }
170
171 @ForceInline
172 public void print() {
173 System.out.print("s=" + s + ", sf=" + sf + ", x=" + x + ", y=" + y + ", z=" + z + ", o=" + (o != null ? (Integer)o : "NULL") + ", v1[");
174 v1.print();
175 System.out.print("], v2[");
176 v2.print();
177 System.out.print("], v3[");
178 v3.print();
179 System.out.print("], c=" + c);
180 }
181
182 @ForceInline
183 __ValueFactory static MyValue1 setX(MyValue1 v, int x) {
184 v.x = x;
185 return v;
186 }
187
188 @ForceInline
189 __ValueFactory static MyValue1 setY(MyValue1 v, long y) {
190 v.y = y;
191 return v;
192 }
193
194 @ForceInline
195 __ValueFactory static MyValue1 setZ(MyValue1 v, short z) {
196 v.z = z;
197 return v;
198 }
199
200 @ForceInline
201 __ValueFactory static MyValue1 setO(MyValue1 v, Integer o) {
202 v.o = o;
203 return v;
204 }
205
206 @ForceInline
207 __ValueFactory static MyValue1 setOA(MyValue1 v, int[] oa) {
208 v.oa = oa;
209 return v;
210 }
211
212 @ForceInline
213 __ValueFactory static MyValue1 setC(MyValue1 v, int c) {
214 v.c = c;
215 return v;
216 }
217
218 @ForceInline
219 __ValueFactory static MyValue1 setV1(MyValue1 v, MyValue2 v1) {
220 v.v1 = v1;
221 return v;
222 }
223
224 @ForceInline
225 __ValueFactory static MyValue1 setV2(MyValue1 v, MyValue2 v2) {
226 v.v2 = v2;
227 return v;
228 }
229 }
230
231 __ByValue final class MyValue2 {
232 final int x;
233 final byte y;
234 final boolean b;
235 final long c;
236
237 private MyValue2(int x, byte y, boolean b, long c) {
238 this.x = x;
239 this.y = y;
240 this.b = b;
241 this.c = c;
242 }
243
244 private MyValue2() {
245 this.x = 0;
246 this.y = 0;
247 this.b = false;
248 this.c = 0;
249 }
250
251 @ForceInline
252 __ValueFactory public static MyValue2 createDefaultInline() {
253 return __MakeDefault MyValue2();
254 }
255
256 @ForceInline
257 public static MyValue2 createWithFieldsInline(int x, boolean b) {
258 MyValue2 v = createDefaultInline();
259 v = setX(v, x);
260 v = setY(v, (byte)x);
261 v = setB(v, b);
262 v = setC(v, ValueTypeTestBench.rL);
263 return v;
264 }
265
266 @ForceInline
267 public long hash() {
268 return x + y + (b ? 0 : 1) + c;
269 }
270
271 @DontInline
272 public long hashInterpreted() {
273 return x + y + (b ? 0 : 1) + c;
274 }
275
276 @ForceInline
277 public void print() {
278 System.out.print("x=" + x + "y=" + y + ", b=" + b + ", c=" + c);
279 }
280
281 @ForceInline
282 __ValueFactory static MyValue2 setX(MyValue2 v, int x) {
283 v.x = x;
284 return v;
285 }
286
287 @ForceInline
288 __ValueFactory static MyValue2 setY(MyValue2 v, byte y) {
289 v.y = y;
290 return v;
291 }
292
293 @ForceInline
294 __ValueFactory static MyValue2 setC(MyValue2 v, long c) {
295 v.c = c;
296 return v;
297 }
298
299 @ForceInline
300 __ValueFactory static MyValue2 setB(MyValue2 v, boolean b) {
301 v.b = b;
302 return v;
303 }
304 }
305
306 // Value type definition to stress test return of a value in registers
307 // (uses all registers of calling convention on x86_64)
308 __ByValue final class MyValue3 {
309 final char c;
310 final byte bb;
311 final short s;
312 final int i;
313 final long l;
314 final Object o;
315 final float f1;
316 final double f2;
317 final float f3;
318 final double f4;
319 final float f5;
320 final double f6;
321 final float f7;
322 final double f8;
323
324 private MyValue3(char c,
325 byte bb,
326 short s,
327 int i,
328 long l,
329 Object o,
330 float f1,
331 double f2,
332 float f3,
333 double f4,
334 float f5,
335 double f6,
336 float f7,
337 double f8) {
338 this.c = c;
339 this.bb = bb;
340 this.s = s;
341 this.i = i;
342 this.l = l;
343 this.o = o;
344 this.f1 = f1;
345 this.f2 = f2;
346 this.f3 = f3;
347 this.f4 = f4;
348 this.f5 = f5;
349 this.f6 = f6;
350 this.f7 = f7;
351 this.f8 = f8;
352 }
353
354 private MyValue3() {
355 this.c = 0;
356 this.bb = 0;
357 this.s = 0;
358 this.i = 0;
359 this.l = 0;
360 this.o = null;
361 this.f1 = 0;
362 this.f2 = 0;
363 this.f3 = 0;
364 this.f4 = 0;
365 this.f5 = 0;
366 this.f6 = 0;
367 this.f7 = 0;
368 this.f8 = 0;
369 }
370
371 @ForceInline
372 __ValueFactory static MyValue3 setC(MyValue3 v, char c) {
373 v.c = c;
374 return v;
375 }
376
377 @ForceInline
378 __ValueFactory static MyValue3 setBB(MyValue3 v, byte bb) {
379 v.bb = bb;
380 return v;
381 }
382
383 @ForceInline
384 __ValueFactory static MyValue3 setS(MyValue3 v, short s) {
385 v.s = s;
386 return v;
387 }
388
389 @ForceInline
390 __ValueFactory static MyValue3 setI(MyValue3 v, int i) {
391 v.i = i;
392 return v;
393 }
394
395 @ForceInline
396 __ValueFactory static MyValue3 setL(MyValue3 v, long l) {
397 v.l = l;
398 return v;
399 }
400
401 @ForceInline
402 __ValueFactory static MyValue3 setO(MyValue3 v, Object o) {
403 v.o = o;
404 return v;
405 }
406
407 @ForceInline
408 __ValueFactory static MyValue3 setF1(MyValue3 v, float f1) {
409 v.f1 = f1;
410 return v;
411 }
412
413 @ForceInline
414 __ValueFactory static MyValue3 setF2(MyValue3 v, double f2) {
415 v.f2 = f2;
416 return v;
417 }
418
419 @ForceInline
420 __ValueFactory static MyValue3 setF3(MyValue3 v, float f3) {
421 v.f3 = f3;
422 return v;
423 }
424
425 @ForceInline
426 __ValueFactory static MyValue3 setF4(MyValue3 v, double f4) {
427 v.f4 = f4;
428 return v;
429 }
430
431 @ForceInline
432 __ValueFactory static MyValue3 setF5(MyValue3 v, float f5) {
433 v.f5 = f5;
434 return v;
435 }
436
437 @ForceInline
438 __ValueFactory static MyValue3 setF6(MyValue3 v, double f6) {
439 v.f6 = f6;
440 return v;
441 }
442
443 @ForceInline
444 __ValueFactory static MyValue3 setF7(MyValue3 v, float f7) {
445 v.f7 = f7;
446 return v;
447 }
448
449 @ForceInline
450 __ValueFactory static MyValue3 setF8(MyValue3 v, double f8) {
451 v.f8 = f8;
452 return v;
453 }
454
455 @ForceInline
456 __ValueFactory public static MyValue3 createDefault() {
457 return __MakeDefault MyValue3();
458 }
459
460 @ForceInline
461 public static MyValue3 create() {
462 java.util.Random r = Utils.getRandomInstance();
463 MyValue3 v = createDefault();
464 v = setC(v, (char)r.nextInt());
465 v = setBB(v, (byte)r.nextInt());
466 v = setS(v, (short)r.nextInt());
467 v = setI(v, r.nextInt());
468 v = setL(v, r.nextLong());
469 v = setO(v, new Object());
470 v = setF1(v, r.nextFloat());
471 v = setF2(v, r.nextDouble());
472 v = setF3(v, r.nextFloat());
473 v = setF4(v, r.nextDouble());
474 v = setF5(v, r.nextFloat());
475 v = setF6(v, r.nextDouble());
476 v = setF7(v, r.nextFloat());
477 v = setF8(v, r.nextDouble());
478 return v;
479 }
480
481 public void verify(MyValue3 other) {
482 Asserts.assertEQ(c, other.c);
483 Asserts.assertEQ(bb, other.bb);
484 Asserts.assertEQ(s, other.s);
485 Asserts.assertEQ(i, other.i);
486 Asserts.assertEQ(l, other.l);
487 Asserts.assertEQ(o, other.o);
488 Asserts.assertEQ(f1, other.f1);
489 Asserts.assertEQ(f2, other.f2);
490 Asserts.assertEQ(f3, other.f3);
491 Asserts.assertEQ(f4, other.f4);
492 Asserts.assertEQ(f5, other.f5);
493 Asserts.assertEQ(f6, other.f6);
494 Asserts.assertEQ(f7, other.f7);
495 Asserts.assertEQ(f8, other.f8);
496 }
497 }
498
499 // Value type definition with too many fields to return in registers
500 __ByValue final class MyValue4 {
501 final MyValue3 v1;
502 final MyValue3 v2;
503
504 private MyValue4(MyValue3 v1, MyValue3 v2) {
505 this.v1 = v1;
506 this.v2 = v2;
507 }
508
509 private MyValue4() {
510 this.v1 = MyValue3.createDefault();
511 this.v2 = MyValue3.createDefault();
512 }
513
514 @ForceInline
515 __ValueFactory static MyValue4 setV1(MyValue4 v, MyValue3 v1) {
516 v.v1 = v1;
517 return v;
518 }
519
520 @ForceInline
521 __ValueFactory static MyValue4 setV2(MyValue4 v, MyValue3 v2) {
522 v.v2 = v2;
523 return v;
524 }
525
526 @ForceInline
527 __ValueFactory public static MyValue4 createDefault() {
528 return __MakeDefault MyValue4();
529 }
530
531 @ForceInline
532 public static MyValue4 create() {
533 MyValue4 v = createDefault();
534 MyValue3 v1 = MyValue3.create();
535 v = setV1(v, v1);
536 MyValue3 v2 = MyValue3.create();
537 v = setV2(v, v2);
538 return v;
539 }
540
541 public void verify(MyValue4 other) {
542 v1.verify(other.v1);
543 v2.verify(other.v2);
544 }
545 }
546
547
548 public class ValueTypeTestBench {
549 // Print ideal graph after execution of each test
550 private static final boolean PRINT_GRAPH = true;
551
552 // Random test values
553 public static final int rI = Utils.getRandomInstance().nextInt() % 1000;
554 public static final long rL = Utils.getRandomInstance().nextLong() % 1000;
555
556 public ValueTypeTestBench() {
557 val3 = MyValue1.createWithFieldsInline(rI, rL);
558 }
559
560 // MethodHandles and value-capable class instance needed for testing vbox/vunbox
561 private static final MethodHandle vccUnboxLoadLongMH = generateVCCUnboxLoadLongMH();
562 private static final MethodHandle vccUnboxLoadIntMH = generateVCCUnboxLoadIntMH();
563 private static final MethodHandle vccUnboxBoxMH = generateVCCUnboxBoxMH();
564 private static final MethodHandle vccUnboxBoxLoadIntMH = generateVCCUnboxBoxLoadIntMH();
565 private static final MethodHandle nullvccUnboxLoadLongMH = generateNullVCCUnboxLoadLongMH();
566 private static final MethodHandle objectUnboxLoadLongMH = generateObjectUnboxLoadLongMH();
567 private static final MethodHandle objectBoxMH = generateObjectBoxMH();
568 private static final MethodHandle checkedvccUnboxLoadLongMH = generateCheckedVCCUnboxLoadLongMH();
569 private static final MethodHandle vastoreMH = generateVastore();
570 private static final MethodHandle invalidVastoreMH = generateInvalidVastore();
571
572 private static final ValueCapableClass1 vcc = ValueCapableClass1.create(rL, rI, (short)rI, (short)rI);
573 private static final ValueCapableClass2 vcc2 = ValueCapableClass2.create(rL + 1);
574
575 // ========== Helper methods ==========
576
577 public long hash() {
578 return hash(rI, rL);
579 }
580
581 public long hash(int x, long y) {
582 return MyValue1.createWithFieldsInline(x, y).hash();
583 }
584
585 // ========== Test definitions ==========
586
587 // Receive value type through call to interpreter
588 @Test(failOn = ALLOC + STORE + TRAP)
589 public long test1() {
590 MyValue1 v = MyValue1.createWithFieldsDontInline(rI, rL);
591 return v.hash();
592 }
593
594 @DontCompile
595 public void test1_verifier(boolean warmup) {
596 long result = test1();
597 Asserts.assertEQ(result, hash());
598 }
599
600 // Receive value type from interpreter via parameter
601 @Test(failOn = ALLOC + STORE + TRAP)
602 public long test2(MyValue1 v) {
603 return v.hash();
604 }
605
606 @DontCompile
607 public void test2_verifier(boolean warmup) {
608 MyValue1 v = MyValue1.createWithFieldsDontInline(rI, rL);
609 long result = test2(v);
610 Asserts.assertEQ(result, hash());
611 }
612
613 // Return incoming value type without accessing fields
614 @Test(valid = ValueTypePassFieldsAsArgsOn, match = {ALLOC, STORE}, matchCount = {1, 11}, failOn = LOAD + TRAP)
615 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = ALLOC + LOAD + STORE + TRAP)
616 public MyValue1 test3(MyValue1 v) {
617 return v;
618 }
619
620 @DontCompile
621 public void test3_verifier(boolean warmup) {
622 MyValue1 v1 = MyValue1.createWithFieldsDontInline(rI, rL);
623 MyValue1 v2 = test3(v1);
624 Asserts.assertEQ(v1.x, v2.x);
625 Asserts.assertEQ(v1.y, v2.y);
626 }
627
628 // Create a value type in compiled code and only use fields.
629 // Allocation should go away because value type does not escape.
630 @Test(failOn = ALLOC + LOAD + STORE + TRAP)
631 public long test4() {
632 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
633 return v.hash();
634 }
635
636 @DontCompile
637 public void test4_verifier(boolean warmup) {
638 long result = test4();
639 Asserts.assertEQ(result, hash());
640 }
641
642 // Create a value type in compiled code and pass it to
643 // an inlined compiled method via a call.
644 @Test(failOn = ALLOC + LOAD + STORE + TRAP)
645 public long test5() {
646 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
647 return test5Inline(v);
648 }
649
650 @ForceInline
651 public long test5Inline(MyValue1 v) {
652 return v.hash();
653 }
654
655 @DontCompile
656 public void test5_verifier(boolean warmup) {
657 long result = test5();
658 Asserts.assertEQ(result, hash());
659 }
660
661 // Create a value type in compiled code and pass it to
662 // the interpreter via a call.
663 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = LOAD + TRAP + ALLOC)
664 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
665 public long test6() {
666 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
667 // Pass to interpreter
668 return v.hashInterpreted();
669 }
670
671 @DontCompile
672 public void test6_verifier(boolean warmup) {
673 long result = test6();
674 Asserts.assertEQ(result, hash());
675 }
676
677 // Create a value type in compiled code and pass it to
678 // the interpreter by returning.
679 @Test(match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
680 public MyValue1 test7(int x, long y) {
681 return MyValue1.createWithFieldsInline(x, y);
682 }
683
684 @DontCompile
685 public void test7_verifier(boolean warmup) {
686 MyValue1 v = test7(rI, rL);
687 Asserts.assertEQ(v.hash(), hash());
688 }
689
690 // Merge value types created from two branches
691 @Test(failOn = ALLOC + STORE + TRAP)
692 public long test8(boolean b) {
693 MyValue1 v;
694 if (b) {
695 v = MyValue1.createWithFieldsInline(rI, rL);
696 } else {
697 v = MyValue1.createWithFieldsDontInline(rI + 1, rL + 1);
698 }
699 return v.hash();
700 }
701
702 @DontCompile
703 public void test8_verifier(boolean warmup) {
704 Asserts.assertEQ(test8(true), hash());
705 Asserts.assertEQ(test8(false), hash(rI + 1, rL + 1));
706 }
707
708 // Merge value types created from two branches
709 @Test(valid = ValueTypePassFieldsAsArgsOn, match = {LOAD}, matchCount = {10}, failOn = TRAP + ALLOC + STORE)
710 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC, STORE}, matchCount = {1, 3}, failOn = LOAD + TRAP)
711 public MyValue1 test9(boolean b) {
712 MyValue1 v;
713 if (b) {
714 // Value type is not allocated
715 v = MyValue1.createWithFieldsInline(rI, rL);
716 } else {
717 // Value type is allocated by the callee
718 v = MyValue1.createWithFieldsDontInline(rI + 1, rL + 1);
719 }
720 // Need to allocate value type if 'b' is true
721 long sum = v.hashInterpreted();
722 if (b) {
723 v = MyValue1.createWithFieldsDontInline(rI, sum);
724 } else {
725 v = MyValue1.createWithFieldsDontInline(rI, sum + 1);
726 }
727 // Don't need to allocate value type because both branches allocate
728 return v;
729 }
730
731 @DontCompile
732 public void test9_verifier(boolean warmup) {
733 MyValue1 v = test9(true);
734 Asserts.assertEQ(v.x, rI);
735 Asserts.assertEQ(v.y, hash());
736 v = test9(false);
737 Asserts.assertEQ(v.x, rI);
738 Asserts.assertEQ(v.y, hash(rI + 1, rL + 1) + 1);
739 }
740
741 // Merge value types created in a loop (not inlined)
742 @Test(failOn = ALLOC + STORE + TRAP)
743 public long test10(int x, long y) {
744 MyValue1 v = MyValue1.createWithFieldsDontInline(x, y);
745 for (int i = 0; i < 10; ++i) {
746 v = MyValue1.createWithFieldsDontInline(v.x + 1, v.y + 1);
747 }
748 return v.hash();
749 }
750
751 @DontCompile
752 public void test10_verifier(boolean warmup) {
753 long result = test10(rI, rL);
754 Asserts.assertEQ(result, hash(rI + 10, rL + 10));
755 }
756
757 // Merge value types created in a loop (inlined)
758 @Test(failOn = ALLOC + LOAD + STORE + TRAP)
759 public long test11(int x, long y) {
760 MyValue1 v = MyValue1.createWithFieldsInline(x, y);
761 for (int i = 0; i < 10; ++i) {
762 v = MyValue1.createWithFieldsInline(v.x + 1, v.y + 1);
763 }
764 return v.hash();
765 }
766
767 @DontCompile
768 public void test11_verifier(boolean warmup) {
769 long result = test11(rI, rL);
770 Asserts.assertEQ(result, hash(rI + 10, rL + 10));
771 }
772
773 // Test loop with uncommon trap referencing a value type
774 @Test(match = {SCOBJ}, matchCount = {-1 /* at least 1 */}, failOn = LOAD)
775 public long test12(boolean b) {
776 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
777 MyValue1[] va = new MyValue1[Math.abs(rI) % 10];
778 for (int i = 0; i < va.length; ++i) {
779 va[i] = MyValue1.createWithFieldsInline(rI, rL);
780 }
781 long result = rL;
782 for (int i = 0; i < 1000; ++i) {
783 if (b) {
784 result += v.x;
785 } else {
786 // Uncommon trap referencing v. We delegate allocation to the
787 // interpreter by adding a SafePointScalarObjectNode.
788 result = v.hashInterpreted();
789 for (int j = 0; j < va.length; ++j) {
790 result += va[j].hash();
791 }
792 }
793 }
794 return result;
795 }
796
797 @DontCompile
798 public void test12_verifier(boolean warmup) {
799 long result = test12(warmup);
800 Asserts.assertEQ(result, warmup ? rL + (1000 * rI) : ((Math.abs(rI) % 10) + 1) * hash());
801 }
802
803 // Test loop with uncommon trap referencing a value type
804 @Test
805 public long test13(boolean b) {
806 MyValue1 v = MyValue1.createWithFieldsDontInline(rI, rL);
807 MyValue1[] va = new MyValue1[Math.abs(rI) % 10];
808 for (int i = 0; i < va.length; ++i) {
809 va[i] = MyValue1.createWithFieldsDontInline(rI, rL);
810 }
811 long result = rL;
812 for (int i = 0; i < 1000; ++i) {
813 if (b) {
814 result += v.x;
815 } else {
816 // Uncommon trap referencing v. Should not allocate
817 // but just pass the existing oop to the uncommon trap.
818 result = v.hashInterpreted();
819 for (int j = 0; j < va.length; ++j) {
820 result += va[j].hashInterpreted();
821 }
822 }
823 }
824 return result;
825 }
826
827 @DontCompile
828 public void test13_verifier(boolean warmup) {
829 long result = test13(warmup);
830 Asserts.assertEQ(result, warmup ? rL + (1000 * rI) : ((Math.abs(rI) % 10) + 1) * hash());
831 }
832
833 // Create a value type in a non-inlined method and then call a
834 // non-inlined method on that value type.
835 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (ALLOC + STORE + TRAP), match = {LOAD}, matchCount = {10})
836 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = (ALLOC + LOAD + STORE + TRAP))
837 public long test14() {
838 MyValue1 v = MyValue1.createWithFieldsDontInline(rI, rL);
839 return v.hashInterpreted();
840 }
841
842 @DontCompile
843 public void test14_verifier(boolean b) {
844 long result = test14();
845 Asserts.assertEQ(result, hash());
846 }
847
848 // Create a value type in an inlined method and then call a
849 // non-inlined method on that value type.
850 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (LOAD + TRAP + ALLOC))
851 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = (LOAD + TRAP), match = {ALLOC}, matchCount = {1})
852 public long test15() {
853 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
854 return v.hashInterpreted();
855 }
856
857 @DontCompile
858 public void test15_verifier(boolean b) {
859 long result = test15();
860 Asserts.assertEQ(result, hash());
861 }
862
863 // Create a value type in a non-inlined method and then call an
864 // inlined method on that value type.
865 @Test(failOn = (ALLOC + STORE + TRAP))
866 public long test16() {
867 MyValue1 v = MyValue1.createWithFieldsDontInline(rI, rL);
868 return v.hash();
869 }
870
871 @DontCompile
872 public void test16_verifier(boolean b) {
873 long result = test16();
874 Asserts.assertEQ(result, hash());
875 }
876
877 // Create a value type in an inlined method and then call an
878 // inlined method on that value type.
879 @Test(failOn = (ALLOC + LOAD + STORE + TRAP))
880 public long test17() {
881 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
882 return v.hash();
883 }
884
885 @DontCompile
886 public void test17_verifier(boolean b) {
887 long result = test17();
888 Asserts.assertEQ(result, hash());
889 }
890
891 // Create a value type in compiled code and pass it to the
892 // interpreter via a call. The value is live at the first call so
893 // debug info should include a reference to all its fields.
894 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = ALLOC + LOAD + TRAP)
895 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
896 public long test18() {
897 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
898 v.hashInterpreted();
899 return v.hashInterpreted();
900 }
901
902 @DontCompile
903 public void test18_verifier(boolean warmup) {
904 long result = test18();
905 Asserts.assertEQ(result, hash());
906 }
907
908 // Create a value type in compiled code and pass it to the
909 // interpreter via a call. The value type is passed twice but
910 // should only be allocated once.
911 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = ALLOC + LOAD + TRAP)
912 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
913 public long test19() {
914 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
915 return sumValue(v, v);
916 }
917
918 @DontCompile
919 public long sumValue(MyValue1 v, MyValue1 dummy) {
920 return v.hash();
921 }
922
923 @DontCompile
924 public void test19_verifier(boolean warmup) {
925 long result = test19();
926 Asserts.assertEQ(result, hash());
927 }
928
929 // Create a value type (array) in compiled code and pass it to the
930 // interpreter via a call. The value type is live at the uncommon
931 // trap: verify that deoptimization causes the value type to be
932 // correctly allocated.
933 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = LOAD + ALLOC + STORE)
934 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {2}, failOn = LOAD)
935 public long test20(boolean deopt) {
936 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
937 MyValue2[] va = new MyValue2[3];
938 if (deopt) {
939 // uncommon trap
940 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test20"));
941 }
942 return v.hashInterpreted() + va[0].hashInterpreted() +
943 va[1].hashInterpreted() + va[2].hashInterpreted();
944 }
945
946 @DontCompile
947 public void test20_verifier(boolean warmup) {
948 MyValue2[] va = new MyValue2[42];
949 long result = test20(!warmup);
950 Asserts.assertEQ(result, hash() + va[0].hash() + va[1].hash() + va[2].hash());
951 }
952
953 // Value type fields in regular object
954 MyValue1 val1;
955 MyValue2 val2;
956 final MyValue1 val3;
957 static MyValue1 val4;
958 static final MyValue1 val5 = MyValue1.createWithFieldsInline(rI, rL);
959
960 // Test value type fields in objects
961 @Test(match = {ALLOC}, matchCount = {1}, failOn = (TRAP))
962 public long test21(int x, long y) {
963 // Compute hash of value type fields
964 long result = val1.hash() + val2.hash() + val3.hash() + val4.hash() + val5.hash();
965 // Update fields
966 val1 = MyValue1.createWithFieldsInline(x, y);
967 val2 = MyValue2.createWithFieldsInline(x, true);
968 val4 = MyValue1.createWithFieldsInline(x, y);
969 return result;
970 }
971
972 @DontCompile
973 public void test21_verifier(boolean warmup) {
974 // Check if hash computed by test18 is correct
975 val1 = MyValue1.createWithFieldsInline(rI, rL);
976 val2 = val1.v2;
977 // val3 is initialized in the constructor
978 val4 = val1;
979 // val5 is initialized in the static initializer
980 long hash = val1.hash() + val2.hash() + val3.hash() + val4.hash() + val5.hash();
981 long result = test21(rI + 1, rL + 1);
982 Asserts.assertEQ(result, hash);
983 // Check if value type fields were updated
984 Asserts.assertEQ(val1.hash(), hash(rI + 1, rL + 1));
985 Asserts.assertEQ(val2.hash(), MyValue2.createWithFieldsInline(rI + 1, true).hash());
986 Asserts.assertEQ(val4.hash(), hash(rI + 1, rL + 1));
987 }
988
989 // Test folding of constant value type fields
990 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
991 public long test22() {
992 // This should be constant folded
993 return val5.hash() + val5.v3.hash();
994 }
995
996 @DontCompile
997 public void test22_verifier(boolean warmup) {
998 long result = test22();
999 Asserts.assertEQ(result, val5.hash() + val5.v3.hash());
1000 }
1001
1002 // Test OSR compilation
1003 @Test()
1004 public long test23() {
1005 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
1006 MyValue1[] va = new MyValue1[Math.abs(rI) % 3];
1007 for (int i = 0; i < va.length; ++i) {
1008 va[i] = MyValue1.createWithFieldsInline(rI, rL);
1009 }
1010 long result = 0;
1011 // Long loop to trigger OSR compilation
1012 for (int i = 0 ; i < 100_000; ++i) {
1013 // Reference local value type in interpreter state
1014 result = v.hash();
1015 for (int j = 0; j < va.length; ++j) {
1016 result += va[j].hash();
1017 }
1018 }
1019 return result;
1020 }
1021
1022 @DontCompile
1023 public void test23_verifier(boolean warmup) {
1024 long result = test23();
1025 Asserts.assertEQ(result, ((Math.abs(rI) % 3) + 1) * hash());
1026 }
1027
1028 // Test interpreter to compiled code with various signatures
1029 @Test(failOn = ALLOC + STORE + TRAP)
1030 public long test24(MyValue2 v) {
1031 return v.hash();
1032 }
1033
1034 @DontCompile
1035 public void test24_verifier(boolean warmup) {
1036 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1037 long result = test24(v);
1038 Asserts.assertEQ(result, v.hashInterpreted());
1039 }
1040
1041 @Test(failOn = ALLOC + STORE + TRAP)
1042 public long test25(int i1, MyValue2 v, int i2) {
1043 return v.hash() + i1 - i2;
1044 }
1045
1046 @DontCompile
1047 public void test25_verifier(boolean warmup) {
1048 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1049 long result = test25(rI, v, 2*rI);
1050 Asserts.assertEQ(result, v.hashInterpreted() - rI);
1051 }
1052
1053 @Test(failOn = ALLOC + STORE + TRAP)
1054 public long test26(long l1, MyValue2 v, long l2) {
1055 return v.hash() + l1 - l2;
1056 }
1057
1058 @DontCompile
1059 public void test26_verifier(boolean warmup) {
1060 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1061 long result = test26(rL, v, 2*rL);
1062 Asserts.assertEQ(result, v.hashInterpreted() - rL);
1063 }
1064
1065 @Test(failOn = ALLOC + STORE + TRAP)
1066 public long test27(int i, MyValue2 v, long l) {
1067 return v.hash() + i + l;
1068 }
1069
1070 @DontCompile
1071 public void test27_verifier(boolean warmup) {
1072 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1073 long result = test27(rI, v, rL);
1074 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
1075 }
1076
1077 @Test(failOn = ALLOC + STORE + TRAP)
1078 public long test28(long l, MyValue2 v, int i) {
1079 return v.hash() + i + l;
1080 }
1081
1082 @DontCompile
1083 public void test28_verifier(boolean warmup) {
1084 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1085 long result = test28(rL, v, rI);
1086 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
1087 }
1088
1089 @Test(failOn = ALLOC + STORE + TRAP)
1090 public long test29(long l, MyValue1 v1, int i, MyValue2 v2) {
1091 return v1.hash() + i + l + v2.hash();
1092 }
1093
1094 @DontCompile
1095 public void test29_verifier(boolean warmup) {
1096 MyValue1 v1 = MyValue1.createWithFieldsDontInline(rI, rL);
1097 MyValue2 v2 = MyValue2.createWithFieldsInline(rI, true);
1098 long result = test29(rL, v1, rI, v2);
1099 Asserts.assertEQ(result, v1.hashInterpreted() + rL + rI + v2.hashInterpreted());
1100 }
1101
1102 // Test compiled code to interpreter with various signatures
1103 @DontCompile
1104 public long test30_interp(MyValue2 v) {
1105 return v.hash();
1106 }
1107
1108 @Test(failOn = ALLOC + STORE + TRAP)
1109 public long test30(MyValue2 v) {
1110 return test30_interp(v);
1111 }
1112
1113 @DontCompile
1114 public void test30_verifier(boolean warmup) {
1115 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1116 long result = test30(v);
1117 Asserts.assertEQ(result, v.hashInterpreted());
1118 }
1119
1120 @DontCompile
1121 public long test31_interp(int i1, MyValue2 v, int i2) {
1122 return v.hash() + i1 - i2;
1123 }
1124
1125 @Test(failOn = ALLOC + STORE + TRAP)
1126 public long test31(int i1, MyValue2 v, int i2) {
1127 return test31_interp(i1, v, i2);
1128 }
1129
1130 @DontCompile
1131 public void test31_verifier(boolean warmup) {
1132 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1133 long result = test31(rI, v, 2*rI);
1134 Asserts.assertEQ(result, v.hashInterpreted() - rI);
1135 }
1136
1137 @DontCompile
1138 public long test32_interp(long l1, MyValue2 v, long l2) {
1139 return v.hash() + l1 - l2;
1140 }
1141
1142 @Test(failOn = ALLOC + STORE + TRAP)
1143 public long test32(long l1, MyValue2 v, long l2) {
1144 return test32_interp(l1, v, l2);
1145 }
1146
1147 @DontCompile
1148 public void test32_verifier(boolean warmup) {
1149 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1150 long result = test32(rL, v, 2*rL);
1151 Asserts.assertEQ(result, v.hashInterpreted() - rL);
1152 }
1153
1154 @DontCompile
1155 public long test33_interp(int i, MyValue2 v, long l) {
1156 return v.hash() + i + l;
1157 }
1158
1159 @Test(failOn = ALLOC + STORE + TRAP)
1160 public long test33(int i, MyValue2 v, long l) {
1161 return test33_interp(i, v, l);
1162 }
1163
1164 @DontCompile
1165 public void test33_verifier(boolean warmup) {
1166 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1167 long result = test33(rI, v, rL);
1168 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
1169 }
1170
1171 @DontCompile
1172 public long test34_interp(long l, MyValue2 v, int i) {
1173 return v.hash() + i + l;
1174 }
1175
1176 @Test(failOn = ALLOC + STORE + TRAP)
1177 public long test34(long l, MyValue2 v, int i) {
1178 return test34_interp(l, v, i);
1179 }
1180
1181 @DontCompile
1182 public void test34_verifier(boolean warmup) {
1183 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1184 long result = test34(rL, v, rI);
1185 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
1186 }
1187
1188 @DontCompile
1189 public long test35_interp(long l, MyValue1 v1, int i, MyValue2 v2) {
1190 return v1.hash() + i + l + v2.hash();
1191 }
1192
1193 @Test(failOn = ALLOC + STORE + TRAP)
1194 public long test35(long l, MyValue1 v1, int i, MyValue2 v2) {
1195 return test35_interp(l, v1, i, v2);
1196 }
1197
1198 @DontCompile
1199 public void test35_verifier(boolean warmup) {
1200 MyValue1 v1 = MyValue1.createWithFieldsDontInline(rI, rL);
1201 MyValue2 v2 = MyValue2.createWithFieldsInline(rI, true);
1202 long result = test35(rL, v1, rI, v2);
1203 Asserts.assertEQ(result, v1.hashInterpreted() + rL + rI + v2.hashInterpreted());
1204 }
1205
1206 // test that debug info at a call is correct
1207 @DontCompile
1208 public long test36_interp(MyValue2 v, MyValue1[] va, boolean deopt) {
1209 if (deopt) {
1210 // uncommon trap
1211 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test36"));
1212 }
1213 return v.hash() + va[0].hash() + va[1].hash();
1214 }
1215
1216 @Test(failOn = ALLOC + STORE + TRAP)
1217 public long test36(MyValue2 v, MyValue1[] va, boolean flag, long l) {
1218 return test36_interp(v, va, flag) + l;
1219 }
1220
1221 @DontCompile
1222 public void test36_verifier(boolean warmup) {
1223 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1224 MyValue1[] va = new MyValue1[2];
1225 va[0] = MyValue1.createWithFieldsDontInline(rI, rL);
1226 va[1] = MyValue1.createWithFieldsDontInline(rI, rL);
1227 long result = test36(v, va, !warmup, rL);
1228 Asserts.assertEQ(result, v.hashInterpreted() + va[0].hash() + va[1].hash() + rL);
1229 }
1230
1231 // Test vbox and vunbox
1232 @Test
1233 public long test37() throws Throwable {
1234 return (long)vccUnboxLoadLongMH.invokeExact(vcc);
1235 }
1236
1237 @DontCompile
1238 public void test37_verifier(boolean warmup) {
1239 try {
1240 long result = test37();
1241 Asserts.assertEQ(vcc.t, result, "Field t of input and result must be equal.");
1242 } catch (Throwable t) {
1243 throw new RuntimeException("test 37 failed", t);
1244 }
1245 }
1246
1247 // Generate a MethodHandle that obtains field t of the
1248 // derived value type
1249 private static MethodHandle generateVCCUnboxLoadLongMH() {
1250 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1251 "vccUnboxLoadLong",
1252 MethodType.methodType(long.class, ValueCapableClass1.class),
1253 CODE -> {
1254 CODE.
1255 aload_0().
1256 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1257 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
1258 lreturn();
1259 }
1260 );
1261 }
1262
1263 @Test
1264 public int test38() throws Throwable {
1265 return (int)vccUnboxLoadIntMH.invokeExact(vcc);
1266 }
1267
1268 @DontCompile
1269 public void test38_verifier(boolean warmup) {
1270 try {
1271 int result = test38();
1272 Asserts.assertEQ(vcc.x, result, "Field x of input and result must be equal.");
1273 } catch (Throwable t) {
1274 throw new RuntimeException("test 38 failed", t);
1275 }
1276 }
1277
1278 // Generate a MethodHandle that obtains field x of the
1279 // derived value type
1280 private static MethodHandle generateVCCUnboxLoadIntMH() {
1281 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1282 "vccUnboxLoadInt",
1283 MethodType.methodType(int.class, ValueCapableClass1.class),
1284 CODE -> {
1285 CODE.
1286 aload_0().
1287 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1288 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "x", "I").
1289 ireturn();
1290 }
1291 );
1292 }
1293
1294 @Test
1295 public ValueCapableClass1 test39() throws Throwable {
1296 return (ValueCapableClass1)vccUnboxBoxMH.invokeExact(vcc);
1297 }
1298
1299 @DontCompile
1300 public void test39_verifier(boolean warmup) {
1301 try {
1302 ValueCapableClass1 result = test39();
1303 Asserts.assertEQ(vcc.value(), result.value(), "Value of VCC and returned VCC must be equal");
1304 } catch (Throwable t) {
1305 throw new RuntimeException("test 39 failed", t);
1306 }
1307 }
1308
1309 // Generate a MethodHandle that takes a value-capable class,
1310 // unboxes it, then boxes it again and returns it.
1311 private static MethodHandle generateVCCUnboxBoxMH() {
1312 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1313 "vccUnboxBox",
1314 MethodType.methodType(ValueCapableClass1.class, ValueCapableClass1.class),
1315 CODE -> {
1316 CODE.
1317 aload_0().
1318 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1319 vbox(ValueCapableClass1.class).
1320 areturn();
1321 }
1322 );
1323 }
1324
1325 @Test
1326 public int test40() throws Throwable {
1327 return (int)vccUnboxBoxLoadIntMH.invokeExact(vcc);
1328 }
1329
1330 @DontCompile
1331 public void test40_verifier(boolean warmup) {
1332 try {
1333 int result = test40();
1334 Asserts.assertEQ(vcc.x, result, "Field x of VCC and result must be equal");
1335 } catch (Throwable t) {
1336 throw new RuntimeException("Test failed in the interpeter", t);
1337 }
1338 }
1339
1340 // Generate a MethodHandle that takes a value-capable class,
1341 // unboxes it, boxes it, reads a field from it, and returns the
1342 // field.
1343 private static MethodHandle generateVCCUnboxBoxLoadIntMH() {
1344 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1345 "vccUnboxBoxLoadInt",
1346 MethodType.methodType(int.class, ValueCapableClass1.class),
1347 CODE -> {
1348 CODE.
1349 aload_0().
1350 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1351 vbox(ValueCapableClass1.class).
1352 getfield(ValueCapableClass1.class, "x", "I").
1353 ireturn();
1354 }
1355 );
1356
1357 }
1358
1359 // Test value type array creation and initialization
1360 @Test(valid = ValueTypeArrayFlattenOff, failOn = (LOAD))
1361 @Test(valid = ValueTypeArrayFlattenOn)
1362 public MyValue1[] test41(int len) {
1363 MyValue1[] va = new MyValue1[len];
1364 for (int i = 0; i < len; ++i) {
1365 va[i] = MyValue1.createWithFieldsDontInline(rI, rL);
1366 }
1367 return va;
1368 }
1369
1370 @DontCompile
1371 public void test41_verifier(boolean warmup) {
1372 int len = Math.abs(rI % 10);
1373 MyValue1[] va = test41(len);
1374 for (int i = 0; i < len; ++i) {
1375 Asserts.assertEQ(va[i].hash(), hash());
1376 }
1377 }
1378
1379 // Test creation of a value type array and element access
1380 @Test(valid = ValueTypeArrayFlattenOff, failOn = (LOOP + TRAP))
1381 @Test(valid = ValueTypeArrayFlattenOn, failOn = (ALLOC + ALLOCA + LOOP + LOAD + LOADP + STORE + TRAP))
1382 public long test42() {
1383 MyValue1[] va = new MyValue1[1];
1384 va[0] = MyValue1.createWithFieldsInline(rI, rL);
1385 return va[0].hash();
1386 }
1387
1388 @DontCompile
1389 public void test42_verifier(boolean warmup) {
1390 long result = test42();
1391 Asserts.assertEQ(result, hash());
1392 }
1393
1394 // Test receiving a value type array from the interpreter,
1395 // updating its elements in a loop and computing a hash.
1396 @Test(failOn = (ALLOCA))
1397 public long test43(MyValue1[] va) {
1398 long result = 0;
1399 for (int i = 0; i < 10; ++i) {
1400 result += va[i].hash();
1401 va[i] = MyValue1.createWithFieldsInline(rI + 1, rL + 1);
1402 }
1403 return result;
1404 }
1405
1406 @DontCompile
1407 public void test43_verifier(boolean warmup) {
1408 MyValue1[] va = new MyValue1[10];
1409 long expected = 0;
1410 for (int i = 0; i < 10; ++i) {
1411 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL + i);
1412 expected += va[i].hash();
1413 }
1414 long result = test43(va);
1415 Asserts.assertEQ(expected, result);
1416 for (int i = 0; i < 10; ++i) {
1417 if (va[i].hash() != hash(rI + 1, rL + 1)) {
1418 Asserts.assertEQ(va[i].hash(), hash(rI + 1, rL + 1));
1419 }
1420 }
1421 }
1422
1423 // Test returning a value type array received from the interpreter
1424 @Test(failOn = ALLOC + ALLOCA + LOAD + LOADP + STORE + LOOP + TRAP)
1425 public MyValue1[] test44(MyValue1[] va) {
1426 return va;
1427 }
1428
1429 @DontCompile
1430 public void test44_verifier(boolean warmup) {
1431 MyValue1[] va = new MyValue1[10];
1432 for (int i = 0; i < 10; ++i) {
1433 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL + i);
1434 }
1435 va = test44(va);
1436 for (int i = 0; i < 10; ++i) {
1437 Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i));
1438 }
1439 }
1440
1441 // Merge value type arrays created from two branches
1442 @Test
1443 public MyValue1[] test45(boolean b) {
1444 MyValue1[] va;
1445 if (b) {
1446 va = new MyValue1[5];
1447 for (int i = 0; i < 5; ++i) {
1448 va[i] = MyValue1.createWithFieldsInline(rI, rL);
1449 }
1450 } else {
1451 va = new MyValue1[10];
1452 for (int i = 0; i < 10; ++i) {
1453 va[i] = MyValue1.createWithFieldsInline(rI + i, rL + i);
1454 }
1455 }
1456 long sum = va[0].hashInterpreted();
1457 if (b) {
1458 va[0] = MyValue1.createWithFieldsDontInline(rI, sum);
1459 } else {
1460 va[0] = MyValue1.createWithFieldsDontInline(rI + 1, sum + 1);
1461 }
1462 return va;
1463 }
1464
1465 @DontCompile
1466 public void test45_verifier(boolean warmup) {
1467 MyValue1[] va = test45(true);
1468 Asserts.assertEQ(va.length, 5);
1469 Asserts.assertEQ(va[0].hash(), hash(rI, hash()));
1470 for (int i = 1; i < 5; ++i) {
1471 Asserts.assertEQ(va[i].hash(), hash());
1472 }
1473 va = test45(false);
1474 Asserts.assertEQ(va.length, 10);
1475 Asserts.assertEQ(va[0].hash(), hash(rI + 1, hash(rI, rL) + 1));
1476 for (int i = 1; i < 10; ++i) {
1477 Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i));
1478 }
1479 }
1480
1481 // Test creation of value type array with single element
1482 @Test(valid = ValueTypeArrayFlattenOff, failOn = (LOAD + LOOP + TRAP))
1483 @Test(valid = ValueTypeArrayFlattenOn, failOn = (ALLOCA + LOAD + LOOP + TRAP))
1484 public MyValue1 test46() {
1485 MyValue1[] va = new MyValue1[1];
1486 return va[0];
1487 }
1488
1489 @DontCompile
1490 public void test46_verifier(boolean warmup) {
1491 MyValue1[] va = new MyValue1[1];
1492 MyValue1 v = test46();
1493 Asserts.assertEQ(v.hashPrimitive(), va[0].hashPrimitive());
1494 }
1495
1496 // Test default initialization of value type arrays
1497 @Test(failOn = LOAD)
1498 public MyValue1[] test47(int len) {
1499 return new MyValue1[len];
1500 }
1501
1502 @DontCompile
1503 public void test47_verifier(boolean warmup) {
1504 int len = Math.abs(rI % 10);
1505 MyValue1[] va = new MyValue1[len];
1506 MyValue1[] var = test47(len);
1507 for (int i = 0; i < len; ++i) {
1508 Asserts.assertEQ(va[i].hashPrimitive(), var[i].hashPrimitive());
1509 }
1510 }
1511
1512 // Test creation of value type array with zero length
1513 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
1514 public MyValue1[] test48() {
1515 return new MyValue1[0];
1516 }
1517
1518 @DontCompile
1519 public void test48_verifier(boolean warmup) {
1520 MyValue1[] va = test48();
1521 Asserts.assertEQ(va.length, 0);
1522 }
1523
1524 static MyValue1[] test49_va;
1525
1526 // Test that value type array loaded from field has correct type
1527 @Test(failOn = (LOOP))
1528 public long test49() {
1529 return test49_va[0].hash();
1530 }
1531
1532 @DontCompile
1533 public void test49_verifier(boolean warmup) {
1534 test49_va = new MyValue1[1];
1535 test49_va[0] = MyValue1.createWithFieldsInline(rI, rL);
1536 long result = test49();
1537 Asserts.assertEQ(result, hash());
1538 }
1539
1540 // test vdefault
1541 @Test(failOn = ALLOC + LOAD + LOADP + STORE + LOOP + TRAP)
1542 public long test50() {
1543 MyValue2 v = MyValue2.createDefaultInline();
1544 return v.hash();
1545 }
1546
1547 @DontCompile
1548 public void test50_verifier(boolean warmup) {
1549 long result = test50();
1550 Asserts.assertEQ(result, MyValue2.createDefaultInline().hash());
1551 }
1552
1553 // test vdefault
1554 @Test(failOn = ALLOC + STORE + LOOP + TRAP)
1555 public long test51() {
1556 MyValue1 v1 = MyValue1.createDefaultInline();
1557 MyValue1 v2 = MyValue1.createDefaultDontInline();
1558 return v1.hashPrimitive() + v2.hashPrimitive();
1559 }
1560
1561 @DontCompile
1562 public void test51_verifier(boolean warmup) {
1563 long result = test51();
1564 Asserts.assertEQ(result, 2 * MyValue1.createDefaultInline().hashPrimitive());
1565 }
1566
1567 // test vwithfield
1568 @Test(failOn = ALLOC + LOAD + LOADP + STORE + LOOP + TRAP)
1569 public long test52() {
1570 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1571 return v.hash();
1572 }
1573
1574 @DontCompile
1575 public void test52_verifier(boolean warmup) {
1576 long result = test52();
1577 Asserts.assertEQ(result, MyValue2.createWithFieldsInline(rI, true).hash());
1578 }
1579
1580 // test vwithfield
1581 @Test(failOn = ALLOC + STORE + LOOP + TRAP)
1582 public long test53() {
1583 MyValue1 v1 = MyValue1.createWithFieldsInline(rI, rL);
1584 MyValue1 v2 = MyValue1.createWithFieldsDontInline(rI, rL);
1585 return v1.hash() + v2.hash();
1586 }
1587
1588 @DontCompile
1589 public void test53_verifier(boolean warmup) {
1590 long result = test53();
1591 Asserts.assertEQ(result, 2 * hash());
1592 }
1593
1594 // multi-dimensional arrays
1595 @Test
1596 public MyValue1[][][] test54(int len1, int len2, int len3) {
1597 MyValue1[][][] arr = new MyValue1[len1][len2][len3];
1598 for (int i = 0; i < len1; i++) {
1599 for (int j = 0; j < len2; j++) {
1600 for (int k = 0; k < len3; k++) {
1601 arr[i][j][k] = MyValue1.createWithFieldsDontInline(rI + i , rL + j + k);
1602 }
1603 }
1604 }
1605 return arr;
1606 }
1607
1608 @DontCompile
1609 public void test54_verifier(boolean warmup) {
1610 MyValue1[][][] arr = test54(2, 3, 4);
1611 for (int i = 0; i < 2; i++) {
1612 for (int j = 0; j < 3; j++) {
1613 for (int k = 0; k < 4; k++) {
1614 Asserts.assertEQ(arr[i][j][k].hash(), MyValue1.createWithFieldsDontInline(rI + i , rL + j + k).hash());
1615 }
1616 }
1617 }
1618 }
1619
1620 @Test
1621 public void test55(MyValue1[][][] arr, long[] res) {
1622 int l = 0;
1623 for (int i = 0; i < arr.length; i++) {
1624 for (int j = 0; j < arr[i].length; j++) {
1625 for (int k = 0; k < arr[i][j].length; k++) {
1626 res[l] = arr[i][j][k].hash();
1627 l++;
1628 }
1629 }
1630 }
1631 }
1632
1633 @DontCompile
1634 public void test55_verifier(boolean warmup) {
1635 MyValue1[][][] arr = new MyValue1[2][3][4];
1636 long[] res = new long[2*3*4];
1637 long[] verif = new long[2*3*4];
1638 int l = 0;
1639 for (int i = 0; i < 2; i++) {
1640 for (int j = 0; j < 3; j++) {
1641 for (int k = 0; k < 4; k++) {
1642 arr[i][j][k] = MyValue1.createWithFieldsDontInline(rI + i, rL + j + k);
1643 verif[l] = arr[i][j][k].hash();
1644 l++;
1645 }
1646 }
1647 }
1648 test55(arr, res);
1649 for (int i = 0; i < verif.length; i++) {
1650 Asserts.assertEQ(res[i], verif[i]);
1651 }
1652 }
1653
1654 class TestClass56 {
1655 public MyValue1 v;
1656 }
1657
1658 // Test allocation elimination of unused object with initialized value type field
1659 @Test(failOn = ALLOC + LOAD + STORE + LOOP)
1660 public void test56(boolean deopt) {
1661 TestClass56 unused = new TestClass56();
1662 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
1663 unused.v = v;
1664 if (deopt) {
1665 // uncommon trap
1666 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test56"));
1667 }
1668 }
1669
1670 @DontCompile
1671 public void test56_verifier(boolean warmup) {
1672 test56(!warmup);
1673 }
1674
1675 // Test loop peeling
1676 @Test(failOn = ALLOC + LOAD + STORE)
1677 public void test57() {
1678 MyValue1 v = MyValue1.createWithFieldsInline(0, 1);
1679 // Trigger OSR compilation and loop peeling
1680 for (int i = 0; i < 100_000; ++i) {
1681 if (v.x != i || v.y != i + 1) {
1682 // Uncommon trap
1683 throw new RuntimeException("test57 failed");
1684 }
1685 v = MyValue1.createWithFieldsInline(i + 1, i + 2);
1686 }
1687 }
1688
1689 @DontCompile
1690 public void test57_verifier(boolean warmup) {
1691 test57();
1692 }
1693
1694 // Test loop peeling and unrolling
1695 @Test()
1696 public void test58() {
1697 MyValue1 v1 = MyValue1.createWithFieldsInline(0, 0);
1698 MyValue1 v2 = MyValue1.createWithFieldsInline(1, 1);
1699 // Trigger OSR compilation and loop peeling
1700 for (int i = 0; i < 100_000; ++i) {
1701 if (v1.x != 2*i || v2.x != i+1 || v2.y != i+1) {
1702 // Uncommon trap
1703 throw new RuntimeException("test58 failed");
1704 }
1705 v1 = MyValue1.createWithFieldsInline(2*(i+1), 0);
1706 v2 = MyValue1.createWithFieldsInline(i+2, i+2);
1707 }
1708 }
1709
1710 @DontCompile
1711 public void test58_verifier(boolean warmup) {
1712 test58();
1713 }
1714
1715 // When calling a method on __Value, passing fields as arguments is impossible
1716 @Test(failOn = ALLOC + STORE + LOAD)
1717 public String test59(MyValue1 v) {
1718 return v.toString();
1719 }
1720
1721 @DontCompile
1722 public void test59_verifier(boolean warmup) {
1723 boolean failed = false;
1724 try {
1725 test59(val1);
1726 failed = true;
1727 } catch (UnsupportedOperationException uoe) {
1728 }
1729 Asserts.assertFalse(failed);
1730 }
1731
1732 // Same as above, but the method on __Value is inlined
1733 // hashCode allocates an exception so can't really check the graph shape
1734 @Test()
1735 public int test60(MyValue1 v) {
1736 return v.hashCode();
1737 }
1738
1739 @DontCompile
1740 public void test60_verifier(boolean warmup) {
1741 boolean failed = false;
1742 try {
1743 test60(val1);
1744 failed = true;
1745 } catch (UnsupportedOperationException uoe) {
1746 }
1747 Asserts.assertFalse(failed);
1748 }
1749
1750 /* The compiler is supposed to determine that the value to be
1751 * unboxed in nullcvvUnboxLoadLong is always null. Therefore, the
1752 * compiler generates only the path leading to the corresponding
1753 * uncommon trap. */
1754 @Test(failOn = RETURN)
1755 public long test61() throws Throwable {
1756 return (long)nullvccUnboxLoadLongMH.invokeExact();
1757 }
1758
1759 @DontCompile
1760 public void test61_verifier(boolean warmup) throws Throwable {
1761 try {
1762 long result = test61();
1763 throw new RuntimeException("Test failed because no exception was thrown");
1764 } catch (NullPointerException e) {
1765 }
1766 }
1767
1768 public static MethodHandle generateNullVCCUnboxLoadLongMH() {
1769 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1770 "nullvccUnboxLoadLong",
1771 MethodType.methodType(long.class),
1772 CODE -> {
1773 CODE.
1774 aconst_null().
1775 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1776 vgetfield(ValueCapableClass1.class, "t", "J").
1777 lreturn();
1778 }
1779 );
1780 }
1781
1782 /* The compiler is supposed to determine that the allocated
1783 * ValueCapableClass1 instance is never null (and therefore not
1784 * generate a null check). Also, the source and target type match
1785 * (known at compile time), so no type check is needed either.*/
1786 @Test(failOn = NPE)
1787 public long test62() throws Throwable {
1788 return (long)checkedvccUnboxLoadLongMH.invokeExact();
1789 }
1790
1791 @DontCompile
1792 public void test62_verifier(boolean warmup) throws Throwable {
1793 long result = test62();
1794 Asserts.assertEQ(result, 17L);
1795 }
1796
1797 public static MethodHandle generateCheckedVCCUnboxLoadLongMH() {
1798 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1799 "checkedVCCUnboxLoadLongMH",
1800 MethodType.methodType(long.class),
1801 CODE -> {
1802 CODE.
1803 invokestatic(ValueCapableClass1.class, "createInline", "()Lcompiler/valhalla/valuetypes/ValueCapableClass1;", false).
1804 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1805 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
1806 lreturn();
1807 }
1808 );
1809 }
1810
1811 /* The compiler is supposed to emit a runtime null check because
1812 * it does not have enough information to determine that the value
1813 * to be unboxed is not null (and either that it is null). The
1814 * declared type of the */
1815 @Test(match = {NPE}, matchCount = {1})
1816 public long test63(ValueCapableClass1 vcc) throws Throwable {
1817 return (long)vccUnboxLoadLongMH.invokeExact(vcc);
1818 }
1819
1820 @DontCompile
1821 public void test63_verifier(boolean warmup) throws Throwable {
1822 try {
1823 long result = test63(null);
1824 throw new RuntimeException("Test failed because no exception was thrown");
1825 } catch (NullPointerException e) {
1826 }
1827 }
1828
1829 /* Attempt to unbox an object that is not a subclass of the
1830 * value-capable class derived from the value type specified in
1831 * the vunbox bytecode. */
1832 @Test(match = {NPE,CCE}, matchCount = {1,1})
1833 public long test64(Object vcc) throws Throwable {
1834 return (long)objectUnboxLoadLongMH.invokeExact(vcc);
1835 }
1836
1837 @DontCompile
1838 public void test64_verifier(boolean warmup) throws Throwable {
1839 try {
1840 long result = test64(new Object());
1841 throw new RuntimeException("Test failed because no exception was thrown");
1842 } catch (ClassCastException e) {
1843 }
1844
1845 try {
1846 long result = test64(vcc2);
1847 throw new RuntimeException("Test failed because no exception was thrown");
1848 } catch (ClassCastException e) {
1849 }
1850
1851 Asserts.assertEQ(test64(vcc), rL);
1852 }
1853
1854 private static MethodHandle generateObjectUnboxLoadLongMH() {
1855 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1856 "ObjectUnboxLoadLong",
1857 MethodType.methodType(long.class, Object.class),
1858 CODE -> {
1859 CODE.
1860 aload_0().
1861 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1862 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
1863 lreturn();
1864 }
1865 );
1866 }
1867
1868 /* Generate an if-then-else construct with one path that contains
1869 * an invalid boxing operation (boxing of a value-type to a
1870 * non-matching value-capable class).*/
1871 @Test(match = {NPE, CCE}, matchCount = {2, 2})
1872 public long test65(Object obj, boolean warmup) throws Throwable {
1873 return (long)objectBoxMH.invokeExact(obj, warmup);
1874 }
1875
1876 @DontCompile
1877 public void test65_verifier(boolean warmup) throws Throwable {
1878 try {
1879 long result = test65(vcc2, true);
1880 throw new RuntimeException("Test failed because no exception was thrown");
1881 } catch (ClassCastException e) {
1882 }
1883
1884 Asserts.assertEQ(test65(vcc, true), rL);
1885
1886 try {
1887 long result = test65(vcc2, false);
1888 throw new RuntimeException("Test failed because no exception was thrown");
1889 } catch (ClassCastException e) {
1890 }
1891
1892 try {
1893 long result = test65(vcc, false);
1894 throw new RuntimeException("Test failed because no exception was thrown");
1895 } catch (ClassCastException e) {
1896 }
1897 }
1898
1899 private static MethodHandle generateObjectBoxMH() {
1900 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
1901 "ObjectBox",
1902 MethodType.methodType(long.class, Object.class, boolean.class),
1903 CODE -> {
1904 CODE.
1905 iload_1().
1906 iconst_1().
1907 if_icmpne((short)14).
1908 aload_0().
1909 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
1910 vbox(ValueCapableClass1.class).
1911 getfield(ValueCapableClass1.class, "t", "J").
1912 lreturn().
1913 aload_0().
1914 vunbox(ValueType.forClass(ValueCapableClass2.class).valueClass()).
1915 vbox(ValueCapableClass1.class).
1916 getfield(ValueCapableClass1.class, "t", "J").
1917 lreturn();
1918 }
1919 );
1920 }
1921
1922 // Test deoptimization at call return with return value in registers
1923 @DontCompile
1924 public MyValue2 test66_interp(boolean deopt) {
1925 if (deopt) {
1926 // uncommon trap
1927 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test66"));
1928 }
1929 return MyValue2.createWithFieldsInline(rI, true);
1930 }
1931
1932 @Test()
1933 public MyValue2 test66(boolean flag) {
1934 return test66_interp(flag);
1935 }
1936
1937 @DontCompile
1938 public void test66_verifier(boolean warmup) {
1939 MyValue2 result = test66(!warmup);
1940 MyValue2 v = MyValue2.createWithFieldsInline(rI, true);
1941 Asserts.assertEQ(result.hash(), v.hash());
1942 }
1943
1944 // Return value types in registers from interpreter -> compiled
1945 final MyValue3 test67_vt = MyValue3.create();
1946 @DontCompile
1947 public MyValue3 test67_interp() {
1948 return test67_vt;
1949 }
1950
1951 MyValue3 test67_vt2;
1952 @Test(valid = ValueTypeReturnedAsFieldsOn, failOn = ALLOC + LOAD + TRAP)
1953 @Test(valid = ValueTypeReturnedAsFieldsOff)
1954 public void test67() {
1955 test67_vt2 = test67_interp();
1956 }
1957
1958 @DontCompile
1959 public void test67_verifier(boolean warmup) {
1960 test67();
1961 test67_vt.verify(test67_vt2);
1962 }
1963
1964 // Return value types in registers from compiled -> interpreter
1965 final MyValue3 test68_vt = MyValue3.create();
1966 @Test(valid = ValueTypeReturnedAsFieldsOn, failOn = ALLOC + STORE + TRAP)
1967 @Test(valid = ValueTypeReturnedAsFieldsOff)
1968 public MyValue3 test68() {
1969 return test68_vt;
1970 }
1971
1972 @DontCompile
1973 public void test68_verifier(boolean warmup) {
1974 MyValue3 vt = test68();
1975 test68_vt.verify(vt);
1976 }
1977
1978 // Return value types in registers from compiled -> compiled
1979 final MyValue3 test69_vt = MyValue3.create();
1980 @DontInline
1981 public MyValue3 test69_comp() {
1982 return test69_vt;
1983 }
1984
1985 MyValue3 test69_vt2;
1986 @Test(valid = ValueTypeReturnedAsFieldsOn, failOn = ALLOC + LOAD + TRAP)
1987 @Test(valid = ValueTypeReturnedAsFieldsOff)
1988 public void test69() {
1989 test69_vt2 = test69_comp();
1990 }
1991
1992 @DontCompile
1993 public void test69_verifier(boolean warmup) throws Exception {
1994 Method helper_m = getClass().getDeclaredMethod("test69_comp");
1995 if (!warmup && USE_COMPILER && !WHITE_BOX.isMethodCompiled(helper_m, false)) {
1996 WHITE_BOX.enqueueMethodForCompilation(helper_m, COMP_LEVEL_FULL_OPTIMIZATION);
1997 Asserts.assertTrue(WHITE_BOX.isMethodCompiled(helper_m, false), "test69_comp not compiled");
1998 }
1999 test69();
2000 test69_vt.verify(test69_vt2);
2001 }
2002
2003 // Same tests as above but with a value type that cannot be returned in registers
2004
2005 // Return value types in registers from interpreter -> compiled
2006 final MyValue4 test70_vt = MyValue4.create();
2007 @DontCompile
2008 public MyValue4 test70_interp() {
2009 return test70_vt;
2010 }
2011
2012 MyValue4 test70_vt2;
2013 @Test
2014 public void test70() {
2015 test70_vt2 = test70_interp();
2016 }
2017
2018 @DontCompile
2019 public void test70_verifier(boolean warmup) {
2020 test70();
2021 test70_vt.verify(test70_vt2);
2022 }
2023
2024 // Return value types in registers from compiled -> interpreter
2025 final MyValue4 test71_vt = MyValue4.create();
2026 @Test
2027 public MyValue4 test71() {
2028 return test71_vt;
2029 }
2030
2031 @DontCompile
2032 public void test71_verifier(boolean warmup) {
2033 MyValue4 vt = test71();
2034 test71_vt.verify(vt);
2035 }
2036
2037 // Return value types in registers from compiled -> compiled
2038 final MyValue4 test72_vt = MyValue4.create();
2039 @DontInline
2040 public MyValue4 test72_comp() {
2041 return test72_vt;
2042 }
2043
2044 MyValue4 test72_vt2;
2045 @Test
2046 public void test72() {
2047 test72_vt2 = test72_comp();
2048 }
2049
2050 @DontCompile
2051 public void test72_verifier(boolean warmup) throws Exception {
2052 Method helper_m = getClass().getDeclaredMethod("test72_comp");
2053 if (!warmup && USE_COMPILER && !WHITE_BOX.isMethodCompiled(helper_m, false)) {
2054 WHITE_BOX.enqueueMethodForCompilation(helper_m, COMP_LEVEL_FULL_OPTIMIZATION);
2055 Asserts.assertTrue(WHITE_BOX.isMethodCompiled(helper_m, false), "test72_comp not compiled");
2056 }
2057 test72();
2058 test72_vt.verify(test72_vt2);
2059 }
2060
2061 // Return values and method handles tests
2062
2063 // Everything inlined
2064 final MyValue3 test73_vt = MyValue3.create();
2065 @ForceInline
2066 MyValue3 test73_target() {
2067 return test73_vt;
2068 }
2069
2070 static final MethodHandle test73_mh;
2071
2072 @Test(valid = ValueTypeReturnedAsFieldsOn, failOn = ALLOC + STORE + CALL)
2073 @Test(valid = ValueTypeReturnedAsFieldsOff, match = { ALLOC, STORE }, matchCount = { 1, 11 })
2074 MyValue3 test73() throws Throwable {
2075 return (MyValue3)test73_mh.invokeExact(this);
2076 }
2077
2078 @DontCompile
2079 public void test73_verifier(boolean warmup) throws Throwable {
2080 MyValue3 vt = test73();
2081 test73_vt.verify(vt);
2082 }
2083
2084 // Leaf method not inlined but returned type is known
2085 final MyValue3 test74_vt = MyValue3.create();
2086 @DontInline
2087 MyValue3 test74_target() {
2088 return test74_vt;
2089 }
2090
2091 static final MethodHandle test74_mh;
2092
2093 @Test
2094 MyValue3 test74() throws Throwable {
2095 return (MyValue3)test74_mh.invokeExact(this);
2096 }
2097
2098 @DontCompile
2099 public void test74_verifier(boolean warmup) throws Throwable {
2100 Method helper_m = getClass().getDeclaredMethod("test74_target");
2101 if (!warmup && USE_COMPILER && !WHITE_BOX.isMethodCompiled(helper_m, false)) {
2102 WHITE_BOX.enqueueMethodForCompilation(helper_m, COMP_LEVEL_FULL_OPTIMIZATION);
2103 Asserts.assertTrue(WHITE_BOX.isMethodCompiled(helper_m, false), "test74_target not compiled");
2104 }
2105 MyValue3 vt = test74();
2106 test74_vt.verify(vt);
2107 }
2108
2109 // Leaf method not inlined and returned type not known
2110 final MyValue3 test75_vt = MyValue3.create();
2111 @DontInline
2112 MyValue3 test75_target() {
2113 return test75_vt;
2114 }
2115
2116 static final MethodHandle test75_mh;
2117
2118 @Test
2119 MyValue3 test75() throws Throwable {
2120 return (MyValue3)test75_mh.invokeExact(this);
2121 }
2122
2123 @DontCompile
2124 public void test75_verifier(boolean warmup) throws Throwable {
2125 // hack so C2 doesn't know the target of the invoke call
2126 Class c = Class.forName("java.lang.invoke.DirectMethodHandle");
2127 Method m = c.getDeclaredMethod("internalMemberName", Object.class);
2128 WHITE_BOX.testSetDontInlineMethod(m, warmup);
2129 MyValue3 vt = test75();
2130 test75_vt.verify(vt);
2131 }
2132
2133 // Test no result from inlined method for incremental inlining
2134 final MyValue3 test76_vt = MyValue3.create();
2135 public MyValue3 test76_inlined() {
2136 throw new RuntimeException();
2137 }
2138
2139 @Test
2140 public MyValue3 test76() {
2141 try {
2142 return test76_inlined();
2143 } catch (RuntimeException ex) {
2144 return test76_vt;
2145 }
2146 }
2147
2148 @DontCompile
2149 public void test76_verifier(boolean warmup) throws Exception {
2150 MyValue3 vt = test76();
2151 test76_vt.verify(vt);
2152 }
2153
2154 static {
2155 try {
2156 MethodHandles.Lookup lookup = MethodHandles.lookup();
2157 MethodType mt = MethodType.fromMethodDescriptorString("()Qcompiler/valhalla/valuetypes/MyValue3;", ValueTypeTestBench.class.getClassLoader());
2158 test73_mh = lookup.findVirtual(ValueTypeTestBench.class, "test73_target", mt);
2159 test74_mh = lookup.findVirtual(ValueTypeTestBench.class, "test74_target", mt);
2160 test75_mh = lookup.findVirtual(ValueTypeTestBench.class, "test75_target", mt);
2161 } catch (NoSuchMethodException|IllegalAccessException e) {
2162 throw new RuntimeException("method handle lookup fails");
2163 }
2164 }
2165
2166 /* Array load out of bounds (upper bound) at compile time.*/
2167 @Test
2168 public int test77() {
2169 int arraySize = Math.abs(rI) % 10;;
2170 MyValue1[] va = new MyValue1[arraySize];
2171
2172 for (int i = 0; i < arraySize; i++) {
2173 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL);
2174 }
2175
2176 try {
2177 return va[arraySize + 1].x;
2178 } catch (ArrayIndexOutOfBoundsException e) {
2179 return rI;
2180 }
2181 }
2182
2183 public void test77_verifier(boolean warmup) {
2184 Asserts.assertEQ(test77(), rI);
2185 }
2186
2187 /* Array load out of bounds (lower bound) at compile time.*/
2188 @Test
2189 public int test78() {
2190 int arraySize = Math.abs(rI) % 10;;
2191 MyValue1[] va = new MyValue1[arraySize];
2192
2193 for (int i = 0; i < arraySize; i++) {
2194 va[i] = MyValue1.createWithFieldsDontInline(rI + i, rL);
2195 }
2196
2197 try {
2198 return va[-arraySize].x;
2199 } catch (ArrayIndexOutOfBoundsException e) {
2200 return rI;
2201 }
2202 }
2203
2204 public void test78_verifier(boolean warmup) {
2205 Asserts.assertEQ(test78(), rI);
2206 }
2207
2208 /* Array load out of bound not known to compiler (both lower and upper bound). */
2209 @Test
2210 public int test79(MyValue1[] va, int index) {
2211 return va[index].x;
2212 }
2213
2214 public void test79_verifier(boolean warmup) {
2215 int arraySize = Math.abs(rI) % 10;
2216 MyValue1[] va = new MyValue1[arraySize];
2217
2218 for (int i = 0; i < arraySize; i++) {
2219 va[i] = MyValue1.createWithFieldsDontInline(rI, rL);
2220 }
2221
2222 int result;
2223 for (int i = -20; i < 20; i++) {
2224 try {
2225 result = test79(va, i);
2226 } catch (ArrayIndexOutOfBoundsException e) {
2227 result = rI;
2228 }
2229 Asserts.assertEQ(result, rI);
2230 }
2231 }
2232
2233 /* Array store out of bounds (upper bound) at compile time.*/
2234 @Test
2235 public int test80() {
2236 int arraySize = Math.abs(rI) % 10;;
2237 MyValue1[] va = new MyValue1[arraySize];
2238
2239 try {
2240 for (int i = 0; i <= arraySize; i++) {
2241 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL);
2242 }
2243 return rI - 1;
2244 } catch (ArrayIndexOutOfBoundsException e) {
2245 return rI;
2246 }
2247 }
2248
2249 public void test80_verifier(boolean warmup) {
2250 Asserts.assertEQ(test80(), rI);
2251 }
2252
2253 /* Array store out of bounds (lower bound) at compile time.*/
2254 @Test
2255 public int test81() {
2256 int arraySize = Math.abs(rI) % 10;;
2257 MyValue1[] va = new MyValue1[arraySize];
2258
2259 try {
2260 for (int i = -1; i <= arraySize; i++) {
2261 va[i] = MyValue1.createWithFieldsDontInline(rI + 1, rL);
2262 }
2263 return rI - 1;
2264 } catch (ArrayIndexOutOfBoundsException e) {
2265 return rI;
2266 }
2267 }
2268
2269 public void test81_verifier(boolean warmup) {
2270 Asserts.assertEQ(test81(), rI);
2271 }
2272
2273 /* Array store out of bound not known to compiler (both lower and upper bound). */
2274 @Test
2275 public int test82(MyValue1[] va, int index, MyValue1 vt) {
2276 va[index] = vt;
2277 return va[index].x;
2278 }
2279
2280 @DontCompile
2281 public void test82_verifier(boolean warmup) {
2282 int arraySize = Math.abs(rI) % 10;
2283 MyValue1[] va = new MyValue1[arraySize];
2284
2285 for (int i = 0; i < arraySize; i++) {
2286 va[i] = MyValue1.createWithFieldsDontInline(rI, rL);
2287 }
2288
2289 MyValue1 vt = MyValue1.createWithFieldsDontInline(rI + 1, rL);
2290 int result;
2291 for (int i = -20; i < 20; i++) {
2292 try {
2293 result = test82(va, i, vt);
2294 } catch (ArrayIndexOutOfBoundsException e) {
2295 result = rI + 1;
2296 }
2297 Asserts.assertEQ(result, rI + 1);
2298 }
2299
2300 for (int i = 0; i < arraySize; i++) {
2301 Asserts.assertEQ(va[i].x, rI + 1);
2302 }
2303 }
2304
2305 /* Create a new value type array and store a value type into
2306 * it. The test should pass without throwing an exception. */
2307 @Test
2308 public void test83() throws Throwable {
2309 vastoreMH.invokeExact(vcc);
2310 }
2311
2312 public void test83_verifier(boolean warmup) throws Throwable {
2313 test83();
2314 }
2315
2316 private static MethodHandle generateVastore() {
2317 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
2318 "Vastore",
2319 MethodType.methodType(void.class, ValueCapableClass1.class),
2320 CODE -> {
2321 CODE.
2322 iconst_1().
2323 anewarray(ValueType.forClass(ValueCapableClass1.class).valueClass()).
2324 iconst_0().
2325 aload_0().
2326 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
2327 vastore().
2328 return_();
2329 }
2330 );
2331 }
2332
2333 /* Create a new value type array with element type
2334 * ValueCapableClass1 and attempt to store a value type of type
2335 * ValueCapableClass2 into it. */
2336 @Test
2337 public void test84() throws Throwable {
2338 invalidVastoreMH.invokeExact(vcc2);
2339 }
2340
2341 public void test84_verifier(boolean warmup) throws Throwable {
2342 boolean exceptionThrown = false;
2343 try {
2344 test84();
2345 } catch (ArrayStoreException e) {
2346 exceptionThrown = true;
2347 }
2348 Asserts.assertTrue(exceptionThrown, "ArrayStoreException must be thrown");
2349 }
2350
2351 private static MethodHandle generateInvalidVastore() {
2352 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
2353 "Vastore",
2354 MethodType.methodType(void.class, ValueCapableClass2.class),
2355 CODE -> {
2356 CODE.
2357 iconst_1().
2358 anewarray(ValueType.forClass(ValueCapableClass1.class).valueClass()).
2359 iconst_0().
2360 aload_0().
2361 vunbox(ValueType.forClass(ValueCapableClass2.class).valueClass()).
2362 vastore().
2363 return_();
2364 }
2365 );
2366 }
2367
2368 // ========== Test infrastructure ==========
2369
2370 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
2371 private static final int ValueTypePassFieldsAsArgsOn = 0x1;
2372 private static final int ValueTypePassFieldsAsArgsOff = 0x2;
2373 private static final int ValueTypeArrayFlattenOn = 0x4;
2374 private static final int ValueTypeArrayFlattenOff = 0x8;
2375 private static final int ValueTypeReturnedAsFieldsOn = 0x10;
2376 private static final int ValueTypeReturnedAsFieldsOff = 0x20;
2377 static final int AllFlags = ValueTypePassFieldsAsArgsOn | ValueTypePassFieldsAsArgsOff | ValueTypeArrayFlattenOn | ValueTypeArrayFlattenOff | ValueTypeReturnedAsFieldsOn;
2378 private static final boolean ValueTypePassFieldsAsArgs = (Boolean)WHITE_BOX.getVMFlag("ValueTypePassFieldsAsArgs");
2379 private static final boolean ValueTypeArrayFlatten = (Boolean)WHITE_BOX.getVMFlag("ValueArrayFlatten");
2380 private static final boolean ValueTypeReturnedAsFields = (Boolean)WHITE_BOX.getVMFlag("ValueTypeReturnedAsFields");
2381 private static final int COMP_LEVEL_ANY = -1;
2382 private static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
2383 private static final Hashtable<String, Method> tests = new Hashtable<String, Method>();
2384 private static final int WARMUP = 251;
2385 private static boolean USE_COMPILER = WHITE_BOX.getBooleanVMFlag("UseCompiler");
2386 private static boolean PRINT_IDEAL = WHITE_BOX.getBooleanVMFlag("PrintIdeal");
2387 private static boolean XCOMP = Platform.isComp();
2388
2389 // Regular expressions used to match nodes in the PrintIdeal output
2390 private static final String START = "(\\d+\\t(.*";
2391 private static final String MID = ".*)+\\t===.*";
2392 private static final String END = ")|";
2393 private static final String ALLOC = "(.*precise klass compiler/valhalla/valuetypes/MyValue.*\\R(.*(nop|spill).*\\R)*.*_new_instance_Java" + END;
2394 private static final String ALLOCA = "(.*precise klass \\[Qcompiler/valhalla/valuetypes/MyValue.*\\R(.*(nop|spill).*\\R)*.*_new_array_Java" + END;
2395 private static final String LOAD = START + "Load(B|S|I|L|F|D)" + MID + "valuetype\\*" + END;
2396 private static final String LOADP = START + "Load(P|N)" + MID + "valuetype\\*" + END;
2397 private static final String STORE = START + "Store(B|S|I|L|F|D)" + MID + "valuetype\\*" + END;
2398 private static final String STOREP = START + "Store(P|N)" + MID + "valuetype\\*" + END;
2399 private static final String LOOP = START + "Loop" + MID + "" + END;
2400 private static final String TRAP = START + "CallStaticJava" + MID + "uncommon_trap.*(unstable_if|predicate)" + END;
2401 private static final String RETURN = START + "Return" + MID + "returns" + END;
2402 private static final String LINKTOSTATIC = START + "CallStaticJava" + MID + "linkToStatic" + END;
2403 private static final String NPE = START + "CallStaticJava" + MID + "null_check" + END;
2404 private static final String CCE = START + "CallStaticJava" + MID + "class_check" + END;
2405 private static final String CALL = START + "CallStaticJava" + MID + END;
2406 private static final String SCOBJ = "(.*# ScObj.*" + END;
2407
2408 static {
2409 // Gather all test methods and put them in Hashtable
2410 for (Method m : ValueTypeTestBench.class.getDeclaredMethods()) {
2411 Test[] annos = m.getAnnotationsByType(Test.class);
2412 if (annos.length != 0) {
2413 tests.put("ValueTypeTestBench::" + m.getName(), m);
2414 }
2415 }
2416 }
2417
2418 private static void execute_vm(String... args) throws Throwable {
2419 Asserts.assertFalse(tests.isEmpty(), "no tests to execute");
2420 ArrayList<String> all_args = new ArrayList(List.of(args));
2421 // Run tests in own process and verify output
2422 all_args.add(ValueTypeTestBench.class.getName());
2423 all_args.add("run");
2424 // Spawn process with default JVM options from the test's run command
2425 String[] vmInputArgs = InputArguments.getVmInputArgs();
2426 String[] cmds = Arrays.copyOf(vmInputArgs, vmInputArgs.length + all_args.size());
2427 System.arraycopy(all_args.toArray(), 0, cmds, vmInputArgs.length, all_args.size());
2428 OutputAnalyzer oa = ProcessTools.executeTestJvm(cmds);
2429 // If ideal graph printing is enabled/supported, verify output
2430 String output = oa.getOutput();
2431 oa.shouldHaveExitValue(0);
2432 boolean verifyIR = output.contains("PrintIdeal enabled") &&
2433 !output.contains("ValueTypePassFieldsAsArgs is not supported on this platform");
2434 if (verifyIR) {
2435 parseOutput(output);
2436 } else {
2437 System.out.println("WARNING: IR verification disabled! Running with -Xint, -Xcomp or release build?");
2438 }
2439 }
2440
2441 public static void main(String[] args) throws Throwable {
2442 //tests.values().removeIf(p -> !p.getName().equals("test85")); // Run single test
2443 if (args.length == 0) {
2444 execute_vm("-XX:+IgnoreUnrecognizedVMOptions", "-XX:-BackgroundCompilation",
2445 "-XX:+PrintCompilation", "-XX:+PrintInlining", "-XX:+PrintIdeal", "-XX:+PrintOptoAssembly",
2446 "-XX:CICompilerCount=1",
2447 "-XX:CompileCommand=quiet", "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.ValueTypeTestBench::*",
2448 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue1::*",
2449 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue2::*",
2450 "-XX:CompileCommand=compileonly,java.lang.Object::<init>",
2451 "-XX:CompileCommand=inline,java.lang.__Value::hashCode",
2452 "-XX:CompileCommand=compileonly,java.lang.invoke.*::*");
2453 } else {
2454 // Execute tests
2455 ValueTypeTestBench bench = new ValueTypeTestBench();
2456 bench.run();
2457 }
2458 }
2459
2460 public static void parseOutput(String output) throws Exception {
2461 Pattern comp_re = Pattern.compile("\\n\\s+\\d+\\s+\\d+\\s+(%| )(s| )(!| )b(n| )\\s+\\S+\\.(?<name>[^.]+::\\S+)\\s+(?<osr>@ \\d+\\s+)?[(]\\d+ bytes[)]\\n");
2462 Matcher m = comp_re.matcher(output);
2463 Map<String,String> compilations = new LinkedHashMap<>();
2464 int prev = 0;
2465 String methodName = null;
2466 while (m.find()) {
2467 if (prev == 0) {
2468 // Print header
2469 System.out.print(output.substring(0, m.start()+1));
2470 } else if (methodName != null) {
2471 compilations.put(methodName, output.substring(prev, m.start()+1));
2472 }
2473 if (m.group("osr") != null) {
2474 methodName = null;
2475 } else {
2476 methodName = m.group("name");
2477 }
2478 prev = m.end();
2479 }
2480 if (prev == 0) {
2481 // Print header
2482 System.out.print(output);
2483 } else if (methodName != null) {
2484 compilations.put(methodName, output.substring(prev));
2485 }
2486 // Iterate over compilation output
2487 for (String testName : compilations.keySet()) {
2488 Method test = tests.get(testName);
2489 if (test == null) {
2490 // Skip helper methods
2491 continue;
2492 }
2493 String graph = compilations.get(testName);
2494 if (PRINT_GRAPH) {
2495 System.out.println("\nGraph for " + testName + "\n" + graph);
2496 }
2497 // Parse graph using regular expressions to determine if it contains forbidden nodes
2498 Test[] annos = test.getAnnotationsByType(Test.class);
2499 Test anno = null;
2500 for (Test a : annos) {
2501 if ((a.valid() & ValueTypePassFieldsAsArgsOn) != 0 && ValueTypePassFieldsAsArgs) {
2502 assert anno == null;
2503 anno = a;
2504 } else if ((a.valid() & ValueTypePassFieldsAsArgsOff) != 0 && !ValueTypePassFieldsAsArgs) {
2505 assert anno == null;
2506 anno = a;
2507 } else if ((a.valid() & ValueTypeArrayFlattenOn) != 0 && ValueTypeArrayFlatten) {
2508 assert anno == null;
2509 anno = a;
2510 } else if ((a.valid() & ValueTypeArrayFlattenOff) != 0 && !ValueTypeArrayFlatten) {
2511 assert anno == null;
2512 anno = a;
2513 } else if ((a.valid() & ValueTypeReturnedAsFieldsOn) != 0 && ValueTypeReturnedAsFields) {
2514 assert anno == null;
2515 anno = a;
2516 } else if ((a.valid() & ValueTypeReturnedAsFieldsOff) != 0 && !ValueTypeReturnedAsFields) {
2517 assert anno == null;
2518 anno = a;
2519 }
2520 }
2521 assert anno != null;
2522 String regexFail = anno.failOn();
2523 if (!regexFail.isEmpty()) {
2524 Pattern pattern = Pattern.compile(regexFail.substring(0, regexFail.length()-1));
2525 Matcher matcher = pattern.matcher(graph);
2526 boolean found = matcher.find();
2527 Asserts.assertFalse(found, "Graph for '" + testName + "' contains forbidden node:\n" + (found ? matcher.group() : ""));
2528 }
2529 String[] regexMatch = anno.match();
2530 int[] matchCount = anno.matchCount();
2531 for (int i = 0; i < regexMatch.length; ++i) {
2532 Pattern pattern = Pattern.compile(regexMatch[i].substring(0, regexMatch[i].length()-1));
2533 Matcher matcher = pattern.matcher(graph);
2534 int count = 0;
2535 String nodes = "";
2536 while (matcher.find()) {
2537 count++;
2538 nodes += matcher.group() + "\n";
2539 }
2540 if (matchCount[i] < 0) {
2541 Asserts.assertLTE(Math.abs(matchCount[i]), count, "Graph for '" + testName + "' contains different number of match nodes:\n" + nodes);
2542 } else {
2543 Asserts.assertEQ(matchCount[i], count, "Graph for '" + testName + "' contains different number of match nodes:\n" + nodes);
2544 }
2545 }
2546 tests.remove(testName);
2547 System.out.println(testName + " passed");
2548 }
2549 // Check if all tests were compiled
2550 if (tests.size() != 0) {
2551 for (String name : tests.keySet()) {
2552 System.out.println("Test '" + name + "' not compiled!");
2553 }
2554 throw new RuntimeException("Not all tests were compiled");
2555 }
2556 }
2557
2558 public void setup(Method[] methods) {
2559 if (XCOMP) {
2560 // Don't control compilation if -Xcomp is enabled
2561 return;
2562 }
2563 for (Method m : methods) {
2564 if (m.isAnnotationPresent(Test.class)) {
2565 // Don't inline tests
2566 WHITE_BOX.testSetDontInlineMethod(m, true);
2567 }
2568 if (m.isAnnotationPresent(DontCompile.class)) {
2569 WHITE_BOX.makeMethodNotCompilable(m, COMP_LEVEL_ANY, true);
2570 WHITE_BOX.makeMethodNotCompilable(m, COMP_LEVEL_ANY, false);
2571 WHITE_BOX.testSetDontInlineMethod(m, true);
2572 }
2573 if (m.isAnnotationPresent(ForceInline.class)) {
2574 WHITE_BOX.testSetForceInlineMethod(m, true);
2575 } else if (m.isAnnotationPresent(DontInline.class)) {
2576 WHITE_BOX.testSetDontInlineMethod(m, true);
2577 }
2578 }
2579 }
2580
2581 public void run() throws Exception {
2582 if (USE_COMPILER && PRINT_IDEAL && !XCOMP) {
2583 System.out.println("PrintIdeal enabled");
2584 }
2585 System.out.format("rI = %d, rL = %d\n", rI, rL);
2586 setup(this.getClass().getDeclaredMethods());
2587 setup(MyValue1.class.getDeclaredMethods());
2588 setup(MyValue2.class.getDeclaredMethods());
2589
2590 // Compile class initializers
2591 WHITE_BOX.enqueueInitializerForCompilation(this.getClass(), COMP_LEVEL_FULL_OPTIMIZATION);
2592 WHITE_BOX.enqueueInitializerForCompilation(MyValue1.class, COMP_LEVEL_FULL_OPTIMIZATION);
2593 WHITE_BOX.enqueueInitializerForCompilation(MyValue2.class, COMP_LEVEL_FULL_OPTIMIZATION);
2594
2595 // Execute tests
2596 for (Method test : tests.values()) {
2597 Method verifier = getClass().getDeclaredMethod(test.getName() + "_verifier", boolean.class);
2598 // Warmup using verifier method
2599 for (int i = 0; i < WARMUP; ++i) {
2600 verifier.invoke(this, true);
2601 }
2602 // Trigger compilation
2603 WHITE_BOX.enqueueMethodForCompilation(test, COMP_LEVEL_FULL_OPTIMIZATION);
2604 Asserts.assertTrue(!USE_COMPILER || WHITE_BOX.isMethodCompiled(test, false), test + " not compiled");
2605 // Check result
2606 verifier.invoke(this, false);
2607 }
2608 }
2609 }
2610
2611 // Mark method as test
2612 @Retention(RetentionPolicy.RUNTIME)
2613 @Repeatable(Tests.class)
2614 @interface Test {
2615 // Regular expression used to match forbidden IR nodes
2616 // in the C2 IR emitted for this test.
2617 String failOn() default "";
2618 // Regular expressions used to match and count IR nodes.
2619 String[] match() default { };
2620 int[] matchCount() default { };
2621 int valid() default ValueTypeTestBench.AllFlags;
2622 }
2623
2624 @Retention(RetentionPolicy.RUNTIME)
2625 @interface Tests {
2626 Test[] value();
2627 }
2628
2629 // Force method inlining during compilation
2630 @Retention(RetentionPolicy.RUNTIME)
2631 @interface ForceInline { }
2632
2633 // Prevent method inlining during compilation
2634 @Retention(RetentionPolicy.RUNTIME)
2635 @interface DontInline { }
2636
2637 // Prevent method compilation
2638 @Retention(RetentionPolicy.RUNTIME)
2639 @interface DontCompile { }