--- old/src/share/vm/opto/library_call.cpp	2013-10-22 14:52:25.140088629 +0200
+++ new/src/share/vm/opto/library_call.cpp	2013-10-22 14:52:25.032088633 +0200
@@ -204,18 +204,14 @@
   bool inline_trig(vmIntrinsics::ID id);
   bool inline_math(vmIntrinsics::ID id);
   void inline_math_mathExact(Node* math);
-  bool inline_math_addExact();
-  bool inline_math_addExactL();
-  bool inline_math_decrementExact();
-  bool inline_math_decrementExactL();
-  bool inline_math_incrementExact();
-  bool inline_math_incrementExactL();
-  bool inline_math_multiplyExact();
+  bool inline_math_addExactI(bool is_increment);
+  bool inline_math_addExactL(bool is_increment);
+  bool inline_math_multiplyExactI();
   bool inline_math_multiplyExactL();
-  bool inline_math_negateExact();
+  bool inline_math_negateExactI();
   bool inline_math_negateExactL();
-  bool inline_math_subtractExact();
-  bool inline_math_subtractExactL();
+  bool inline_math_subtractExactI(bool is_decrement);
+  bool inline_math_subtractExactL(bool is_decrement);
   bool inline_exp();
   bool inline_pow();
   void finish_pow_exp(Node* result, Node* x, Node* y, const TypeFunc* call_type, address funcAddr, const char* funcName);
@@ -518,29 +514,29 @@
     if (!UseCRC32Intrinsics) return NULL;
     break;
 
-  case vmIntrinsics::_incrementExact:
-  case vmIntrinsics::_addExact:
+  case vmIntrinsics::_incrementExactI:
+  case vmIntrinsics::_addExactI:
     if (!Matcher::match_rule_supported(Op_AddExactI) || !UseMathExactIntrinsics) return NULL;
     break;
   case vmIntrinsics::_incrementExactL:
   case vmIntrinsics::_addExactL:
     if (!Matcher::match_rule_supported(Op_AddExactL) || !UseMathExactIntrinsics) return NULL;
     break;
-  case vmIntrinsics::_decrementExact:
-  case vmIntrinsics::_subtractExact:
+  case vmIntrinsics::_decrementExactI:
+  case vmIntrinsics::_subtractExactI:
     if (!Matcher::match_rule_supported(Op_SubExactI) || !UseMathExactIntrinsics) return NULL;
     break;
   case vmIntrinsics::_decrementExactL:
   case vmIntrinsics::_subtractExactL:
     if (!Matcher::match_rule_supported(Op_SubExactL) || !UseMathExactIntrinsics) return NULL;
     break;
-  case vmIntrinsics::_negateExact:
+  case vmIntrinsics::_negateExactI:
     if (!Matcher::match_rule_supported(Op_NegExactI) || !UseMathExactIntrinsics) return NULL;
     break;
   case vmIntrinsics::_negateExactL:
     if (!Matcher::match_rule_supported(Op_NegExactL) || !UseMathExactIntrinsics) return NULL;
     break;
-  case vmIntrinsics::_multiplyExact:
+  case vmIntrinsics::_multiplyExactI:
     if (!Matcher::match_rule_supported(Op_MulExactI) || !UseMathExactIntrinsics) return NULL;
     break;
   case vmIntrinsics::_multiplyExactL:
@@ -717,18 +713,18 @@
   case vmIntrinsics::_min:
   case vmIntrinsics::_max:                      return inline_min_max(intrinsic_id());
 
-  case vmIntrinsics::_addExact:                 return inline_math_addExact();
-  case vmIntrinsics::_addExactL:                return inline_math_addExactL();
-  case vmIntrinsics::_decrementExact:           return inline_math_decrementExact();
-  case vmIntrinsics::_decrementExactL:          return inline_math_decrementExactL();
-  case vmIntrinsics::_incrementExact:           return inline_math_incrementExact();
-  case vmIntrinsics::_incrementExactL:          return inline_math_incrementExactL();
-  case vmIntrinsics::_multiplyExact:            return inline_math_multiplyExact();
+  case vmIntrinsics::_addExactI:                return inline_math_addExactI(false /* add */);
+  case vmIntrinsics::_addExactL:                return inline_math_addExactL(false /* add */);
+  case vmIntrinsics::_decrementExactI:          return inline_math_subtractExactI(true /* decrement */);
+  case vmIntrinsics::_decrementExactL:          return inline_math_subtractExactL(true /* decrement */);
+  case vmIntrinsics::_incrementExactI:          return inline_math_addExactI(true /* increment */);
+  case vmIntrinsics::_incrementExactL:          return inline_math_addExactL(true /* increment */);
+  case vmIntrinsics::_multiplyExactI:           return inline_math_multiplyExactI();
   case vmIntrinsics::_multiplyExactL:           return inline_math_multiplyExactL();
-  case vmIntrinsics::_negateExact:              return inline_math_negateExact();
+  case vmIntrinsics::_negateExactI:             return inline_math_negateExactI();
   case vmIntrinsics::_negateExactL:             return inline_math_negateExactL();
-  case vmIntrinsics::_subtractExact:            return inline_math_subtractExact();
-  case vmIntrinsics::_subtractExactL:           return inline_math_subtractExactL();
+  case vmIntrinsics::_subtractExactI:           return inline_math_subtractExactI(false /* subtract */);
+  case vmIntrinsics::_subtractExactL:           return inline_math_subtractExactL(false /* subtract */);
 
   case vmIntrinsics::_arraycopy:                return inline_arraycopy();
 
@@ -1976,7 +1972,7 @@
 void LibraryCallKit::inline_math_mathExact(Node* math) {
   // If we didn't get the expected opcode it means we have optimized
   // the node to something else and don't need the exception edge.
-  if (MathExactNode::is_MathExactOpcode(math->Opcode()) == false) {
+  if (!math->is_MathExact()) {
     set_result(math);
     return;
   }
@@ -2005,50 +2001,74 @@
   set_result(result);
 }
 
-bool LibraryCallKit::inline_math_addExact() {
+bool LibraryCallKit::inline_math_addExactI(bool is_increment) {
   Node* arg1 = argument(0);
-  Node* arg2 = argument(1);
+  Node* arg2 = NULL;
+
+  if (is_increment) {
+      arg2 = intcon(1);
+  } else {
+      arg2 = argument(1);
+  }
 
   Node* add = _gvn.transform( new(C) AddExactINode(NULL, arg1, arg2) );
   inline_math_mathExact(add);
   return true;
 }
 
-bool LibraryCallKit::inline_math_addExactL() {
+bool LibraryCallKit::inline_math_addExactL(bool is_increment) {
   Node* arg1 = argument(0); // type long
   // argument(1) == TOP
-  Node* arg2 = argument(2); // type long
-  // argument(4) == TOP
+  Node* arg2 = NULL;
 
-  Node* add = _gvn.transform( new(C) AddExactLNode(NULL, arg1, arg2) );
+  if (is_increment) {
+    arg2 = longcon(1);
+  } else {
+    arg2 = argument(2); // type long
+    // argument(3) == TOP
+  }
+
+  Node* add = _gvn.transform(new(C) AddExactLNode(NULL, arg1, arg2));
   inline_math_mathExact(add);
   return true;
 }
 
-bool LibraryCallKit::inline_math_subtractExactL() {
-  Node* arg1 = argument(0); // type long
-  // argument(1) == TOP
-  Node* arg2 = argument(2); // type long
-  // argument(4) == TOP
+bool LibraryCallKit::inline_math_subtractExactI(bool is_decrement) {
+  Node* arg1 = argument(0);
+  Node* arg2 = NULL;
 
-  Node* sub = _gvn.transform( new(C) SubExactLNode(NULL, arg1, arg2) );
+  if (is_decrement) {
+    arg2 = intcon(1);
+  } else {
+    arg2 = argument(1);
+  }
+
+  Node* sub = _gvn.transform(new(C) SubExactINode(NULL, arg1, arg2));
   inline_math_mathExact(sub);
   return true;
 }
 
-bool LibraryCallKit::inline_math_subtractExact() {
-  Node* arg1 = argument(0);
-  Node* arg2 = argument(1);
+bool LibraryCallKit::inline_math_subtractExactL(bool is_decrement) {
+  Node* arg1 = argument(0); // type long
+  // argument(1) == TOP
+  Node* arg2 = NULL;
 
-  Node* sub = _gvn.transform( new(C) SubExactINode(NULL, arg1, arg2) );
+  if (is_decrement) {
+    arg2 = longcon(1);
+  } else {
+    Node* arg2 = argument(2); // type long
+    // argument(3) == TOP
+  }
+
+  Node* sub = _gvn.transform(new(C) SubExactLNode(NULL, arg1, arg2));
   inline_math_mathExact(sub);
   return true;
 }
 
-bool LibraryCallKit::inline_math_negateExact() {
+bool LibraryCallKit::inline_math_negateExactI() {
   Node* arg1 = argument(0);
 
-  Node* neg = _gvn.transform( new(C) NegExactINode(NULL, arg1));
+  Node* neg = _gvn.transform(new(C) NegExactINode(NULL, arg1));
   inline_math_mathExact(neg);
   return true;
 }
@@ -2057,16 +2077,16 @@
   Node* arg1 = argument(0);
   // argument(1) == TOP
 
-  Node* neg = _gvn.transform( new(C) NegExactLNode(NULL, arg1));
+  Node* neg = _gvn.transform(new(C) NegExactLNode(NULL, arg1));
   inline_math_mathExact(neg);
   return true;
 }
 
-bool LibraryCallKit::inline_math_multiplyExact() {
+bool LibraryCallKit::inline_math_multiplyExactI() {
   Node* arg1 = argument(0);
   Node* arg2 = argument(1);
 
-  Node* mul = _gvn.transform( new(C) MulExactINode(NULL, arg1, arg2) );
+  Node* mul = _gvn.transform(new(C) MulExactINode(NULL, arg1, arg2));
   inline_math_mathExact(mul);
   return true;
 }
@@ -2077,49 +2097,11 @@
   Node* arg2 = argument(2);
   // argument(3) == TOP
 
-  Node* mul = _gvn.transform( new(C) MulExactLNode(NULL, arg1, arg2) );
+  Node* mul = _gvn.transform(new(C) MulExactLNode(NULL, arg1, arg2));
   inline_math_mathExact(mul);
   return true;
 }
 
-bool LibraryCallKit::inline_math_incrementExact() {
-  Node* arg1 = argument(0);
-  Node* arg2 = intcon(1);
-
-  Node* inc = _gvn.transform( new(C) AddExactINode(NULL, arg1, arg2));
-  inline_math_mathExact(inc);
-  return true;
-}
-
-bool LibraryCallKit::inline_math_incrementExactL() {
-  Node* arg1 = argument(0);
-  // argument(1) == TOP
-  Node* arg2 = longcon(1);
-
-  Node* inc = _gvn.transform( new(C) AddExactLNode(NULL, arg1, arg2));
-  inline_math_mathExact(inc);
-  return true;
-}
-
-bool LibraryCallKit::inline_math_decrementExact() {
-  Node* arg1 = argument(0);
-  Node* arg2 = intcon(1);
-
-  Node* dec = _gvn.transform( new(C) SubExactINode(NULL, arg1, arg2));
-  inline_math_mathExact(dec);
-  return true;
-}
-
-bool LibraryCallKit::inline_math_decrementExactL() {
-  Node* arg1 = argument(0);
-  // argument(1) == TOP
-  Node* arg2 = longcon(1);
-
-  Node* dec = _gvn.transform( new(C) SubExactLNode(NULL, arg1, arg2));
-  inline_math_mathExact(dec);
-  return true;
-}
-
 Node*
 LibraryCallKit::generate_min_max(vmIntrinsics::ID id, Node* x0, Node* y0) {
   // These are the candidate return value: