8241492: Strip mining not working for test/hotspot/jtreg/compiler/c2/…

…Test6850611.java

Reviewed-by: mdoerr, thartmann, neliasso

src/hotspot/share/opto/loopnode.cpp

@@ -38,6 +38,7 @@
 #include "opto/divnode.hpp"
 #include "opto/idealGraphPrinter.hpp"
 #include "opto/loopnode.hpp"
+#include "opto/movenode.hpp"
 #include "opto/mulnode.hpp"
 #include "opto/rootnode.hpp"
 #include "opto/superword.hpp"
@@ -1589,7 +1590,13 @@ void OuterStripMinedLoopNode::adjust_strip_mined_loop(PhaseIterGVN* igvn) {
     } else {
       sub = igvn->transform(new SubINode(iv_phi, limit));
     }
-    Node* min = igvn->transform(new MinINode(sub, igvn->intcon(scaled_iters)));
+    // sub is positive and can be larger than the max signed int
+    // value. Use an unsigned min.
+    Node* const_iters = igvn->intcon(scaled_iters);
+    Node* cmp = igvn->transform(new CmpUNode(sub, const_iters));
+    Node* bol = igvn->transform(new BoolNode(cmp, BoolTest::lt));
+    Node* min = igvn->transform(new CMoveINode(bol, const_iters, sub, TypeInt::make(0, scaled_iters, Type::WidenMin)));
+
     Node* new_limit = NULL;
     if (stride > 0) {
       new_limit = igvn->transform(new AddINode(min, iv_phi));

test/hotspot/jtreg/compiler/loopstripmining/CheckLoopStripMining.java

@@ -23,7 +23,7 @@
 
 /**
  * @test
- * @bug 8220374
+ * @bug 8220374 8241492
  * @summary C2: LoopStripMining doesn't strip as expected
  * @requires vm.compiler2.enabled
  *
@@ -37,40 +37,75 @@
 import jdk.test.lib.process.ProcessTools;
 
 public class CheckLoopStripMining {
-  public static void main(String args[]) throws Exception {
-    ProcessTools.executeTestJvm(
-        "-XX:+UnlockDiagnosticVMOptions",
-        // to prevent biased locking handshakes from changing the timing of this test
-        "-XX:-UseBiasedLocking",
-        "-XX:+SafepointTimeout",
-        "-XX:+SafepointALot",
-        "-XX:+AbortVMOnSafepointTimeout",
-        "-XX:SafepointTimeoutDelay=" + Utils.adjustTimeout(500),
-        "-XX:GuaranteedSafepointInterval=" + Utils.adjustTimeout(500),
-        "-XX:-TieredCompilation",
-        "-XX:+UseCountedLoopSafepoints",
-        "-XX:LoopStripMiningIter=1000",
-        "-XX:LoopUnrollLimit=0",
-        "-XX:CompileCommand=compileonly,compiler.loopstripmining.CheckLoopStripMining$Test::test_loop",
-        "-Xcomp",
-        Test.class.getName()).shouldHaveExitValue(0)
-                             .stdoutShouldContain("sum: 715827882");
-  }
+    public static void main(String args[]) throws Exception {
+        String[] subProcessArgs1 = { "-XX:+UnlockDiagnosticVMOptions",
+                                     // to prevent biased locking handshakes from changing the timing of this test
+                                     "-XX:-UseBiasedLocking",
+                                     "-XX:+SafepointTimeout",
+                                     "-XX:+SafepointALot",
+                                     "-XX:+AbortVMOnSafepointTimeout",
+                                     "-XX:SafepointTimeoutDelay=" + Utils.adjustTimeout(300),
+                                     "-XX:GuaranteedSafepointInterval=" + Utils.adjustTimeout(300),
+                                     "-XX:-TieredCompilation",
+                                     "-XX:+UseCountedLoopSafepoints",
+                                     "-XX:LoopStripMiningIter=1000",
+                                     "-XX:LoopUnrollLimit=0",
+                                     "-XX:CompileCommand=compileonly,compiler.loopstripmining.CheckLoopStripMining$Test1::test_loop",
+                                     "-Xcomp",
+                                     Test1.class.getName()};
 
-  public static class Test {
-    public static int test_loop(int x) {
-      int sum = 0;
-      if (x != 0) {
-          for (int y = 1; y < Integer.MAX_VALUE; ++y) {
-              if (y % x == 0) ++sum;
-          }
-      }
-      return sum;
+        ProcessTools.executeTestJvm(subProcessArgs1).shouldHaveExitValue(0)
+            .stdoutShouldContain("sum: 715827882");
+        String[] subProcessArgs2 = { "-XX:+UnlockDiagnosticVMOptions",
+                                     // to prevent biased locking handshakes from changing the timing of this test
+                                     "-XX:-UseBiasedLocking",
+                                     "-XX:+SafepointTimeout",
+                                     "-XX:+SafepointALot",
+                                     "-XX:+AbortVMOnSafepointTimeout",
+                                     "-XX:SafepointTimeoutDelay=" + Utils.adjustTimeout(300),
+                                     "-XX:GuaranteedSafepointInterval=" + Utils.adjustTimeout(300),
+                                     "-XX:-TieredCompilation",
+                                     "-XX:+UseCountedLoopSafepoints",
+                                     "-XX:LoopStripMiningIter=1000",
+                                     "-XX:LoopUnrollLimit=0",
+                                     "-XX:-BackgroundCompilation",
+                                     Test2.class.getName()};
+        ProcessTools.executeTestJvm(subProcessArgs2).shouldHaveExitValue(0);
     }
 
-    public static void main(String args[]) {
-      int sum = test_loop(3);
-      System.out.println("sum: " + sum);
+    public static class Test1 {
+        public static int test_loop(int x) {
+            int sum = 0;
+            if (x != 0) {
+                for (int y = 1; y < Integer.MAX_VALUE; ++y) {
+                    if (y % x == 0) ++sum;
+                }
+            }
+            return sum;
+        }
+
+        public static void main(String args[]) {
+            int sum = test_loop(3);
+            System.out.println("sum: " + sum);
+        }
+    }
+
+    public static class Test2 {
+        public static int test_loop(int start, int stop) {
+            int sum = 0;
+            for (int x = start; x < stop; x++) {
+                sum += x;
+            }
+            return sum;
+        }
+
+        public static void main(String args[]) {
+            for (int i = 0; i < 20_000; i++) {
+                test_loop(0, 1);
+            }
+            test_loop(Integer.MIN_VALUE, 0);
+            test_loop(-1, Integer.MAX_VALUE);
+            test_loop(Integer.MIN_VALUE, Integer.MAX_VALUE);
+        }
     }
-  }
 }