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 * @build compiler.valhalla.valuetypes.ValueTypeTestBench
30 * @run main ClassFileInstaller sun.hotspot.WhiteBox
31 * @run main ClassFileInstaller jdk.test.lib.Platform
32 * @run main/othervm -ea -noverify -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
33 * -XX:+UnlockExperimentalVMOptions -XX:+ValueTypePassFieldsAsArgs
34 * -XX:-TieredCompilation compiler.valhalla.valuetypes.ValueTypeTestBench
35 * @run main/othervm -ea -noverify -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
36 * -XX:+UnlockExperimentalVMOptions -XX:-ValueTypePassFieldsAsArgs
37 * -XX:-TieredCompilation compiler.valhalla.valuetypes.ValueTypeTestBench
38 */
39
40 package compiler.valhalla.valuetypes;
41
42 import compiler.whitebox.CompilerWhiteBoxTest;
43 import jdk.internal.misc.Unsafe;
44 import jdk.test.lib.Asserts;
45 import jdk.test.lib.Platform;
46 import jdk.test.lib.ProcessTools;
47 import jdk.test.lib.OutputAnalyzer;
48 import jdk.test.lib.Utils;
49 import sun.hotspot.WhiteBox;
50
51 import java.lang.annotation.Retention;
52 import java.lang.annotation.RetentionPolicy;
53 import java.lang.annotation.Repeatable;
54 import java.lang.invoke.*;
55 import java.lang.reflect.Method;
56 import java.util.ArrayList;
57 import java.util.Arrays;
58 import java.util.Hashtable;
59 import java.util.List;
60 import java.util.regex.Matcher;
61 import java.util.regex.Pattern;
62 import jdk.experimental.value.*;
63
64 // Test value types
65 __ByValue final class MyValue1 {
66 static int s;
67 static final long sf = ValueTypeTestBench.rL;
68 final int x;
69 final long y;
70 final MyValue2 v1;
71 final MyValue2 v2;
72 static final MyValue2 v3 = MyValue2.createInline(ValueTypeTestBench.rI, true);
73 final int c;
74
75 private MyValue1(int x, long y, MyValue2 v1, MyValue2 v2, int c) {
76 s = x;
77 this.x = x;
78 this.y = y;
79 this.v1 = v1;
80 this.v2 = v2;
81 this.c = c;
82 }
83
84 @DontInline
85 public static MyValue1 createDontInline(int x, long y) {
86 return __Make MyValue1(x, y, MyValue2.createInline(x, true), MyValue2.createInline(x, false), ValueTypeTestBench.rI);
87 }
88
89 @ForceInline
90 public static MyValue1 createInline(int x, long y) {
91 return __Make MyValue1(x, y, MyValue2.createInline(x, true), MyValue2.createInline(x, false), ValueTypeTestBench.rI);
92 }
93
94 @ForceInline
95 public long hash() {
96 return s + sf + x + y + c + v1.hash() + v2.hash() + v3.hash();
97 }
98
99 @DontCompile
100 public long hashInterpreted() {
101 return s + sf + x + y + c + v1.hashInterpreted() + v2.hashInterpreted() + v3.hashInterpreted();
102 }
103 }
104
105 __ByValue final class MyValue2 {
106 final int x;
107 final boolean b;
108 final long c;
109
110 private MyValue2(int x, boolean b, long c) {
111 this.x = x;
112 this.b = b;
113 this.c = c;
114 }
115
116 @ForceInline
117 public static MyValue2 createInline(int x, boolean b) {
118 return __Make MyValue2(x, b, ValueTypeTestBench.rL);
119 }
120
121 @ForceInline
122 public long hash() {
123 return x + (b ? 0 : 1) + c;
124 }
125
126 @DontInline
127 public long hashInterpreted() {
128 return x + (b ? 0 : 1) + c;
129 }
130 }
131
132 public class ValueTypeTestBench {
133 // Print ideal graph after execution of each test
134 private static final boolean PRINT_GRAPH = true;
135
136 // Random test values
137 public static final int rI = Utils.getRandomInstance().nextInt() % 1000;
138 public static final long rL = Utils.getRandomInstance().nextLong() % 1000;
139
140 public ValueTypeTestBench() {
141 val3 = MyValue1.createInline(rI, rL);
142 }
143
144 // MethodHandles and value-capable class instance needed for testing vbox/vunbox
145 private static final MethodHandle vccUnboxLoadLongMH = generateVCCUnboxLoadLongMH();
146 private static final MethodHandle vccUnboxLoadIntMH = generateVCCUnboxLoadIntMH();
147 private static final MethodHandle vccUnboxBoxMH = generateVCCUnboxBoxMH();
148 private static final MethodHandle vccUnboxBoxLoadIntMH = generateVCCUnboxBoxLoadIntMH();
149
150 private static final ValueCapableClass1 vcc = ValueCapableClass1.create(rL, rI, (short)rI, (short)rI);
151
152 // ========== Helper methods ==========
153
154 public long hash() {
155 return hash(rI, rL);
156 }
157
158 public long hash(int x, long y) {
159 return MyValue1.createInline(x, y).hash();
160 }
161
162 // ========== Test definitions ==========
163
164 // Receive value type through call to interpreter
165 @Test(failOn = ALLOC + STORE + TRAP)
166 public long test1() {
167 MyValue1 v = MyValue1.createDontInline(rI, rL);
168 return v.hash();
169 }
170
171 @DontCompile
172 public void test1_verifier(boolean warmup) {
173 long result = test1();
174 Asserts.assertEQ(result, hash());
175 }
176
177 // Receive value type from interpreter via parameter
178 @Test(failOn = ALLOC + STORE + TRAP)
179 public long test2(MyValue1 v) {
180 return v.hash();
181 }
182
183 @DontCompile
184 public void test2_verifier(boolean warmup) {
185 MyValue1 v = MyValue1.createDontInline(rI, rL);
186 long result = test2(v);
187 Asserts.assertEQ(result, hash());
188 }
189
190 // Return incoming value type without accessing fields
191 @Test(valid = ValueTypePassFieldsAsArgsOn, match = {ALLOC, STORE}, matchCount = {1, 9}, failOn = LOAD + TRAP)
192 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = ALLOC + LOAD + STORE + TRAP)
193 public MyValue1 test3(MyValue1 v) {
194 return v;
195 }
196
197 @DontCompile
198 public void test3_verifier(boolean warmup) {
199 MyValue1 v1 = MyValue1.createDontInline(rI, rL);
200 MyValue1 v2 = test3(v1);
201 Asserts.assertEQ(v1.x, v2.x);
202 Asserts.assertEQ(v1.y, v2.y);
203 }
204
205 // Create a value type in compiled code and only use fields.
206 // Allocation should go away because value type does not escape.
207 @Test(failOn = ALLOC + LOAD + STORE + TRAP)
208 public long test4() {
209 MyValue1 v = MyValue1.createInline(rI, rL);
210 return v.hash();
211 }
212
213 @DontCompile
214 public void test4_verifier(boolean warmup) {
215 long result = test4();
216 Asserts.assertEQ(result, hash());
217 }
218
219 // Create a value type in compiled code and pass it to
220 // an inlined compiled method via a call.
221 @Test(failOn = ALLOC + LOAD + STORE + TRAP)
222 public long test5() {
223 MyValue1 v = MyValue1.createInline(rI, rL);
224 return test5Inline(v);
225 }
226
227 @ForceInline
228 public long test5Inline(MyValue1 v) {
229 return v.hash();
230 }
231
232 @DontCompile
233 public void test5_verifier(boolean warmup) {
234 long result = test5();
235 Asserts.assertEQ(result, hash());
236 }
237
238 // Create a value type in compiled code and pass it to
239 // the interpreter via a call.
240 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = LOAD + TRAP + ALLOC)
241 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
242 public long test6() {
243 MyValue1 v = MyValue1.createInline(rI, rL);
244 // Pass to interpreter
245 return v.hashInterpreted();
246 }
247
248 @DontCompile
249 public void test6_verifier(boolean warmup) {
250 long result = test6();
251 Asserts.assertEQ(result, hash());
252 }
253
254 // Create a value type in compiled code and pass it to
255 // the interpreter by returning.
256 @Test(match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
257 public MyValue1 test7(int x, long y) {
258 return MyValue1.createInline(x, y);
259 }
260
261 @DontCompile
262 public void test7_verifier(boolean warmup) {
263 MyValue1 v = test7(rI, rL);
264 Asserts.assertEQ(v.hash(), hash());
265 }
266
267 // Merge value types created from two branches
268 @Test(failOn = ALLOC + STORE + TRAP)
269 public long test8(boolean b) {
270 MyValue1 v;
271 if (b) {
272 v = MyValue1.createInline(rI, rL);
273 } else {
274 v = MyValue1.createDontInline(rI + 1, rL + 1);
275 }
276 return v.hash();
277 }
278
279 @DontCompile
280 public void test8_verifier(boolean warmup) {
281 Asserts.assertEQ(test8(true), hash());
282 Asserts.assertEQ(test8(false), hash(rI + 1, rL + 1));
283 }
284
285 // Merge value types created from two branches
286 @Test(valid = ValueTypePassFieldsAsArgsOn, match = {LOAD}, matchCount = {9}, failOn = TRAP + ALLOC + STORE)
287 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC, STORE}, matchCount = {1, 3}, failOn = LOAD + TRAP)
288 public MyValue1 test9(boolean b) {
289 MyValue1 v;
290 if (b) {
291 // Value type is not allocated
292 v = MyValue1.createInline(rI, rL);
293 } else {
294 // Value type is allocated by the callee
295 v = MyValue1.createDontInline(rI + 1, rL + 1);
296 }
297 // Need to allocate value type if 'b' is true
298 long sum = v.hashInterpreted();
299 if (b) {
300 v = MyValue1.createDontInline(rI, sum);
301 } else {
302 v = MyValue1.createDontInline(rI, sum + 1);
303 }
304 // Don't need to allocate value type because both branches allocate
305 return v;
306 }
307
308 @DontCompile
309 public void test9_verifier(boolean warmup) {
310 MyValue1 v = test9(true);
311 Asserts.assertEQ(v.x, rI);
312 Asserts.assertEQ(v.y, hash());
313 v = test9(false);
314 Asserts.assertEQ(v.x, rI);
315 Asserts.assertEQ(v.y, hash(rI + 1, rL + 1) + 1);
316 }
317
318 // Merge value types created in a loop (not inlined)
319 @Test(failOn = ALLOC + STORE + TRAP)
320 public long test10(int x, long y) {
321 MyValue1 v = MyValue1.createDontInline(x, y);
322 for (int i = 0; i < 10; ++i) {
323 v = MyValue1.createDontInline(v.x + 1, v.y + 1);
324 }
325 return v.hash();
326 }
327
328 @DontCompile
329 public void test10_verifier(boolean warmup) {
330 long result = test10(rI, rL);
331 Asserts.assertEQ(result, hash(rI + 10, rL + 10));
332 }
333
334 // Merge value types created in a loop (inlined)
335 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
336 public long test11(int x, long y) {
337 MyValue1 v = MyValue1.createInline(x, y);
338 for (int i = 0; i < 10; ++i) {
339 v = MyValue1.createInline(v.x + 1, v.y + 1);
340 }
341 return v.hash();
342 }
343
344 @DontCompile
345 public void test11_verifier(boolean warmup) {
346 long result = test11(rI, rL);
347 Asserts.assertEQ(result, hash(rI + 10, rL + 10));
348 }
349
350 // Test loop with uncommon trap referencing a value type
351 @Test(match = {TRAP, SCOBJ}, matchCount = {1, 1}, failOn = ALLOC + LOAD + STORE)
352 public long test12(boolean b) {
353 MyValue1 v = MyValue1.createInline(rI, rL);
354 long result = 42;
355 for (int i = 0; i < 1000; ++i) {
356 if (b) {
357 result += v.x;
358 } else {
359 // Uncommon trap referencing v. We delegate allocation to the
360 // interpreter by adding a SafePointScalarObjectNode.
361 result = v.hashInterpreted();
362 }
363 }
364 return result;
365 }
366
367 @DontCompile
368 public void test12_verifier(boolean warmup) {
369 long result = test12(warmup);
370 Asserts.assertEQ(result, warmup ? 42 + (1000*rI) : hash());
371 }
372
373 // Test loop with uncommon trap referencing a value type
374 @Test(match = {TRAP, LOAD}, matchCount = {1, 1}, failOn = ALLOC + STORE + SCOBJ)
375 public long test13(boolean b) {
376 MyValue1 v = MyValue1.createDontInline(rI, rL);
377 long result = 42;
378 for (int i = 0; i < 1000; ++i) {
379 if (b) {
380 result += v.x;
381 } else {
382 // Uncommon trap referencing v. Should not allocate
383 // but just pass the existing oop to the uncommon trap.
384 result = v.hashInterpreted();
385 }
386 }
387 return result;
388 }
389
390 @DontCompile
391 public void test13_verifier(boolean warmup) {
392 long result = test13(warmup);
393 Asserts.assertEQ(result, warmup ? 42 + (1000*rI) : hash());
394 }
395
396 // Create a value type in a non-inlined method and then call a
397 // non-inlined method on that value type.
398 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (ALLOC + STORE + TRAP), match = {LOAD}, matchCount = {9})
399 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = (ALLOC + LOAD + STORE + TRAP))
400 public long test14() {
401 MyValue1 v = MyValue1.createDontInline(rI, rL);
402 return v.hashInterpreted();
403 }
404
405 @DontCompile
406 public void test14_verifier(boolean b) {
407 long result = test14();
408 Asserts.assertEQ(result, hash());
409 }
410
411 // Create a value type in an inlined method and then call a
412 // non-inlined method on that value type.
413 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (LOAD + TRAP + ALLOC))
414 @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = (LOAD + TRAP), match = {ALLOC}, matchCount = {1})
415 public long test15() {
416 MyValue1 v = MyValue1.createInline(rI, rL);
417 return v.hashInterpreted();
418 }
419
420 @DontCompile
421 public void test15_verifier(boolean b) {
422 long result = test15();
423 Asserts.assertEQ(result, hash());
424 }
425
426 // Create a value type in a non-inlined method and then call an
427 // inlined method on that value type.
428 @Test(failOn = (ALLOC + STORE + TRAP))
429 public long test16() {
430 MyValue1 v = MyValue1.createDontInline(rI, rL);
431 return v.hash();
432 }
433
434 @DontCompile
435 public void test16_verifier(boolean b) {
436 long result = test16();
437 Asserts.assertEQ(result, hash());
438 }
439
440 // Create a value type in an inlined method and then call an
441 // inlined method on that value type.
442 @Test(failOn = (ALLOC + LOAD + STORE + TRAP))
443 public long test17() {
444 MyValue1 v = MyValue1.createInline(rI, rL);
445 return v.hash();
446 }
447
448 @DontCompile
449 public void test17_verifier(boolean b) {
450 long result = test17();
451 Asserts.assertEQ(result, hash());
452 }
453
454 // Create a value type in compiled code and pass it to the
455 // interpreter via a call. The value is live at the first call so
456 // debug info should include a reference to all its fields.
457 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = ALLOC + LOAD + TRAP)
458 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
459 public long test18() {
460 MyValue1 v = MyValue1.createInline(rI, rL);
461 v.hashInterpreted();
462 return v.hashInterpreted();
463 }
464
465 @DontCompile
466 public void test18_verifier(boolean warmup) {
467 long result = test18();
468 Asserts.assertEQ(result, hash());
469 }
470
471 // Create a value type in compiled code and pass it to the
472 // interpreter via a call. The value type is passed twice but
473 // should only be allocated once.
474 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = ALLOC + LOAD + TRAP)
475 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD + TRAP)
476 public long test19() {
477 MyValue1 v = MyValue1.createInline(rI, rL);
478 return sumValue(v, v);
479 }
480
481 @DontCompile
482 public long sumValue(MyValue1 v, MyValue1 dummy) {
483 return v.hash();
484 }
485
486 @DontCompile
487 public void test19_verifier(boolean warmup) {
488 long result = test19();
489 Asserts.assertEQ(result, hash());
490 }
491
492 // Create a value type in compiled code and pass it to the
493 // interpreter via a call. The value type is live at the uncommon
494 // trap: verify that deoptimization causes the value type to be
495 // correctly allocated.
496 @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = LOAD + ALLOC + STORE)
497 @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD)
498 public long test20(boolean flag) {
499 MyValue1 v = MyValue1.createInline(rI, rL);
500 if (flag) {
501 // uncommon trap
502 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test20"));
503 }
504 return v.hashInterpreted();
505 }
506
507 @DontCompile
508 public void test20_verifier(boolean warmup) {
509 long result = test20(false);
510 Asserts.assertEQ(result, hash());
511 if (!warmup) {
512 result = test20(true);
513 Asserts.assertEQ(result, hash());
514 }
515 }
516
517 // Value type fields in regular object
518 MyValue1 val1;
519 MyValue2 val2;
520 final MyValue1 val3;
521 static MyValue1 val4;
522 static final MyValue1 val5 = MyValue1.createInline(rI, rL);
523
524 // Test value type fields in objects
525 @Test(match = {ALLOC}, matchCount = {1}, failOn = (TRAP))
526 public long test21(int x, long y) {
527 // Compute hash of value type fields
528 long result = val1.hash() + val2.hash() + val3.hash() + val4.hash() + val5.hash();
529 // Update fields
530 val1 = MyValue1.createInline(x, y);
531 val2 = MyValue2.createInline(x, true);
532 val4 = MyValue1.createInline(x, y);
533 return result;
534 }
535
536 @DontCompile
537 public void test21_verifier(boolean warmup) {
538 // Check if hash computed by test18 is correct
539 val1 = MyValue1.createInline(rI, rL);
540 val2 = val1.v2;
541 // val3 is initialized in the constructor
542 val4 = val1;
543 // val5 is initialized in the static initializer
544 long hash = val1.hash() + val2.hash() + val3.hash() + val4.hash() + val5.hash();
545 long result = test21(rI + 1, rL + 1);
546 Asserts.assertEQ(result, hash);
547 // Check if value type fields were updated
548 Asserts.assertEQ(val1.hash(), hash(rI + 1, rL + 1));
549 Asserts.assertEQ(val2.hash(), MyValue2.createInline(rI + 1, true).hash());
550 Asserts.assertEQ(val4.hash(), hash(rI + 1, rL + 1));
551 }
552
553 // Test folding of constant value type fields
554 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
555 public long test22() {
556 // This should be constant folded
557 return val5.hash() + val5.v3.hash();
558 }
559
560 @DontCompile
561 public void test22_verifier(boolean warmup) {
562 long result = test22();
563 Asserts.assertEQ(result, val5.hash() + val5.v3.hash());
564 }
565
566 // Test OSR compilation
567 @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
568 public long test23() {
569 MyValue1 v = MyValue1.createInline(rI, rL);
570 long result = 0;
571 // Long loop to trigger OSR compilation
572 for (int i = 0 ; i < 100_000 ; ++i) {
573 // Reference local value type in interpreter state
574 result = v.hash();
575 }
576 return result;
577 }
578
579 @DontCompile
580 public void test23_verifier(boolean warmup) {
581 long result = test23();
582 Asserts.assertEQ(result, hash());
583 }
584
585 // Test interpreter to compiled code with various signatures
586 @Test(failOn = ALLOC + STORE + TRAP)
587 public long test24(MyValue2 v) {
588 return v.hash();
589 }
590
591 @DontCompile
592 public void test24_verifier(boolean warmup) {
593 MyValue2 v = MyValue2.createInline(rI, true);
594 long result = test24(v);
595 Asserts.assertEQ(result, v.hashInterpreted());
596 }
597
598 @Test(failOn = ALLOC + STORE + TRAP)
599 public long test25(int i1, MyValue2 v, int i2) {
600 return v.hash() + i1 - i2;
601 }
602
603 @DontCompile
604 public void test25_verifier(boolean warmup) {
605 MyValue2 v = MyValue2.createInline(rI, true);
606 long result = test25(rI, v, 2*rI);
607 Asserts.assertEQ(result, v.hashInterpreted() - rI);
608 }
609
610 @Test(failOn = ALLOC + STORE + TRAP)
611 public long test26(long l1, MyValue2 v, long l2) {
612 return v.hash() + l1 - l2;
613 }
614
615 @DontCompile
616 public void test26_verifier(boolean warmup) {
617 MyValue2 v = MyValue2.createInline(rI, true);
618 long result = test26(rL, v, 2*rL);
619 Asserts.assertEQ(result, v.hashInterpreted() - rL);
620 }
621
622 @Test(failOn = ALLOC + STORE + TRAP)
623 public long test27(int i, MyValue2 v, long l) {
624 return v.hash() + i + l;
625 }
626
627 @DontCompile
628 public void test27_verifier(boolean warmup) {
629 MyValue2 v = MyValue2.createInline(rI, true);
630 long result = test27(rI, v, rL);
631 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
632 }
633
634 @Test(failOn = ALLOC + STORE + TRAP)
635 public long test28(long l, MyValue2 v, int i) {
636 return v.hash() + i + l;
637 }
638
639 @DontCompile
640 public void test28_verifier(boolean warmup) {
641 MyValue2 v = MyValue2.createInline(rI, true);
642 long result = test28(rL, v, rI);
643 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
644 }
645
646 @Test(failOn = ALLOC + STORE + TRAP)
647 public long test29(long l, MyValue1 v1, int i, MyValue2 v2) {
648 return v1.hash() + i + l + v2.hash();
649 }
650
651 @DontCompile
652 public void test29_verifier(boolean warmup) {
653 MyValue1 v1 = MyValue1.createDontInline(rI, rL);
654 MyValue2 v2 = MyValue2.createInline(rI, true);
655 long result = test29(rL, v1, rI, v2);
656 Asserts.assertEQ(result, v1.hashInterpreted() + rL + rI + v2.hashInterpreted());
657 }
658
659 // Test compiled code to interpreter with various signatures
660 @DontCompile
661 public long test30_interp(MyValue2 v) {
662 return v.hash();
663 }
664
665 @Test(failOn = ALLOC + STORE + TRAP)
666 public long test30(MyValue2 v) {
667 return test30_interp(v);
668 }
669
670 @DontCompile
671 public void test30_verifier(boolean warmup) {
672 MyValue2 v = MyValue2.createInline(rI, true);
673 long result = test30(v);
674 Asserts.assertEQ(result, v.hashInterpreted());
675 }
676
677 @DontCompile
678 public long test31_interp(int i1, MyValue2 v, int i2) {
679 return v.hash() + i1 - i2;
680 }
681
682 @Test(failOn = ALLOC + STORE + TRAP)
683 public long test31(int i1, MyValue2 v, int i2) {
684 return test31_interp(i1, v, i2);
685 }
686
687 @DontCompile
688 public void test31_verifier(boolean warmup) {
689 MyValue2 v = MyValue2.createInline(rI, true);
690 long result = test31(rI, v, 2*rI);
691 Asserts.assertEQ(result, v.hashInterpreted() - rI);
692 }
693
694 @DontCompile
695 public long test32_interp(long l1, MyValue2 v, long l2) {
696 return v.hash() + l1 - l2;
697 }
698
699 @Test(failOn = ALLOC + STORE + TRAP)
700 public long test32(long l1, MyValue2 v, long l2) {
701 return test32_interp(l1, v, l2);
702 }
703
704 @DontCompile
705 public void test32_verifier(boolean warmup) {
706 MyValue2 v = MyValue2.createInline(rI, true);
707 long result = test32(rL, v, 2*rL);
708 Asserts.assertEQ(result, v.hashInterpreted() - rL);
709 }
710
711 @DontCompile
712 public long test33_interp(int i, MyValue2 v, long l) {
713 return v.hash() + i + l;
714 }
715
716 @Test(failOn = ALLOC + STORE + TRAP)
717 public long test33(int i, MyValue2 v, long l) {
718 return test33_interp(i, v, l);
719 }
720
721 @DontCompile
722 public void test33_verifier(boolean warmup) {
723 MyValue2 v = MyValue2.createInline(rI, true);
724 long result = test33(rI, v, rL);
725 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
726 }
727
728 @DontCompile
729 public long test34_interp(long l, MyValue2 v, int i) {
730 return v.hash() + i + l;
731 }
732
733 @Test(failOn = ALLOC + STORE + TRAP)
734 public long test34(long l, MyValue2 v, int i) {
735 return test34_interp(l, v, i);
736 }
737
738 @DontCompile
739 public void test34_verifier(boolean warmup) {
740 MyValue2 v = MyValue2.createInline(rI, true);
741 long result = test34(rL, v, rI);
742 Asserts.assertEQ(result, v.hashInterpreted() + rL + rI);
743 }
744
745 @DontCompile
746 public long test35_interp(long l, MyValue1 v1, int i, MyValue2 v2) {
747 return v1.hash() + i + l + v2.hash();
748 }
749
750 @Test(failOn = ALLOC + STORE + TRAP)
751 public long test35(long l, MyValue1 v1, int i, MyValue2 v2) {
752 return test35_interp(l, v1, i, v2);
753 }
754
755 @DontCompile
756 public void test35_verifier(boolean warmup) {
757 MyValue1 v1 = MyValue1.createDontInline(rI, rL);
758 MyValue2 v2 = MyValue2.createInline(rI, true);
759 long result = test35(rL, v1, rI, v2);
760 Asserts.assertEQ(result, v1.hashInterpreted() + rL + rI + v2.hashInterpreted());
761 }
762
763 // test that debug info at a call is correct
764 @DontCompile
765 public long test36_interp(MyValue2 v, boolean flag) {
766 if (flag) {
767 // uncommon trap
768 WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test36"));
769 }
770 return v.hash();
771 }
772
773 @Test(failOn = ALLOC + STORE + TRAP)
774 public long test36(MyValue2 v, boolean flag, long l) {
775 return test36_interp(v, flag) + l;
776 }
777
778 @DontCompile
779 public void test36_verifier(boolean warmup) {
780 MyValue2 v = MyValue2.createInline(rI, true);
781 long result = test36(v, false, rL);
782 Asserts.assertEQ(result, v.hashInterpreted() + rL);
783 if (!warmup) {
784 result = test36(v, true, rL);
785 Asserts.assertEQ(result, v.hashInterpreted() + rL);
786 }
787 }
788
789 // Test vbox and vunbox
790 @Test
791 public long test37() throws Throwable {
792 return (long)vccUnboxLoadLongMH.invokeExact(vcc);
793 }
794
795 @DontCompile
796 public void test37_verifier(boolean warmup) {
797 try {
798 long result = test37();
799 Asserts.assertEQ(vcc.t, result, "Field t of input and result must be equal.");
800 } catch (Throwable t) {
801 throw new RuntimeException("test 37 failed", t);
802 }
803 }
804
805 // Generate a MethodHandle that obtains field t of the
806 // derived value type
807 private static MethodHandle generateVCCUnboxLoadLongMH() {
808 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
809 "vccUnboxLoadLong",
810 MethodType.methodType(long.class, ValueCapableClass1.class),
811 CODE -> {
812 CODE.
813 aload_0().
814 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
815 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
816 lreturn();
817 }
818 );
819 }
820
821
822 @Test
823 public int test38() throws Throwable {
824 return (int)vccUnboxLoadIntMH.invokeExact(vcc);
825 }
826
827 @DontCompile
828 public void test38_verifier(boolean warmup) {
829 try {
830 int result = test38();
831 Asserts.assertEQ(vcc.x, result, "Field x of input and result must be equal.");
832 } catch (Throwable t) {
833 throw new RuntimeException("test 38 failed", t);
834 }
835 }
836
837 // Generate a MethodHandle that obtains field x of the
838 // derived value type
839 private static MethodHandle generateVCCUnboxLoadIntMH() {
840 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
841 "vccUnboxLoadInt",
842 MethodType.methodType(int.class, ValueCapableClass1.class),
843 CODE -> {
844 CODE.
845 aload_0().
846 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
847 vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "x", "I").
848 ireturn();
849 }
850 );
851 }
852
853 @Test
854 public ValueCapableClass1 test39() throws Throwable {
855 return (ValueCapableClass1)vccUnboxBoxMH.invokeExact(vcc);
856 }
857
858 @DontCompile
859 public void test39_verifier(boolean warmup) {
860 try {
861 ValueCapableClass1 result = test39();
862 Asserts.assertEQ(vcc.value(), result.value(), "Value of VCC and returned VCC must be equal");
863 } catch (Throwable t) {
864 throw new RuntimeException("test 39 failed", t);
865 }
866 }
867
868 // Generate a MethodHandle that takes a value-capable class,
869 // unboxes it, then boxes it again and returns it.
870 private static MethodHandle generateVCCUnboxBoxMH() {
871 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
872 "vccUnboxBox",
873 MethodType.methodType(ValueCapableClass1.class, ValueCapableClass1.class),
874 CODE -> {
875 CODE.
876 aload_0().
877 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
878 vbox(ValueCapableClass1.class).
879 areturn();
880 }
881 );
882 }
883
884 @Test
885 public int test40() throws Throwable {
886 return (int)vccUnboxBoxLoadIntMH.invokeExact(vcc);
887 }
888
889 @DontCompile
890 public void test40_verifier(boolean warmup) {
891 try {
892 int result = test40();
893 Asserts.assertEQ(vcc.x, result, "Field x of VCC and result must be equal");
894 } catch (Throwable t) {
895 throw new RuntimeException("Test failed in the interpeter", t);
896 }
897 }
898
899 // Generate a MethodHandle that takes a value-capable class,
900 // unboxes it, boxes it, reads a field from it, and returns the
901 // field.
902 private static MethodHandle generateVCCUnboxBoxLoadIntMH() {
903 return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
904 "vccUnboxBoxLoadInt",
905 MethodType.methodType(int.class, ValueCapableClass1.class),
906 CODE -> {
907 CODE.
908 aload_0().
909 vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
910 vbox(ValueCapableClass1.class).
911 getfield(ValueCapableClass1.class, "x", "I").
912 ireturn();
913 }
914 );
915 }
916
917 // ========== Test infrastructure ==========
918
919 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
920 private static final int ValueTypePassFieldsAsArgsOn = 0x1;
921 private static final int ValueTypePassFieldsAsArgsOff = 0x2;
922 static final int AllFlags = ValueTypePassFieldsAsArgsOn | ValueTypePassFieldsAsArgsOff;
923 private static final boolean ValueTypePassFieldsAsArgs = (Boolean)WHITE_BOX.getVMFlag("ValueTypePassFieldsAsArgs");
924 private static final int COMP_LEVEL_ANY = -1;
925 private static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
926 private static final Hashtable<String, Method> tests = new Hashtable<String, Method>();
927 private static final int WARMUP = 250;
928 private static boolean USE_COMPILER = WHITE_BOX.getBooleanVMFlag("UseCompiler");
929 private static boolean PRINT_IDEAL = WHITE_BOX.getBooleanVMFlag("PrintIdeal");
930 // TODO use Platform.isComp() after merge with JDK 9
931 private static boolean XCOMP = System.getProperty("java.vm.info").startsWith("compiled ");
932
933 // Regular expressions used to match nodes in the PrintIdeal output
934 private static final String START = "(\\d+\\t(.*";
935 private static final String MID = ".*)+\\t===.*";
936 private static final String END = ")|";
937 private static final String ALLOC = START + "CallStaticJava" + MID + "_new_instance_Java" + END;
938 private static final String LOAD = START + "Load" + MID + "valuetype\\*" + END;
939 private static final String STORE = START + "Store" + MID + "valuetype\\*" + END;
940 private static final String LOOP = START + "Loop" + MID + "" + END;
941 private static final String TRAP = START + "CallStaticJava" + MID + "uncommon_trap" + END;
942 // TODO: match field values of scalar replaced object
943 private static final String SCOBJ = "(.*# ScObj.*" + END;
944
945 static {
946 // Gather all test methods and put them in Hashtable
947 for (Method m : ValueTypeTestBench.class.getDeclaredMethods()) {
948 Test[] annos = m.getAnnotationsByType(Test.class);
949 if (annos.length != 0) {
950 tests.put("ValueTypeTestBench::" + m.getName(), m);
951 }
952 }
953 }
954
955 private static void execute_vm(String... extra_args) throws Throwable {
956 ArrayList<String> all_args = new ArrayList(List.of(
957 "-noverify",
958 "-XX:+UnlockDiagnosticVMOptions", "-Xbootclasspath/a:.", "-XX:+WhiteBoxAPI",
959 "-XX:-TieredCompilation", "-XX:-BackgroundCompilation",
960 "-XX:+IgnoreUnrecognizedVMOptions", "-XX:+PrintCompilation", "-XX:+PrintIdeal", "-XX:+PrintOptoAssembly",
961 "-XX:CompileCommand=quiet", "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.ValueTypeTestBench::*",
962 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue1::*",
963 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue2::*"
964 ));
965 all_args.addAll(List.of(extra_args));
966 // Run tests in own process and verify output
967 all_args.add(ValueTypeTestBench.class.getName());
968 all_args.add("run");
969 OutputAnalyzer oa = ProcessTools.executeTestJvm(all_args.toArray(new String[0]));
970 // If ideal graph printing is enabled/supported, verify output
971 String output = oa.getOutput();
972 oa.shouldHaveExitValue(0);
973 if (output.contains("PrintIdeal enabled")) {
974 parseOutput(output);
975 } else {
976 System.out.println("WARNING: IR verification disabled! Running with -Xint, -Xcomp or release build?");
977 }
978 }
979
980 public static void main(String[] args) throws Throwable {
981 if (args.length == 0) {
982 String field_as_args;
983 if ((Boolean)WHITE_BOX.getVMFlag("ValueTypePassFieldsAsArgs")) {
984 field_as_args = "-XX:+ValueTypePassFieldsAsArgs";
985 } else {
986 field_as_args = "-XX:-ValueTypePassFieldsAsArgs";
987 }
988 execute_vm("-XX:+UnlockExperimentalVMOptions", field_as_args);
989 execute_vm("-XX:+AlwaysIncrementalInline", "-XX:+UnlockExperimentalVMOptions", field_as_args);
990 } else {
991 if (USE_COMPILER && PRINT_IDEAL && !XCOMP) {
992 System.out.println("PrintIdeal enabled");
993 }
994 // Execute tests
995 ValueTypeTestBench bench = new ValueTypeTestBench();
996 bench.run();
997 }
998 }
999
1000 public static void parseOutput(String output) throws Exception {
1001 String split = "b compiler.valhalla.valuetypes.";
1002 String[] compilations = output.split(split);
1003 // Print header
1004 System.out.println(compilations[0]);
1005 // Iterate over compilation output
1006 for (String graph : compilations) {
1007 String[] lines = graph.split("\\n");
1008 if (lines[0].contains("@")) {
1009 continue; // Ignore OSR compilations
1010 }
1011 String testName = lines[0].split(" ")[0];
1012 Method test = tests.get(testName);
1013 if (test == null) {
1014 // Skip helper methods
1015 continue;
1016 }
1017 if (PRINT_GRAPH) {
1018 System.out.println("\nGraph for " + graph);
1019 }
1020 // Parse graph using regular expressions to determine if it contains forbidden nodes
1021 Test[] annos = test.getAnnotationsByType(Test.class);
1022 Test anno = null;
1023 for (Test a : annos) {
1024 if ((a.valid() & ValueTypePassFieldsAsArgsOn) != 0 && ValueTypePassFieldsAsArgs) {
1025 assert anno == null;
1026 anno = a;
1027 } else if ((a.valid() & ValueTypePassFieldsAsArgsOff) != 0 && !ValueTypePassFieldsAsArgs) {
1028 assert anno == null;
1029 anno = a;
1030 }
1031 }
1032 assert anno != null;
1033 String regexFail = anno.failOn();
1034 if (!regexFail.isEmpty()) {
1035 Pattern pattern = Pattern.compile(regexFail.substring(0, regexFail.length()-1));
1036 Matcher matcher = pattern.matcher(graph);
1037 boolean fail = false;
1038 while (matcher.find()) {
1039 System.out.println("Graph for '" + testName + "' contains forbidden node:");
1040 System.out.println(matcher.group());
1041 fail = true;
1042 }
1043 Asserts.assertFalse(fail, "Graph for '" + testName + "' contains forbidden nodes");
1044 }
1045 String[] regexMatch = anno.match();
1046 int[] matchCount = anno.matchCount();
1047 for (int i = 0; i < regexMatch.length; ++i) {
1048 Pattern pattern = Pattern.compile(regexMatch[i].substring(0, regexMatch[i].length()-1));
1049 Matcher matcher = pattern.matcher(graph);
1050 int count = 0;
1051 String nodes = "";
1052 while (matcher.find()) {
1053 count++;
1054 nodes += matcher.group() + "\n";
1055 }
1056 if (matchCount[i] != count) {
1057 System.out.println("Graph for '" + testName + "' contains different number of match nodes:");
1058 System.out.println(nodes);
1059 }
1060 Asserts.assertEQ(matchCount[i], count, "Graph for '" + testName + "' contains different number of match nodes");
1061 }
1062 tests.remove(testName);
1063 System.out.println(testName + " passed");
1064 }
1065 // Check if all tests were compiled
1066 if (tests.size() != 0) {
1067 for (String name : tests.keySet()) {
1068 System.out.println("Test '" + name + "' not compiled!");
1069 }
1070 throw new RuntimeException("Not all tests were compiled");
1071 }
1072 }
1073
1074 public void setup(Method[] methods) {
1075 for (Method m : methods) {
1076 if (m.isAnnotationPresent(Test.class)) {
1077 // Don't inline tests
1078 WHITE_BOX.testSetDontInlineMethod(m, true);
1079 }
1080 if (m.isAnnotationPresent(DontCompile.class)) {
1081 WHITE_BOX.makeMethodNotCompilable(m, COMP_LEVEL_ANY, true);
1082 WHITE_BOX.makeMethodNotCompilable(m, COMP_LEVEL_ANY, false);
1083 }
1084 if (m.isAnnotationPresent(ForceInline.class)) {
1085 WHITE_BOX.testSetForceInlineMethod(m, true);
1086 } else if (m.isAnnotationPresent(DontInline.class)) {
1087 WHITE_BOX.testSetDontInlineMethod(m, true);
1088 }
1089 }
1090 }
1091
1092 public void run() throws Exception {
1093 System.out.format("rI = %d, rL = %d\n", rI, rL);
1094 setup(this.getClass().getDeclaredMethods());
1095 setup(MyValue1.class.getDeclaredMethods());
1096 setup(MyValue2.class.getDeclaredMethods());
1097
1098 // TODO enable this after JDK 9 merge and verify that it's compiled
1099 //WHITE_BOX.enqueueInitializerForCompilation(this.getClass(), COMP_LEVEL_FULL_OPTIMIZATION);
1100
1101 // Execute tests
1102 for (Method test : tests.values()) {
1103 Method verifier = getClass().getDeclaredMethod(test.getName() + "_verifier", boolean.class);
1104 // Warmup using verifier method
1105 for (int i = 0; i < WARMUP; ++i) {
1106 verifier.invoke(this, true);
1107 }
1108 // Trigger compilation
1109 WHITE_BOX.enqueueMethodForCompilation(test, COMP_LEVEL_FULL_OPTIMIZATION);
1110 Asserts.assertTrue(!USE_COMPILER || WHITE_BOX.isMethodCompiled(test, false), test + " not compiled");
1111 // Check result
1112 verifier.invoke(this, false);
1113 }
1114 }
1115 }
1116
1117 // Mark method as test
1118 @Retention(RetentionPolicy.RUNTIME)
1119 @Repeatable(Tests.class)
1120 @interface Test {
1121 // Regular expression used to match forbidden IR nodes
1122 // in the C2 IR emitted for this test.
1123 String failOn() default "";
1124 // Regular expressions used to match and count IR nodes.
1125 String[] match() default { };
1126 int[] matchCount() default { };
1127 int valid() default ValueTypeTestBench.AllFlags;
1128 }
1129
1130 @Retention(RetentionPolicy.RUNTIME)
1131 @interface Tests {
1132 Test[] value();
1133 }
1134
1135 // Force method inlining during compilation
1136 @Retention(RetentionPolicy.RUNTIME)
1137 @interface ForceInline { }
1138
1139 // Prevent method inlining during compilation
1140 @Retention(RetentionPolicy.RUNTIME)
1141 @interface DontInline { }
1142
1143 // Prevent method compilation
1144 @Retention(RetentionPolicy.RUNTIME)
1145 @interface DontCompile { }