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