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:ValueArrayElemMaxFlatSize=-1"};
  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 }