1 /*
2 * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 package compiler.valhalla.valuetypes;
25
26 import java.lang.reflect.Array;
27 import java.lang.reflect.Field;
28 import java.util.Arrays;
29
30 import jdk.test.lib.Asserts;
31 import jdk.internal.misc.Unsafe;
32
33 /*
34 * @test
35 * @summary Test intrinsic support for value types
36 * @library /testlibrary /test/lib /compiler/whitebox /
37 * @modules java.base/jdk.internal.misc
38 * @requires os.simpleArch == "x64"
39 * @compile -XDallowWithFieldOperator TestIntrinsics.java
40 * @run driver ClassFileInstaller sun.hotspot.WhiteBox jdk.test.lib.Platform
41 * @run main/othervm/timeout=120 -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
42 * -XX:+UnlockExperimentalVMOptions -XX:+WhiteBoxAPI -XX:+EnableValhalla
43 * compiler.valhalla.valuetypes.ValueTypeTest
44 * compiler.valhalla.valuetypes.TestIntrinsics
45 */
46 public class TestIntrinsics extends ValueTypeTest {
47 // Extra VM parameters for some test scenarios. See ValueTypeTest.getVMParameters()
48 @Override
49 public String[] getExtraVMParameters(int scenario) {
50 switch (scenario) {
51 case 3: return new String[] {"-XX:-MonomorphicArrayCheck", "-XX:+ValueArrayFlatten"};
52 case 4: return new String[] {"-XX:-MonomorphicArrayCheck"};
53 }
54 return null;
55 }
56
57 public static void main(String[] args) throws Throwable {
58 TestIntrinsics test = new TestIntrinsics();
59 test.run(args, MyValue1.class, MyValue2.class, MyValue2Inline.class);
60 }
61
62 // Test correctness of the Class::isAssignableFrom intrinsic
63 @Test()
64 public boolean test1(Class<?> supercls, Class<?> subcls) {
65 return supercls.isAssignableFrom(subcls);
66 }
67
68 public void test1_verifier(boolean warmup) {
69 Asserts.assertTrue(test1(Object.class, MyValue1.class), "test1_1 failed");
70 Asserts.assertTrue(test1(MyValue1.class, MyValue1.class), "test1_2 failed");
71 Asserts.assertTrue(test1(Object.class, java.util.ArrayList.class), "test1_3 failed");
72 Asserts.assertTrue(test1(java.util.ArrayList.class, java.util.ArrayList.class), "test1_4 failed");
73 }
74
75 // Verify that Class::isAssignableFrom checks with statically known classes are folded
76 @Test(failOn = LOADK)
77 public boolean test2() {
78 boolean check1 = java.util.AbstractList.class.isAssignableFrom(java.util.ArrayList.class);
79 boolean check2 = MyValue1.class.isAssignableFrom(MyValue1.class);
80 boolean check3 = Object.class.isAssignableFrom(java.util.ArrayList.class);
81 boolean check4 = Object.class.isAssignableFrom(MyValue1.class);
82 boolean check5 = !MyValue1.class.isAssignableFrom(Object.class);
83 return check1 && check2 && check3 && check4 && check5;
84 }
85
86 public void test2_verifier(boolean warmup) {
87 Asserts.assertTrue(test2(), "test2 failed");
88 }
89
90 // Test correctness of the Class::getSuperclass intrinsic
91 @Test()
92 public Class<?> test3(Class<?> cls) {
93 return cls.getSuperclass();
94 }
95
96 public void test3_verifier(boolean warmup) {
97 Asserts.assertTrue(test3(Object.class) == null, "test3_1 failed");
98 Asserts.assertTrue(test3(MyValue1.class) == Object.class, "test3_2 failed");
99 Asserts.assertTrue(test3(Class.class) == Object.class, "test3_3 failed");
100 }
101
102 // Verify that Class::getSuperclass checks with statically known classes are folded
103 @Test(failOn = LOADK)
104 public boolean test4() {
105 boolean check1 = Object.class.getSuperclass() == null;
106 boolean check2 = MyValue1.class.getSuperclass() == Object.class;
107 boolean check3 = Class.class.getSuperclass() == Object.class;
108 return check1 && check2 && check3;
109 }
110
111 public void test4_verifier(boolean warmup) {
112 Asserts.assertTrue(test4(), "test4 failed");
113 }
114
115 // Test toString() method
116 @Test()
117 public String test5(MyValue1 v) {
118 return v.toString();
119 }
120
121 @DontCompile
122 public void test5_verifier(boolean warmup) {
123 MyValue1 v = MyValue1.createDefaultInline();
124 test5(v);
125 }
126
127 // Test hashCode() method
128 @Test()
129 public int test6(MyValue1 v) {
130 return v.hashCode();
131 }
132
133 @DontCompile
134 public void test6_verifier(boolean warmup) {
135 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
136 int res = test6(v);
137 Asserts.assertEQ(res, v.hashCode());
138 }
139
140 // Test default value type array creation via reflection
141 @Test()
142 public Object[] test7(Class<?> componentType, int len) {
143 Object[] va = (Object[])Array.newInstance(componentType, len);
144 return va;
145 }
146
147 @DontCompile
148 public void test7_verifier(boolean warmup) {
149 int len = Math.abs(rI) % 42;
150 long hash = MyValue1.createDefaultDontInline().hashPrimitive();
151 Object[] va = test7(MyValue1.class, len);
152 for (int i = 0; i < len; ++i) {
153 Asserts.assertEQ(((MyValue1)va[i]).hashPrimitive(), hash);
154 }
155 }
156
157 // Class.isInstance
158 @Test()
159 public boolean test8(Class c, MyValue1 vt) {
160 return c.isInstance(vt);
161 }
162
163 @DontCompile
164 public void test8_verifier(boolean warmup) {
165 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
166 boolean result = test8(MyValue1.class, vt);
167 Asserts.assertTrue(result);
168 }
169
170 @Test()
171 public boolean test9(Class c, MyValue1 vt) {
172 return c.isInstance(vt);
173 }
174
175 @DontCompile
176 public void test9_verifier(boolean warmup) {
177 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
178 boolean result = test9(MyValue2.class, vt);
179 Asserts.assertFalse(result);
180 }
181
182 // Class.cast
183 @Test()
184 public Object test10(Class c, MyValue1 vt) {
185 return c.cast(vt);
186 }
187
188 @DontCompile
189 public void test10_verifier(boolean warmup) {
190 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
191 Object result = test10(MyValue1.class, vt);
192 Asserts.assertEQ(((MyValue1)result).hash(), vt.hash());
193 }
194
195 @Test()
196 public Object test11(Class c, MyValue1 vt) {
197 return c.cast(vt);
198 }
199
200 @DontCompile
201 public void test11_verifier(boolean warmup) {
202 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
203 try {
204 test11(MyValue2.class, vt);
205 throw new RuntimeException("should have thrown");
206 } catch(ClassCastException cce) {
207 }
208 }
209
210 @Test()
211 public Object test12(MyValue1 vt) {
212 return MyValue1.class.cast(vt);
213 }
214
215 @DontCompile
216 public void test12_verifier(boolean warmup) {
217 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
218 Object result = test12(vt);
219 Asserts.assertEQ(((MyValue1)result).hash(), vt.hash());
220 }
221
222 @Test()
223 public Object test13(MyValue1 vt) {
224 return MyValue2.class.cast(vt);
225 }
226
227 @DontCompile
228 public void test13_verifier(boolean warmup) {
229 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
230 try {
231 test13(vt);
232 throw new RuntimeException("should have thrown");
233 } catch(ClassCastException cce) {
234 }
235 }
236
237 // value type array creation via reflection
238 @Test()
239 public void test14(int len, long hash) {
240 Object[] va = (Object[])Array.newInstance(MyValue1.class, len);
241 for (int i = 0; i < len; ++i) {
242 Asserts.assertEQ(((MyValue1)va[i]).hashPrimitive(), hash);
243 }
244 }
245
246 @DontCompile
247 public void test14_verifier(boolean warmup) {
248 int len = Math.abs(rI) % 42;
249 long hash = MyValue1.createDefaultDontInline().hashPrimitive();
250 test14(len, hash);
251 }
252
253 // Test hashCode() method
254 @Test()
255 public int test15(Object v) {
256 return v.hashCode();
257 }
258
259 @DontCompile
260 public void test15_verifier(boolean warmup) {
261 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
262 int res = test15(v);
263 Asserts.assertEQ(res, v.hashCode());
264 }
265
266 @Test()
267 public int test16(Object v) {
268 return System.identityHashCode(v);
269 }
270
271 @DontCompile
272 public void test16_verifier(boolean warmup) {
273 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
274 int res = test16(v);
275 Asserts.assertEQ(res, System.identityHashCode((Object)v));
276 }
277
278 @Test()
279 public int test17(Object v) {
280 return System.identityHashCode(v);
281 }
282
283 @DontCompile
284 public void test17_verifier(boolean warmup) {
285 Integer v = new Integer(rI);
286 int res = test17(v);
287 Asserts.assertEQ(res, System.identityHashCode(v));
288 }
289
290 @Test()
291 public int test18(Object v) {
292 return System.identityHashCode(v);
293 }
294
295 @DontCompile
296 public void test18_verifier(boolean warmup) {
297 Object v = null;
298 int res = test18(v);
299 Asserts.assertEQ(res, System.identityHashCode(v));
300 }
301
302 // hashCode() and toString() with different value types
303 @Test()
304 public int test19(MyValue1 vt1, MyValue1 vt2, boolean b) {
305 MyValue1 res = b ? vt1 : vt2;
306 return res.hashCode();
307 }
308
309 @DontCompile
310 public void test19_verifier(boolean warmup) {
311 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
312 int res = test19(vt, vt, true);
313 Asserts.assertEQ(res, vt.hashCode());
314 res = test19(vt, vt, false);
315 Asserts.assertEQ(res, vt.hashCode());
316 }
317
318 @Test()
319 public String test20(MyValue1 vt1, MyValue1 vt2, boolean b) {
320 MyValue1 res = b ? vt1 : vt2;
321 return res.toString();
322 }
323
324 @DontCompile
325 public void test20_verifier(boolean warmup) {
326 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
327 String res = test20(vt, vt, true);
328 Asserts.assertEQ(res, vt.toString());
329 res = test20(vt, vt, false);
330 Asserts.assertEQ(res, vt.toString());
331 }
332
333 private static final Unsafe U = Unsafe.getUnsafe();
334 private static final long X_OFFSET;
335 private static final long Y_OFFSET;
336 private static final long V1_OFFSET;
337 private static final boolean V1_FLATTENED;
338 static {
339 try {
340 Field xField = MyValue1.class.getDeclaredField("x");
341 X_OFFSET = U.objectFieldOffset(xField);
342 Field yField = MyValue1.class.getDeclaredField("y");
343 Y_OFFSET = U.objectFieldOffset(yField);
344 Field v1Field = MyValue1.class.getDeclaredField("v1");
345 V1_OFFSET = U.objectFieldOffset(v1Field);
346 V1_FLATTENED = U.isFlattened(v1Field);
347 } catch (Exception e) {
348 throw new RuntimeException(e);
349 }
350 }
351
352 protected static final String CALL_Unsafe = START + "CallStaticJava" + MID + "# Static jdk.internal.misc.Unsafe::" + END;
353
354 @Test(failOn=CALL_Unsafe)
355 public int test21(MyValue1 v) {
356 return U.getInt(v, X_OFFSET);
357 }
358
359 @DontCompile
360 public void test21_verifier(boolean warmup) {
361 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
362 int res = test21(v);
363 Asserts.assertEQ(res, v.x);
364 }
365
366 MyValue1.val test22_vt;
367 @Test(failOn=CALL_Unsafe + ALLOC)
368 public void test22(MyValue1 v) {
369 v = U.makePrivateBuffer(v);
370 U.putInt(v, X_OFFSET, rI);
371 v = U.finishPrivateBuffer(v);
372 test22_vt = v;
373 }
374
375 @DontCompile
376 public void test22_verifier(boolean warmup) {
377 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
378 test22(v.setX(v, 0));
379 Asserts.assertEQ(test22_vt.hash(), v.hash());
380 }
381
382 @Test(failOn=CALL_Unsafe)
383 public int test23(MyValue1 v, long offset) {
384 return U.getInt(v, offset);
385 }
386
387 @DontCompile
388 public void test23_verifier(boolean warmup) {
389 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
390 int res = test23(v, X_OFFSET);
391 Asserts.assertEQ(res, v.x);
392 }
393
394 MyValue1.val test24_vt = MyValue1.createWithFieldsInline(rI, rL);
395
396 @Test(failOn=CALL_Unsafe)
397 public int test24(long offset) {
398 return U.getInt(test24_vt, offset);
399 }
400
401 @DontCompile
402 public void test24_verifier(boolean warmup) {
403 int res = test24(X_OFFSET);
404 Asserts.assertEQ(res, test24_vt.x);
405 }
406
407 // Test copyOf intrinsic with allocated value type in it's debug information
408 value final class Test25Value {
409 final int x;
410 public Test25Value() {
411 this.x = 42;
412 }
413 }
414
415 final Test25Value[] test25Array = new Test25Value[10];
416
417 @Test
418 public Test25Value[] test25(Test25Value element) {
419 Test25Value[] newArray = Arrays.copyOf(test25Array, test25Array.length + 1);
420 newArray[test25Array.length] = element;
421 return newArray;
422 }
423
424 @DontCompile
425 public void test25_verifier(boolean warmup) {
426 Test25Value vt = new Test25Value();
427 test25(vt);
428 }
429
430 @Test
431 public Object test26() {
432 Class<?>[] ca = new Class<?>[1];
433 for (int i = 0; i < 1; ++i) {
434 // Folds during loop opts
435 ca[i] = MyValue1.class;
436 }
437 return Array.newInstance(ca[0], 1);
438 }
439
440 @DontCompile
441 public void test26_verifier(boolean warmup) {
442 Object[] res = (Object[])test26();
443 Asserts.assertEQ(((MyValue1)res[0]).hashPrimitive(), MyValue1.createDefaultInline().hashPrimitive());
444 }
445
446 // Load non-flattenable value type field with unsafe
447 MyValue1.box test27_vt = MyValue1.createWithFieldsInline(rI, rL);
448 private static final long TEST27_OFFSET;
449 static {
450 try {
451 Field field = TestIntrinsics.class.getDeclaredField("test27_vt");
452 TEST27_OFFSET = U.objectFieldOffset(field);
453 } catch (Exception e) {
454 throw new RuntimeException(e);
455 }
456 }
457
458 @Test(failOn=CALL_Unsafe)
459 public MyValue1 test27() {
460 return (MyValue1)U.getReference(this, TEST27_OFFSET);
461 }
462
463 @DontCompile
464 public void test27_verifier(boolean warmup) {
465 MyValue1 res = test27();
466 Asserts.assertEQ(res.hash(), test24_vt.hash());
467 }
468
469 // Mismatched type
470 @Test(failOn=CALL_Unsafe)
471 public int test28(MyValue1 v) {
472 return U.getByte(v, X_OFFSET);
473 }
474
475 @DontCompile
476 public void test28_verifier(boolean warmup) {
477 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
478 int res = test28(v);
479 if (java.nio.ByteOrder.nativeOrder() == java.nio.ByteOrder.LITTLE_ENDIAN) {
480 Asserts.assertEQ(res, (int)((byte)v.x));
481 } else {
482 Asserts.assertEQ(res, (int)((byte)Integer.reverseBytes(v.x)));
483 }
484 }
485
486 // Wrong alignment
487 @Test(failOn=CALL_Unsafe)
488 public long test29(MyValue1 v) {
489 // Read the field that's guaranteed to not be last in the
490 // value so we don't read out of the value
491 if (X_OFFSET < Y_OFFSET) {
492 return U.getInt(v, X_OFFSET+1);
493 }
494 return U.getLong(v, Y_OFFSET+1);
495 }
496
497 @DontCompile
498 public void test29_verifier(boolean warmup) {
499 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
500 long res = test29(v);
501 if (java.nio.ByteOrder.nativeOrder() == java.nio.ByteOrder.LITTLE_ENDIAN) {
502 if (X_OFFSET < Y_OFFSET) {
503 Asserts.assertEQ(((int)res) << 8, (v.x >> 8) << 8);
504 } else {
505 Asserts.assertEQ(res << 8, (v.y >> 8) << 8);
506 }
507 } else {
508 if (X_OFFSET < Y_OFFSET) {
509 Asserts.assertEQ(((int)res), v.x >>> 8);
510 } else {
511 Asserts.assertEQ(res, v.y >>> 8);
512 }
513 }
514 }
515
516 // getValue to retrieve flattened field from value
517 @Test(failOn=CALL_Unsafe)
518 public MyValue2 test30(MyValue1 v) {
519 if (V1_FLATTENED) {
520 return U.getValue(v, V1_OFFSET, MyValue2.class);
521 }
522 return (MyValue2)U.getReference(v, V1_OFFSET);
523 }
524
525 @DontCompile
526 public void test30_verifier(boolean warmup) {
527 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
528 MyValue2 res = test30(v);
529 Asserts.assertEQ(res.hash(), v.v1.hash());
530 }
531
532 MyValue1.val test31_vt;
533 private static final long TEST31_VT_OFFSET;
534 private static final boolean TEST31_VT_FLATTENED;
535 static {
536 try {
537 Field test31_vt_Field = TestIntrinsics.class.getDeclaredField("test31_vt");
538 TEST31_VT_OFFSET = U.objectFieldOffset(test31_vt_Field);
539 TEST31_VT_FLATTENED = U.isFlattened(test31_vt_Field);
540 } catch (Exception e) {
541 throw new RuntimeException(e);
542 }
543 }
544
545 // getValue to retrieve flattened field from object
546 @Test(failOn=CALL_Unsafe)
547 public MyValue1 test31() {
548 if (TEST31_VT_FLATTENED) {
549 return U.getValue(this, TEST31_VT_OFFSET, MyValue1.class);
550 }
551 return (MyValue1)U.getReference(this, TEST31_VT_OFFSET);
552 }
553
554 @DontCompile
555 public void test31_verifier(boolean warmup) {
556 test31_vt = MyValue1.createWithFieldsInline(rI, rL);
557 MyValue1 res = test31();
558 Asserts.assertEQ(res.hash(), test31_vt.hash());
559 }
560
561 // putValue to set flattened field in object
562 @Test(failOn=CALL_Unsafe)
563 public void test32(MyValue1 vt) {
564 if (TEST31_VT_FLATTENED) {
565 U.putValue(this, TEST31_VT_OFFSET, MyValue1.class, vt);
566 } else {
567 U.putReference(this, TEST31_VT_OFFSET, vt);
568 }
569 }
570
571 @DontCompile
572 public void test32_verifier(boolean warmup) {
573 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
574 test31_vt = MyValue1.createDefaultInline();
575 test32(vt);
576 Asserts.assertEQ(vt.hash(), test31_vt.hash());
577 }
578
579 private static final int TEST33_BASE_OFFSET;
580 private static final int TEST33_INDEX_SCALE;
581 private static final boolean TEST33_FLATTENED_ARRAY;
582 static {
583 try {
584 TEST33_BASE_OFFSET = U.arrayBaseOffset(MyValue1[].class);
585 TEST33_INDEX_SCALE = U.arrayIndexScale(MyValue1[].class);
586 TEST33_FLATTENED_ARRAY = U.isFlattenedArray(MyValue1[].class);
587 } catch (Exception e) {
588 throw new RuntimeException(e);
589 }
590 }
591 // getValue to retrieve flattened field from array
592 @Test(failOn=CALL_Unsafe)
593 public MyValue1 test33(MyValue1[] arr) {
594 if (TEST33_FLATTENED_ARRAY) {
595 return U.getValue(arr, TEST33_BASE_OFFSET + TEST33_INDEX_SCALE, MyValue1.class);
596 }
597 return (MyValue1)U.getReference(arr, TEST33_BASE_OFFSET + TEST33_INDEX_SCALE);
598 }
599
600 @DontCompile
601 public void test33_verifier(boolean warmup) {
602 MyValue1[] arr = new MyValue1[2];
603 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
604 arr[1] = vt;
605 MyValue1 res = test33(arr);
606 Asserts.assertEQ(res.hash(), vt.hash());
607 }
608
609 // putValue to set flattened field in array
610 @Test(failOn=CALL_Unsafe)
611 public void test34(MyValue1[] arr, MyValue1 vt) {
612 if (TEST33_FLATTENED_ARRAY) {
613 U.putValue(arr, TEST33_BASE_OFFSET + TEST33_INDEX_SCALE, MyValue1.class, vt);
614 } else {
615 U.putReference(arr, TEST33_BASE_OFFSET + TEST33_INDEX_SCALE, vt);
616 }
617 }
618
619 @DontCompile
620 public void test34_verifier(boolean warmup) {
621 MyValue1[] arr = new MyValue1[2];
622 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
623 test34(arr, vt);
624 Asserts.assertEQ(arr[1].hash(), vt.hash());
625 }
626
627 // getValue to retrieve flattened field from object with unknown
628 // container type
629 @Test(failOn=CALL_Unsafe)
630 public MyValue1 test35(Object o) {
631 if (TEST31_VT_FLATTENED) {
632 return U.getValue(o, TEST31_VT_OFFSET, MyValue1.class);
633 }
634 return (MyValue1)U.getReference(o, TEST31_VT_OFFSET);
635 }
636
637 @DontCompile
638 public void test35_verifier(boolean warmup) {
639 test31_vt = MyValue1.createWithFieldsInline(rI, rL);
640 MyValue1 res = test35(this);
641 Asserts.assertEQ(res.hash(), test31_vt.hash());
642 }
643
644 // getValue to retrieve flattened field from object at unknown
645 // offset
646 @Test(failOn=CALL_Unsafe)
647 public MyValue1 test36(long offset) {
648 if (TEST31_VT_FLATTENED) {
649 return U.getValue(this, offset, MyValue1.class);
650 }
651 return (MyValue1)U.getReference(this, offset);
652 }
653
654 @DontCompile
655 public void test36_verifier(boolean warmup) {
656 test31_vt = MyValue1.createWithFieldsInline(rI, rL);
657 MyValue1 res = test36(TEST31_VT_OFFSET);
658 Asserts.assertEQ(res.hash(), test31_vt.hash());
659 }
660
661 // putValue to set flattened field in object with unknown
662 // container
663 @Test(failOn=CALL_Unsafe)
664 public void test37(Object o, MyValue1 vt) {
665 if (TEST31_VT_FLATTENED) {
666 U.putValue(o, TEST31_VT_OFFSET, MyValue1.class, vt);
667 } else {
668 U.putReference(o, TEST31_VT_OFFSET, vt);
669 }
670 }
671
672 @DontCompile
673 public void test37_verifier(boolean warmup) {
674 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
675 test31_vt = MyValue1.createDefaultInline();
676 test37(this, vt);
677 Asserts.assertEQ(vt.hash(), test31_vt.hash());
678 }
679
680 // putValue to set flattened field in object, non value argument
681 // to store
682 @Test(match = { CALL_Unsafe }, matchCount = { 1 })
683 public void test38(Object o) {
684 if (TEST31_VT_FLATTENED) {
685 U.putValue(this, TEST31_VT_OFFSET, MyValue1.class, o);
686 } else {
687 U.putReference(this, TEST31_VT_OFFSET, o);
688 }
689 }
690
691 @DontCompile
692 public void test38_verifier(boolean warmup) {
693 MyValue1 vt = MyValue1.createWithFieldsInline(rI, rL);
694 test31_vt = MyValue1.createDefaultInline();
695 test38(vt);
696 Asserts.assertEQ(vt.hash(), test31_vt.hash());
697 }
698
699 @Test(failOn=CALL_Unsafe)
700 public MyValue1 test39(MyValue1 v) {
701 v = U.makePrivateBuffer(v);
702 U.putInt(v, X_OFFSET, rI);
703 v = U.finishPrivateBuffer(v);
704 return v;
705 }
706
707 @DontCompile
708 public void test39_verifier(boolean warmup) {
709 MyValue1 v = MyValue1.createWithFieldsInline(rI, rL);
710 MyValue1 res = test39(v.setX(v, 0));
711 Asserts.assertEQ(res.hash(), v.hash());
712 }
713 }