8287801: Fix test-bugs related to stress flags

test/hotspot/jtreg/compiler/arraycopy/TestArrayCopyNoInitDeopt.java

@@ -34,6 +34,7 @@
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement -XX:TypeProfileLevel=020
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodSpecTrapLimit=5000 -XX:PerMethodTrapLimit=100
  *                   compiler.arraycopy.TestArrayCopyNoInitDeopt
  */
 

test/hotspot/jtreg/compiler/c2/cr7200264/TestDriver.java

@@ -49,6 +49,8 @@ private List<String> executeApplication() throws Throwable {
             "-XX:-TieredCompilation",
             "-XX:+PrintCompilation",
             "-XX:+TraceNewVectors",
+            "-XX:+IgnoreUnrecognizedVMOptions",
+            "-XX:StressLongCountedLoop=0", // make sure int loops do not get converted to long
             TestIntVect.class.getName());
         outputAnalyzer.shouldHaveExitValue(0);
         return outputAnalyzer.asLines();

test/hotspot/jtreg/compiler/c2/cr7200264/TestSSE2IntVect.java

@@ -28,7 +28,8 @@
  * @requires vm.cpu.features ~= ".*sse2.*" & vm.debug & vm.flavor == "server"
  * @requires !vm.emulatedClient & !vm.graal.enabled
  * @library /test/lib /
- * @run driver compiler.c2.cr7200264.TestSSE2IntVect
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:StressLongCountedLoop=0
+ *                   compiler.c2.cr7200264.TestSSE2IntVect
  */
 
 package compiler.c2.cr7200264;

test/hotspot/jtreg/compiler/c2/cr7200264/TestSSE4IntVect.java

@@ -28,7 +28,8 @@
  * @requires vm.cpu.features ~= ".*sse4\\.1.*" & vm.debug & vm.flavor == "server"
  * @requires !vm.emulatedClient & !vm.graal.enabled
  * @library /test/lib /
- * @run driver compiler.c2.cr7200264.TestSSE4IntVect
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:StressLongCountedLoop=0
+ *                   compiler.c2.cr7200264.TestSSE4IntVect
  */
 
 package compiler.c2.cr7200264;

test/hotspot/jtreg/compiler/c2/irTests/blackhole/BlackholeStoreStoreEATest.java

@@ -39,6 +39,7 @@ public class BlackholeStoreStoreEATest {
 
     public static void main(String[] args) {
         TestFramework.runWithFlags(
+            "-XX:+UseTLAB",
             "-XX:+UnlockExperimentalVMOptions",
             "-XX:CompileCommand=blackhole,compiler.c2.irTests.blackhole.BlackholeStoreStoreEATest::blackhole"
         );

test/hotspot/jtreg/compiler/cha/AbstractRootMethod.java

@@ -38,6 +38,7 @@
  *                   -XX:CompileCommand=compileonly,*::test -XX:CompileCommand=dontinline,*::test
  *                   -Xbatch -Xmixed -XX:+WhiteBoxAPI
  *                   -XX:-TieredCompilation
+ *                   -XX:-StressMethodHandleLinkerInlining
  *                      compiler.cha.AbstractRootMethod
  *
  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
@@ -46,6 +47,7 @@
  *                   -XX:CompileCommand=compileonly,*::test -XX:CompileCommand=dontinline,*::test
  *                   -Xbatch -Xmixed -XX:+WhiteBoxAPI
  *                   -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ *                   -XX:-StressMethodHandleLinkerInlining
  *                      compiler.cha.AbstractRootMethod
  */
 package compiler.cha;

test/hotspot/jtreg/compiler/cha/DefaultRootMethod.java

@@ -38,6 +38,7 @@
  *                   -XX:CompileCommand=compileonly,*::test -XX:CompileCommand=dontinline,*::test
  *                   -Xbatch -Xmixed -XX:+WhiteBoxAPI
  *                   -XX:-TieredCompilation
+ *                   -XX:-StressMethodHandleLinkerInlining
  *                      compiler.cha.DefaultRootMethod
  *
  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
@@ -46,6 +47,7 @@
  *                   -XX:CompileCommand=compileonly,*::test -XX:CompileCommand=dontinline,*::test
  *                   -Xbatch -Xmixed -XX:+WhiteBoxAPI
  *                   -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ *                   -XX:-StressMethodHandleLinkerInlining
  *                      compiler.cha.DefaultRootMethod
  */
 package compiler.cha;

test/hotspot/jtreg/compiler/intrinsics/klass/CastNullCheckDroppingsTest.java

@@ -35,6 +35,8 @@
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  *                   -Xmixed -XX:-BackgroundCompilation -XX:-TieredCompilation -XX:CompileThreshold=1000
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100 -XX:-StressReflectiveCode
+ *                   -XX:+UncommonNullCast -XX:-StressMethodHandleLinkerInlining -XX:TypeProfileLevel=0
  *                   -XX:CompileCommand=exclude,compiler.intrinsics.klass.CastNullCheckDroppingsTest::runTest
  *                   compiler.intrinsics.klass.CastNullCheckDroppingsTest
  */
@@ -356,7 +358,7 @@ static void checkDeoptimization(List<RecordedEvent> events, int compilerId, bool
         if (exist != mustExist) {
             System.err.println("events:");
             System.err.println(events);
-            throw new AssertionError("compilation must " + (mustExist ? "" : " not ") + " got deoptimized");
+            throw new AssertionError("compilation must " + (mustExist ? "" : " not ") + " get deoptimized");
         }
 
         if (mustExist && events.stream()

test/hotspot/jtreg/compiler/jvmci/compilerToVM/IsMatureVsReprofileTest.java

@@ -40,6 +40,7 @@
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
  *     -XX:+WhiteBoxAPI -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -Xbatch -XX:CompileThresholdScaling=1.0
+ *     -XX:CompileCommand=dontinline,compiler.jvmci.common.testcases.SimpleClass::testMethod
  *     compiler.jvmci.compilerToVM.IsMatureVsReprofileTest
  */
 

test/hotspot/jtreg/compiler/jvmci/compilerToVM/ReprofileTest.java

@@ -40,6 +40,7 @@
  *                   -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  *                   -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI
  *                   -Xmixed -Xbatch
+ *                   -XX:TypeProfileLevel=0
  *                   compiler.jvmci.compilerToVM.ReprofileTest
  */
 

test/hotspot/jtreg/compiler/profiling/TestTypeProfiling.java

@@ -39,11 +39,13 @@
   *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement
   *                   -XX:CompileThreshold=10000
   *                   -server -XX:-TieredCompilation -XX:TypeProfileLevel=020
+  *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodSpecTrapLimit=5000 -XX:PerMethodTrapLimit=100
   *                    compiler.profiling.TestTypeProfiling
   * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
   *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement
   *                   -XX:CompileThreshold=10000
   *                   -server -XX:-TieredCompilation -XX:TypeProfileLevel=200
+  *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodSpecTrapLimit=5000 -XX:PerMethodTrapLimit=100
   *                    compiler.profiling.TestTypeProfiling
   */
 

test/hotspot/jtreg/compiler/rangechecks/TestExplicitRangeChecks.java

@@ -31,6 +31,7 @@
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -ea -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodSpecTrapLimit=5000 -XX:PerMethodTrapLimit=100
  *                   -XX:CompileCommand=compileonly,compiler.rangechecks.TestExplicitRangeChecks::test*
  *                   compiler.rangechecks.TestExplicitRangeChecks
  *

test/hotspot/jtreg/compiler/rangechecks/TestRangeCheckSmearing.java

@@ -28,8 +28,9 @@
  * @library /test/lib /
  * @modules java.base/jdk.internal.misc
  *          java.management
- * @build jdk.test.whitebox.WhiteBox
- * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
+ * @build sun.hotspot.WhiteBox
+ * @requires vm.flavor == "server" & (vm.opt.TieredStopAtLevel == null | vm.opt.TieredStopAtLevel == 4)
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller sun.hotspot.WhiteBox
  * @run main/othervm -ea -Xmixed -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
  *                   -XX:-BackgroundCompilation -XX:-UseOnStackReplacement
  *                   -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+EagerJVMCI

test/hotspot/jtreg/compiler/uncommontrap/Decompile.java

@@ -0,0 +1,170 @@
+/*
+ * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+ * @test
+ * @bug 8275908
+ * @summary Quick test for the new WhiteBox methods of JDK-8275908
+ *
+ * @requires vm.compiler2.enabled & vm.compMode != "Xcomp"
+ * @requires vm.opt.DeoptimizeALot != true
+ *
+ * @library /test/lib
+ * @build jdk.test.whitebox.WhiteBox
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
+ *                   -Xbatch -XX:-UseOnStackReplacement -XX:-TieredCompilation
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100 -XX:PerBytecodeTrapLimit=4
+ *                   -XX:TypeProfileLevel=0
+ *                   -XX:CompileCommand=compileonly,compiler.uncommontrap.Decompile::uncommonTrap
+ *                   -XX:CompileCommand=inline,compiler.uncommontrap.Decompile*::foo
+ *                   compiler.uncommontrap.Decompile
+ */
+
+package compiler.uncommontrap;
+
+import java.lang.reflect.Method;
+
+import jdk.test.lib.Asserts;
+import jdk.test.whitebox.WhiteBox;
+
+public class Decompile {
+
+    private static final WhiteBox WB = WhiteBox.getWhiteBox();
+    // The number of deoptimizations after which a method will be made not-entrant
+    private static final int PerBytecodeTrapLimit = WB.getIntxVMFlag("PerBytecodeTrapLimit").intValue();
+    // The number of interpreter invocations after which a decompiled method will be re-compiled.
+    private static final int Tier0InvokeNotifyFreq = (int)Math.pow(2, WB.getIntxVMFlag("Tier0InvokeNotifyFreqLog"));
+    // VM builds without JVMCI like x86_32 call the bimorphic inlining trap just 'bimorphic'
+    // while all the other builds with JVMCI call it 'bimorphic_or_optimized_type_check'.
+    // Only builds with JVMCI have the "EnableJVMCI" flag.
+    private static final boolean isJVMCISupported = (WB.getBooleanVMFlag("EnableJVMCI") != null);
+    private static final String bimorphicTrapName = isJVMCISupported ? "bimorphic_or_optimized_type_check" : "bimorphic";
+
+    static class Base {
+        void foo() {}
+    }
+    static class X extends Base {
+        void foo() {}
+    }
+    static class Y extends Base {
+        void foo() {}
+    }
+
+    static void uncommonTrap(Base t) {
+        t.foo();
+    }
+
+    private static void printCounters(Method uncommonTrap_m, int invocations) {
+        System.out.println("-----------------------------------------------------------------");
+        System.out.println("invocations=" + invocations + " " +
+                           "method compiled=" + WB.isMethodCompiled(uncommonTrap_m) + " " +
+                           "decompileCount=" + WB.getMethodDecompileCount(uncommonTrap_m) + "\n" +
+                           "trapCount=" + WB.getMethodTrapCount(uncommonTrap_m) + " " +
+                           "trapCount(class_check)=" + WB.getMethodTrapCount(uncommonTrap_m, "class_check") + " " +
+                           "trapCount(" + bimorphicTrapName + ")=" +
+                           WB.getMethodTrapCount(uncommonTrap_m, bimorphicTrapName) + "\n" +
+                           "globalDeoptCount=" + WB.getDeoptCount() + " " +
+                           "globalDeoptCount(class_check)=" + WB.getDeoptCount("class_check", null) + " " +
+                           "globalDeoptCount(" + bimorphicTrapName + ")=" +
+                           WB.getDeoptCount(bimorphicTrapName, null));
+        System.out.println("-----------------------------------------------------------------");
+    }
+
+    private static void check(Method uncommonTrap_m, int invocations, boolean isCompiled, int decompileCount,
+                              int trapCount, int trapCountClassCheck, int trapCountBimorphic,
+                              int deoptCount, int deoptCountClassCheck, int deoptCountBimorphic) {
+
+        printCounters(uncommonTrap_m, invocations);
+
+        Asserts.assertEQ(isCompiled, WB.isMethodCompiled(uncommonTrap_m),
+                         "Wrong compilation status.");
+        Asserts.assertEQ(decompileCount, WB.getMethodDecompileCount(uncommonTrap_m),
+                         "Wrong number of decompilations.");
+        Asserts.assertEQ(trapCount, WB.getMethodTrapCount(uncommonTrap_m),
+                         "Wrong number of traps.");
+        Asserts.assertEQ(trapCountClassCheck, WB.getMethodTrapCount(uncommonTrap_m, "class_check"),
+                         "Wrong number of traps.");
+        Asserts.assertEQ(trapCountBimorphic, WB.getMethodTrapCount(uncommonTrap_m, bimorphicTrapName),
+                         "Wrong number of traps.");
+        Asserts.assertEQ(deoptCount, WB.getDeoptCount(),
+                         "Wrong number of deoptimizations.");
+        Asserts.assertEQ(deoptCountClassCheck, WB.getDeoptCount("class_check", null),
+                         "Wrong number of class_check deoptimizations.");
+        Asserts.assertEQ(deoptCountBimorphic, WB.getDeoptCount(bimorphicTrapName, null),
+                         "Wrong number of " + bimorphicTrapName + "deoptimizations.");
+    }
+    public static void main(String[] args) throws Exception {
+
+        // Get a handle of the test method for usage with the WhiteBox API.
+        Method uncommonTrap_m = Decompile.class
+            .getDeclaredMethod("uncommonTrap", new Class[] { Base.class });
+
+        int invocations = 0;
+        Base b = new Base();
+        // This is a little tricky :) We have to define 'x' already here otherwise
+        // the class 'X' won't be loaded and 'uncommonTrap()' will be compiled without
+        // a class check but a CHA dependency that class 'B' has no subtypes.
+        X x = new X();
+        Y y = new Y();
+
+        // Warmup and compile with an object of type 'Base' as receiver, but don't invoke compiled code.
+        while(!WB.isMethodCompiled(uncommonTrap_m)) {
+            invocations++;
+            uncommonTrap(b);
+        }
+        check(uncommonTrap_m, invocations, true /* is_compiled */, 0 /* decompileCount */,
+              0 /* trapCount  */, 0 /* trapCountClassCheck  */, 0 /* trapCountBimorphic  */,
+              0 /* deoptCount */, 0 /* deoptCountClassCheck */, 0 /* deoptCountBimorphic */);
+
+        // Invoke compiled code 'PerBytecodeTrapLimit' times with an receiver object of type 'X'.
+        // This should deoptimize 'PerBytecodeTrapLimit' times and finally decompile the method.
+        for (int i = 0; i < PerBytecodeTrapLimit; i++) {
+            invocations++;
+            uncommonTrap(x);
+        }
+        check(uncommonTrap_m, invocations, false /* is_compiled */, 1 /* decompileCount */,
+              PerBytecodeTrapLimit /* trapCount  */, PerBytecodeTrapLimit /* trapCountClassCheck  */, 0 /* trapCountBimorphic  */,
+              PerBytecodeTrapLimit /* deoptCount */, PerBytecodeTrapLimit /* deoptCountClassCheck */, 0 /* deoptCountBimorphic */);
+
+        // Invoke the method 'Tier0InvokeNotifyFreq' more times with an receiver object of type 'X'.
+        // This should re-compile the method again with bimorphic inlining for receiver types 'Base' and 'X'.
+        for (int i = 0; i < Tier0InvokeNotifyFreq; i++) {
+            invocations++;
+            uncommonTrap(x);
+        }
+        check(uncommonTrap_m, invocations, true /* is_compiled */, 1 /* decompileCount */,
+              PerBytecodeTrapLimit /* trapCount  */, PerBytecodeTrapLimit /* trapCountClassCheck  */, 0 /* trapCountBimorphic  */,
+              PerBytecodeTrapLimit /* deoptCount */, PerBytecodeTrapLimit /* deoptCountClassCheck */, 0 /* deoptCountBimorphic */);
+
+        // Invoke compiled code 'PerBytecodeTrapLimit' times with an receiver object of type 'Y'.
+        // This should deoptimize 'PerBytecodeTrapLimit' times and finally decompile the method.
+        for (int i = 0; i < PerBytecodeTrapLimit; i++) {
+            invocations++;
+            uncommonTrap(y);
+        }
+        check(uncommonTrap_m, invocations, false /* is_compiled */, 2 /* decompileCount */,
+              2*PerBytecodeTrapLimit /* trapCount  */, PerBytecodeTrapLimit /* trapCountClassCheck  */, PerBytecodeTrapLimit /* trapCountBimorphic  */,
+              2*PerBytecodeTrapLimit /* deoptCount */, PerBytecodeTrapLimit /* deoptCountClassCheck */, PerBytecodeTrapLimit /* deoptCountBimorphic */);
+    }
+}

test/hotspot/jtreg/compiler/uncommontrap/TestUnstableIfTrap.java

@@ -35,21 +35,25 @@
  * @build jdk.test.whitebox.WhiteBox
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100
  *                   -XX:+WhiteBoxAPI -XX:+LogCompilation
  *                   -XX:CompileCommand=compileonly,UnstableIfExecutable.test
  *                   -XX:LogFile=always_taken_not_fired.xml
  *                   compiler.uncommontrap.TestUnstableIfTrap ALWAYS_TAKEN false
  * @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100
  *                   -XX:+WhiteBoxAPI -XX:+LogCompilation
  *                   -XX:CompileCommand=compileonly,UnstableIfExecutable.test
  *                   -XX:LogFile=always_taken_fired.xml
  *                   compiler.uncommontrap.TestUnstableIfTrap ALWAYS_TAKEN true
  * @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100
  *                   -XX:+WhiteBoxAPI -XX:+LogCompilation
  *                   -XX:CompileCommand=compileonly,UnstableIfExecutable.test
  *                   -XX:LogFile=never_taken_not_fired.xml
  *                   compiler.uncommontrap.TestUnstableIfTrap NEVER_TAKEN false
  * @run main/othervm -Xbatch -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
+ *                   -XX:+UnlockExperimentalVMOptions -XX:PerMethodTrapLimit=100
  *                   -XX:+WhiteBoxAPI -XX:+LogCompilation
  *                   -XX:CompileCommand=compileonly,UnstableIfExecutable.test
  *                   -XX:LogFile=never_taken_fired.xml