--- old/src/share/vm/opto/compile.cpp	2013-10-11 13:48:37.949328234 +0200
+++ new/src/share/vm/opto/compile.cpp	2013-10-11 13:48:37.845328238 +0200
@@ -47,6 +47,7 @@
 #include "opto/machnode.hpp"
 #include "opto/macro.hpp"
 #include "opto/matcher.hpp"
+#include "opto/mathexactnode.hpp"
 #include "opto/memnode.hpp"
 #include "opto/mulnode.hpp"
 #include "opto/node.hpp"
@@ -2986,6 +2987,32 @@
       n->set_req(MemBarNode::Precedent, top());
     }
     break;
+    // Must set a control edge on all nodes that produce a FlagsProj
+    // so they can't escape the block that consumes the flags.
+    // Must also set the non throwing branch as the control
+    // for all nodes that depends on the result. Unless the node
+    // already have a control that isn't the control of the
+    // flag producer
+  case Op_FlagsProj:
+    {
+      MathExactNode* math = (MathExactNode*)  n->in(0);
+      Node* ctrl = math->control_node();
+      Node* non_throwing = math->non_throwing_branch();
+      math->set_req(0, ctrl);
+
+      Node* result = math->result_node();
+      if (result != NULL) {
+        for (DUIterator_Fast jmax, j = result->fast_outs(jmax); j < jmax; j++) {
+          Node* out = result->fast_out(j);
+          if (out->in(0) == NULL) {
+            out->set_req(0, non_throwing);
+          } else if (out->in(0) == ctrl) {
+            out->set_req(0, non_throwing);
+          }
+        }
+      }
+    }
+    break;
   default:
     assert( !n->is_Call(), "" );
     assert( !n->is_Mem(), "" );
--- old/src/share/vm/opto/mathexactnode.cpp	2013-10-11 13:48:38.569328213 +0200
+++ new/src/share/vm/opto/mathexactnode.cpp	2013-10-11 13:48:38.465328216 +0200
@@ -25,9 +25,10 @@
 #include "precompiled.hpp"
 #include "memory/allocation.inline.hpp"
 #include "opto/addnode.hpp"
+#include "opto/cfgnode.hpp"
 #include "opto/machnode.hpp"
-#include "opto/mathexactnode.hpp"
 #include "opto/matcher.hpp"
+#include "opto/mathexactnode.hpp"
 #include "opto/subnode.hpp"
 
 MathExactNode::MathExactNode(Node* ctrl, Node* n1, Node* n2) : MultiNode(3) {
@@ -36,6 +37,23 @@
   init_req(2, n2);
 }
 
+Node* MathExactNode::control_node() const {
+  Node* flags = flags_node();
+  BoolNode* boolnode = flags->unique_out()->as_Bool();
+  IfNode* iff = boolnode->unique_out()->as_If();
+  return iff->in(0);
+}
+
+Node* MathExactNode::non_throwing_branch() const {
+  Node* flags = flags_node();
+  BoolNode* boolnode = flags->unique_out()->as_Bool();
+  IfNode* iff = boolnode->unique_out()->as_If();
+  if (boolnode->_test._test == BoolTest::overflow) {
+    return iff->proj_out(0);
+  }
+  return iff->proj_out(1);
+}
+
 Node* AddExactINode::match(const ProjNode* proj, const Matcher* m) {
   uint ideal_reg = proj->ideal_reg();
   RegMask rm;
--- old/src/share/vm/opto/mathexactnode.hpp	2013-10-11 13:48:39.133328193 +0200
+++ new/src/share/vm/opto/mathexactnode.hpp	2013-10-11 13:48:39.033328197 +0200
@@ -49,8 +49,10 @@
   virtual bool is_CFG() const { return false; }
   virtual uint ideal_reg() const { return NotAMachineReg; }
 
-  ProjNode* result_node() { return proj_out(result_proj_node); }
-  ProjNode* flags_node() { return proj_out(flags_proj_node); }
+  ProjNode* result_node() const { return proj_out(result_proj_node); }
+  ProjNode* flags_node() const { return proj_out(flags_proj_node); }
+  Node* control_node() const;
+  Node* non_throwing_branch() const;
 protected:
   Node* no_overflow(PhaseGVN *phase, Node* new_result);
 };
--- /dev/null	2013-10-09 08:00:06.496075990 +0200
+++ new/test/compiler/intrinsics/mathexact/RepeatTest.java	2013-10-11 13:48:39.605328177 +0200
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2013, Oracle and/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 8025657
+ * @summary Test repeating addExact
+ * @compile RepeatTest.java Verify.java
+ * @run main RepeatTest
+ *
+ */
+
+import java.lang.ArithmeticException;
+
+public class RepeatTest {
+  public static void main(String[] args) {
+    java.util.Random rnd = new java.util.Random();
+    for (int i = 0; i < 50000; ++i) {
+      int x = Integer.MAX_VALUE - 10;
+      int y = Integer.MAX_VALUE - 10 + rnd.nextInt(5); //rnd.nextInt() / 2;
+
+      int c = rnd.nextInt() / 2;
+      int d = rnd.nextInt() / 2;
+
+      int a = addExact(x, y);
+
+      if (a != 36) {
+          throw new RuntimeException("a != 0 : " + a);
+      }
+
+      int b = nonExact(c, d);
+      int n = addExact2(c, d);
+
+
+      if (n != b) {
+        throw new RuntimeException("n != b : " + n + " != " + b);
+      }
+    }
+  }
+
+  public static int addExact2(int x, int y) {
+      int result = 0;
+      result += java.lang.Math.addExact(x, y);
+      result += java.lang.Math.addExact(x, y);
+      result += java.lang.Math.addExact(x, y);
+      result += java.lang.Math.addExact(x, y);
+      return result;
+  }
+
+  public static int addExact(int x, int y) {
+    int result = 0;
+    try {
+        result += 5;
+        result = java.lang.Math.addExact(x, y);
+    } catch (ArithmeticException e) {
+        result += 1;
+    }
+    try {
+        result += 6;
+
+        result += java.lang.Math.addExact(x, y);
+    } catch (ArithmeticException e) {
+        result += 2;
+    }
+    try {
+        result += 7;
+        result += java.lang.Math.addExact(x, y);
+    } catch (ArithmeticException e) {
+        result += 3;
+    }
+    try {
+        result += 8;
+        result += java.lang.Math.addExact(x, y);
+    } catch (ArithmeticException e) {
+        result += 4;
+    }
+    return result;
+  }
+
+  public static int nonExact(int x, int y) {
+    int result = x + y;
+    result += x + y;
+    result += x + y;
+    result += x + y;
+    return result;
+  }
+}