src/share/vm/opto/mathexactnode.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/opto

src/share/vm/opto/mathexactnode.cpp

Print this page
rev 5902 : 8027754: Enable loop optimizations for loops with MathExact inside


  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 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "opto/addnode.hpp"
  28 #include "opto/cfgnode.hpp"
  29 #include "opto/machnode.hpp"
  30 #include "opto/matcher.hpp"
  31 #include "opto/mathexactnode.hpp"
  32 #include "opto/subnode.hpp"
  33 
  34 MathExactNode::MathExactNode(Node* ctrl, Node* in1) : MultiNode(2) {
  35   init_class_id(Class_MathExact);
  36   init_req(0, ctrl);
  37   init_req(1, in1);
  38 }
  39 
  40 MathExactNode::MathExactNode(Node* ctrl, Node* in1, Node* in2) : MultiNode(3) {
  41   init_class_id(Class_MathExact);
  42   init_req(0, ctrl);
  43   init_req(1, in1);
  44   init_req(2, in2);
  45 }
  46 
  47 BoolNode* MathExactNode::bool_node() const {
  48   Node* flags = flags_node();
  49   BoolNode* boolnode = flags->unique_out()->as_Bool();
  50   assert(boolnode != NULL, "must have BoolNode");
  51   return boolnode;



  52 }
  53 
  54 IfNode* MathExactNode::if_node() const {
  55   BoolNode* boolnode = bool_node();
  56   IfNode* ifnode = boolnode->unique_out()->as_If();
  57   assert(ifnode != NULL, "must have IfNode");
  58   return ifnode;

  59 }
  60 
  61 Node* MathExactNode::control_node() const {
  62   IfNode* ifnode = if_node();
  63   return ifnode->in(0);






  64 }
  65 
  66 Node* MathExactNode::non_throwing_branch() const {
  67   IfNode* ifnode = if_node();
  68   if (bool_node()->_test._test == BoolTest::overflow) {
  69     return ifnode->proj_out(0);
  70   }
  71   return ifnode->proj_out(1);
  72 }
  73 
  74 // If the MathExactNode won't overflow we have to replace the
  75 // FlagsProjNode and ProjNode that is generated by the MathExactNode
  76 Node* MathExactNode::no_overflow(PhaseGVN* phase, Node* new_result) {
  77   PhaseIterGVN* igvn = phase->is_IterGVN();
  78   if (igvn) {
  79     ProjNode* result = result_node();
  80     ProjNode* flags = flags_node();
  81 
  82     if (result != NULL) {
  83       igvn->replace_node(result, new_result);
  84     }


  85 
  86     if (flags != NULL) {
  87       BoolNode* boolnode = bool_node();
  88       switch (boolnode->_test._test) {
  89         case BoolTest::overflow:
  90           // if the check is for overflow - never taken
  91           igvn->replace_node(boolnode, phase->intcon(0));
  92           break;
  93         case BoolTest::no_overflow:
  94           // if the check is for no overflow - always taken
  95           igvn->replace_node(boolnode, phase->intcon(1));
  96           break;
  97         default:
  98           fatal("Unexpected value of BoolTest");
  99           break;
 100       }
 101       flags->del_req(0);
 102     }
 103   }
 104   return new_result;
 105 }
 106 
 107 Node* MathExactINode::match(const ProjNode* proj, const Matcher* m) {
 108   uint ideal_reg = proj->ideal_reg();
 109   RegMask rm;
 110   if (proj->_con == result_proj_node) {
 111     rm = m->mathExactI_result_proj_mask();
 112   } else {
 113     assert(proj->_con == flags_proj_node, "must be result or flags");
 114     assert(ideal_reg == Op_RegFlags, "sanity");
 115     rm = m->mathExactI_flags_proj_mask();
 116   }
 117   return new (m->C) MachProjNode(this, proj->_con, rm, ideal_reg);
 118 }
 119 
 120 Node* MathExactLNode::match(const ProjNode* proj, const Matcher* m) {
 121   uint ideal_reg = proj->ideal_reg();
 122   RegMask rm;
 123   if (proj->_con == result_proj_node) {
 124     rm = m->mathExactL_result_proj_mask();
 125   } else {
 126     assert(proj->_con == flags_proj_node, "must be result or flags");
 127     assert(ideal_reg == Op_RegFlags, "sanity");
 128     rm = m->mathExactI_flags_proj_mask();
 129   }
 130   return new (m->C) MachProjNode(this, proj->_con, rm, ideal_reg);
 131 }
 132 
 133 Node* AddExactINode::Ideal(PhaseGVN* phase, bool can_reshape) {
 134   Node* arg1 = in(1);
 135   Node* arg2 = in(2);

 136 
 137   const Type* type1 = phase->type(arg1);
 138   const Type* type2 = phase->type(arg2);

 139 
 140   if (type1 != Type::TOP && type1->singleton() &&
 141       type2 != Type::TOP && type2->singleton()) {
 142     jint val1 = arg1->get_int();
 143     jint val2 = arg2->get_int();
 144     jint result = val1 + val2;
 145     // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result
 146     if ( (((val1 ^ result) & (val2 ^ result)) >= 0)) {
 147       Node* con_result = ConINode::make(phase->C, result);
 148       return no_overflow(phase, con_result);
 149     }
 150     return NULL;
 151   }
 152 
 153   if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) { // (Add 0 x) == x
 154     Node* add_result = new (phase->C) AddINode(arg1, arg2);
 155     return no_overflow(phase, add_result);

 156   }


 157 
 158   if (type2->singleton()) {
 159     return NULL; // no change - keep constant on the right
 160   }
 161 
 162   if (type1->singleton()) {
 163     // Make it x + Constant - move constant to the right
 164     swap_edges(1, 2);
 165     return this;
 166   }
 167 
 168   if (arg2->is_Load()) {
 169     return NULL; // no change - keep load on the right
 170   }

 171 
 172   if (arg1->is_Load()) {
 173     // Make it x + Load - move load to the right
 174     swap_edges(1, 2);
 175     return this;




 176   }
 177 
 178   if (arg1->_idx > arg2->_idx) {
 179     // Sort the edges
 180     swap_edges(1, 2);
 181     return this;
 182   }
 183 
 184   return NULL;
 185 }
 186 
 187 Node* AddExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 188   Node* arg1 = in(1);
 189   Node* arg2 = in(2);
 190 
 191   const Type* type1 = phase->type(arg1);
 192   const Type* type2 = phase->type(arg2);

 193 
 194   if (type1 != Type::TOP && type1->singleton() &&
 195       type2 != Type::TOP && type2->singleton()) {
 196     jlong val1 = arg1->get_long();
 197     jlong val2 = arg2->get_long();
 198     jlong result = val1 + val2;
 199     // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result
 200     if ( (((val1 ^ result) & (val2 ^ result)) >= 0)) {
 201       Node* con_result = ConLNode::make(phase->C, result);
 202       return no_overflow(phase, con_result);
 203     }
 204     return NULL;
 205   }
 206 
 207   if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) { // (Add 0 x) == x
 208     Node* add_result = new (phase->C) AddLNode(arg1, arg2);
 209     return no_overflow(phase, add_result);
 210   }
 211 
 212   if (type2->singleton()) {
 213     return NULL; // no change - keep constant on the right
 214   }
 215 
 216   if (type1->singleton()) {
 217     // Make it x + Constant - move constant to the right
 218     swap_edges(1, 2);
 219     return this;
 220   }

 221 
 222   if (arg2->is_Load()) {
 223     return NULL; // no change - keep load on the right
 224   }
 225 
 226   if (arg1->is_Load()) {
 227     // Make it x + Load - move load to the right
 228     swap_edges(1, 2);
 229     return this;
 230   }
 231 
 232   if (arg1->_idx > arg2->_idx) {
 233     // Sort the edges
 234     swap_edges(1, 2);
 235     return this;
 236   }

 237 
 238   return NULL;
 239 }
 240 
 241 Node* SubExactINode::Ideal(PhaseGVN* phase, bool can_reshape) {
 242   Node* arg1 = in(1);
 243   Node* arg2 = in(2);
 244 



 245   const Type* type1 = phase->type(arg1);
 246   const Type* type2 = phase->type(arg2);
 247 
 248   if (type1 != Type::TOP && type1->singleton() &&
 249       type2 != Type::TOP && type2->singleton()) {
 250     jint val1 = arg1->get_int();
 251     jint val2 = arg2->get_int();
 252     jint result = val1 - val2;
 253 
 254     // Hacker's Delight 2-12 Overflow iff the arguments have different signs and
 255     // the sign of the result is different than the sign of arg1
 256     if (((val1 ^ val2) & (val1 ^ result)) >= 0) {
 257       Node* con_result = ConINode::make(phase->C, result);
 258       return no_overflow(phase, con_result);
 259     }
 260     return NULL;
 261   }
 262 
 263   if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) {
 264     // Sub with zero is the same as add with zero
 265     Node* add_result = new (phase->C) AddINode(arg1, arg2);
 266     return no_overflow(phase, add_result);
 267   }
 268 
 269   return NULL;
 270 }
 271 
 272 Node* SubExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 273   Node* arg1 = in(1);
 274   Node* arg2 = in(2);
 275 
 276   const Type* type1 = phase->type(arg1);
 277   const Type* type2 = phase->type(arg2);
 278 
 279   if (type1 != Type::TOP && type1->singleton() &&
 280       type2 != Type::TOP && type2->singleton()) {
 281     jlong val1 = arg1->get_long();
 282     jlong val2 = arg2->get_long();
 283     jlong result = val1 - val2;
 284 
 285     // Hacker's Delight 2-12 Overflow iff the arguments have different signs and
 286     // the sign of the result is different than the sign of arg1
 287     if (((val1 ^ val2) & (val1 ^ result)) >= 0) {
 288       Node* con_result = ConLNode::make(phase->C, result);
 289       return no_overflow(phase, con_result);
 290     }
 291     return NULL;
 292   }
 293 
 294   if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) {
 295     // Sub with zero is the same as add with zero
 296     Node* add_result = new (phase->C) AddLNode(arg1, arg2);
 297     return no_overflow(phase, add_result);
 298   }
 299 
 300   return NULL;
 301 }



 302 
 303 Node* NegExactINode::Ideal(PhaseGVN* phase, bool can_reshape) {
 304   Node *arg = in(1);
 305 
 306   const Type* type = phase->type(arg);
 307   if (type != Type::TOP && type->singleton()) {
 308     jint value = arg->get_int();
 309     if (value != min_jint) {
 310       Node* neg_result = ConINode::make(phase->C, -value);
 311       return no_overflow(phase, neg_result);
 312     }
 313   }
 314   return NULL;
 315 }
 316 
 317 Node* NegExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 318   Node *arg = in(1);
 319 
 320   const Type* type = phase->type(arg);
 321   if (type != Type::TOP && type->singleton()) {
 322     jlong value = arg->get_long();
 323     if (value != min_jlong) {
 324       Node* neg_result = ConLNode::make(phase->C, -value);
 325       return no_overflow(phase, neg_result);
 326     }










 327   }
 328   return NULL;
 329 }
 330 
 331 Node* MulExactINode::Ideal(PhaseGVN* phase, bool can_reshape) {
 332   Node* arg1 = in(1);
 333   Node* arg2 = in(2);
 334 
 335   const Type* type1 = phase->type(arg1);
 336   const Type* type2 = phase->type(arg2);
 337 
 338   if (type1 != Type::TOP && type1->singleton() &&
 339       type2 != Type::TOP && type2->singleton()) {
 340     jint val1 = arg1->get_int();
 341     jint val2 = arg2->get_int();
 342     jlong result = (jlong) val1 * (jlong) val2;
 343     if ((jint) result == result) {
 344       // no overflow
 345       Node* mul_result = ConINode::make(phase->C, result);
 346       return no_overflow(phase, mul_result);
 347     }
 348   }
 349 
 350   if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) {
 351     return no_overflow(phase, ConINode::make(phase->C, 0));
 352   }
 353 
 354   if (type1 == TypeInt::ONE) {
 355     Node* mul_result = new (phase->C) AddINode(arg2, phase->intcon(0));
 356     return no_overflow(phase, mul_result);
 357   }
 358   if (type2 == TypeInt::ONE) {
 359     Node* mul_result = new (phase->C) AddINode(arg1, phase->intcon(0));
 360     return no_overflow(phase, mul_result);
 361   }
 362 
 363   if (type1 == TypeInt::MINUS_1) {
 364     return new (phase->C) NegExactINode(NULL, arg2);
 365   }

 366 
 367   if (type2 == TypeInt::MINUS_1) {
 368     return new (phase->C) NegExactINode(NULL, arg1);
 369   }
 370 
 371   return NULL;
 372 }
 373 
 374 Node* MulExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 375   Node* arg1 = in(1);
 376   Node* arg2 = in(2);
 377 
 378   const Type* type1 = phase->type(arg1);
 379   const Type* type2 = phase->type(arg2);
 380 
 381   if (type1 != Type::TOP && type1->singleton() &&
 382       type2 != Type::TOP && type2->singleton()) {
 383     jlong val1 = arg1->get_long();
 384     jlong val2 = arg2->get_long();
 385 
 386     jlong result = val1 * val2;
 387     jlong ax = (val1 < 0 ? -val1 : val1);
 388     jlong ay = (val2 < 0 ? -val2 : val2);
 389 
 390     bool overflow = false;
 391     if ((ax | ay) & CONST64(0xFFFFFFFF00000000)) {
 392       // potential overflow if any bit in upper 32 bits are set
 393       if ((val1 == min_jlong && val2 == -1) || (val2 == min_jlong && val1 == -1)) {
 394         // -1 * Long.MIN_VALUE will overflow
 395         overflow = true;
 396       } else if (val2 != 0 && (result / val2 != val1)) {
 397         overflow = true;
 398       }
 399     }
 400 
 401     if (!overflow) {
 402       Node* mul_result = ConLNode::make(phase->C, result);
 403       return no_overflow(phase, mul_result);
 404     }
 405   }


 406 
 407   if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) {
 408     return no_overflow(phase, ConLNode::make(phase->C, 0));
 409   }
 410 
 411   if (type1 == TypeLong::ONE) {
 412     Node* mul_result = new (phase->C) AddLNode(arg2, phase->longcon(0));
 413     return no_overflow(phase, mul_result);
 414   }
 415   if (type2 == TypeLong::ONE) {
 416     Node* mul_result = new (phase->C) AddLNode(arg1, phase->longcon(0));
 417     return no_overflow(phase, mul_result);
 418   }
 419 
 420   if (type1 == TypeLong::MINUS_1) {
 421     return new (phase->C) NegExactLNode(NULL, arg2);
 422   }
 423 
 424   if (type2 == TypeLong::MINUS_1) {
 425     return new (phase->C) NegExactLNode(NULL, arg1);
 426   }
 427 
 428   return NULL;


 429 }
 430 






  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 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "opto/addnode.hpp"
  28 #include "opto/cfgnode.hpp"
  29 #include "opto/machnode.hpp"
  30 #include "opto/matcher.hpp"
  31 #include "opto/mathexactnode.hpp"
  32 #include "opto/subnode.hpp"
  33 
  34 OverflowNode::OverflowNode(Node* in1) : CmpNode(in1, in1) {



  35 }
  36 
  37 OverflowNode::OverflowNode(Node* in1, Node* in2) : CmpNode(in1, in2) {




  38 }
  39 
  40 template <typename OverflowOp>
  41 bool OverflowNode::AddHelper<OverflowOp>::will_overflow(ConstantType value1, ConstantType value2) {
  42   ConstantType result = value1 + value2;
  43   // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result
  44   if ( (((value1 ^ result) & (value2 ^ result)) >= 0)) {
  45     return false;
  46   }
  47   return true;
  48 }
  49 
  50 template <typename OverflowOp>
  51 bool OverflowNode::AddHelper<OverflowOp>::can_overflow(const Type* type1, const Type* type2) {
  52   if (type1 == TypeClass::ZERO || type2 == TypeClass::ZERO) {
  53     return false;
  54   }
  55   return true;
  56 }
  57 
  58 template <typename OverflowOp>
  59 bool OverflowNode::SubHelper<OverflowOp>::will_overflow(ConstantType value1, ConstantType value2) {
  60   ConstantType result = value1 - value2;
  61   // Hacker's Delight 2-12 Overflow iff the arguments have different signs and
  62   // the sign of the result is different than the sign of arg1
  63   if (((value1 ^ value2) & (value1 ^ result)) >= 0) {
  64     return false;
  65   }
  66   return true;
  67 }
  68 
  69 template <typename OverflowOp>
  70 bool OverflowNode::SubHelper<OverflowOp>::can_overflow(const Type* type1, const Type* type2) {
  71   if (type2 == TypeClass::ZERO) {
  72     return false;
  73   }
  74   return true;
  75 }
  76 
  77 template <typename OverflowOp>
  78 bool OverflowNode::MulHelper<OverflowOp>::can_overflow(const Type* type1, const Type* type2) {
  79   if (type1 == TypeClass::ZERO || type2 == TypeClass::ZERO) {
  80     return false;
  81   } else if (type1 == TypeClass::ONE || type2 == TypeClass::ONE) {
  82     return false;




  83   }
  84   return true;
  85 }
  86 
  87 bool OverflowINode::will_overflow(jint v1, jint v2) const {
  88   ShouldNotReachHere();
  89   return true;
















  90 }
  91 
  92 bool OverflowLNode::will_overflow(jlong v1, jlong v2) const {
  93   ShouldNotReachHere();
  94   return true;








  95 }
  96 
  97 bool OverflowINode::can_overflow(const Type* t1, const Type* t2) const {
  98   ShouldNotReachHere();
  99   return true;








 100 }
 101 
 102 bool OverflowLNode::can_overflow(const Type* t1, const Type* t2) const {
 103   ShouldNotReachHere();
 104   return true;
 105 }
 106 
 107 bool OverflowAddINode::will_overflow(jint v1, jint v2) const {
 108   return OverflowHelper::will_overflow(v1, v2);
 109 }
 110 
 111 bool OverflowSubINode::will_overflow(jint v1, jint v2) const {
 112   return OverflowHelper::will_overflow(v1, v2);
 113 }









 114 
 115 bool OverflowMulINode::will_overflow(jint v1, jint v2) const {
 116     jlong result = (jlong) v1 * (jlong) v2;
 117     if ((jint) result == result) {
 118       return false;
 119     }
 120     return true;
 121 }
 122 
 123 bool OverflowAddLNode::will_overflow(jlong v1, jlong v2) const {
 124   return OverflowHelper::will_overflow(v1, v2);
 125 }
 126 
 127 bool OverflowSubLNode::will_overflow(jlong v1, jlong v2) const {
 128   return OverflowHelper::will_overflow(v1, v2);
 129 }


 130 
 131 bool OverflowMulLNode::will_overflow(jlong val1, jlong val2) const {
 132     jlong result = val1 * val2;
 133     jlong ax = (val1 < 0 ? -val1 : val1);
 134     jlong ay = (val2 < 0 ? -val2 : val2);
 135 
 136     bool overflow = false;
 137     if ((ax | ay) & CONST64(0xFFFFFFFF00000000)) {
 138       // potential overflow if any bit in upper 32 bits are set
 139       if ((val1 == min_jlong && val2 == -1) || (val2 == min_jlong && val1 == -1)) {
 140         // -1 * Long.MIN_VALUE will overflow
 141         overflow = true;
 142       } else if (val2 != 0 && (result / val2 != val1)) {
 143         overflow = true;
 144       }





 145     }
 146 
 147     return overflow;
 148 }
 149 



 150 
 151 template <typename TypeClass>
 152 struct TypeHelper {
 153   typedef typename TypeClass::native_type_t native_type_t;
 154 
 155   static const TypeClass* get_type(const Type* type);
 156   static native_type_t get_value(const Node* node);
 157 };









 158 
 159 template<>
 160 struct TypeHelper<TypeInt> {
 161   typedef TypeInt::native_type_t native_type_t;

 162 
 163   static const TypeInt* get_type(const Type* type) {
 164     return type->isa_int();
 165   }
 166   static native_type_t get_value(const Node* node) {
 167     return node->get_int();



 168   }
 169 };
 170 
 171 template<>
 172 struct TypeHelper<TypeLong> {
 173   typedef TypeLong::native_type_t native_type_t;
 174 
 175   static const TypeLong* get_type(const Type* type) {
 176     return type->isa_long();


 177   }
 178   static native_type_t get_value(const Node* node) {
 179     return node->get_long();



 180   }
 181 };
 182 
 183 template <typename OverflowOp>
 184 struct IdealHelper {
 185   typedef typename OverflowOp::TypeClass TypeClass; // TypeInt, TypeLong
 186   typedef typename TypeClass::native_type_t native_type_t;


 187 
 188   static Node* Ideal(const OverflowOp* node, PhaseGVN* phase, bool can_reshape) {
 189     Node* arg1 = node->in(1);
 190     Node* arg2 = node->in(2);
 191     const Type* type1 = phase->type(arg1);
 192     const Type* type2 = phase->type(arg2);
 193 
 194     if (type1 != Type::TOP && type1->singleton() &&
 195         type2 != Type::TOP && type2->singleton()) {
 196       native_type_t val1 = TypeHelper<TypeClass>::get_value(arg1);
 197       native_type_t val2 = TypeHelper<TypeClass>::get_value(arg2);
 198       if (node->will_overflow(val1, val2) == false) {
 199         Node* con_result = ConINode::make(phase->C, 0);
 200         return con_result;




 201       }
 202       return NULL;
 203     }







 204     return NULL;




























 205   }
 206 
 207   static const Type* Value(const OverflowOp* node, PhaseTransform* phase) {
 208     const Type *t1 = phase->type( node->in(1) );
 209     const Type *t2 = phase->type( node->in(2) );
 210     if( t1 == Type::TOP ) return Type::TOP;
 211     if( t2 == Type::TOP ) return Type::TOP;
 212 
 213     const TypeClass* i1 = TypeHelper<TypeClass>::get_type(t1);
 214     const TypeClass* i2 = TypeHelper<TypeClass>::get_type(t2);
 215 
 216     if (t1->singleton() && t2->singleton()) {
 217       if (i1 == NULL || i2 == NULL) {
 218         return TypeInt::CC;



 219       }






 220 
 221       native_type_t val1 = i1->get_con();
 222       native_type_t val2 = i2->get_con();
 223       if (node->will_overflow(val1, val2)) {
 224         return TypeInt::CC;


 225       }
 226       return TypeInt::ZERO;
 227     } else if (i1 != TypeClass::top() && i2 != TypeClass::top()) {
 228       if (node->will_overflow(i1->_lo, i2->_lo)) {
 229         return TypeInt::CC;
 230       } else if (node->will_overflow(i1->_lo, i2->_hi)) {
 231         return TypeInt::CC;
 232       } else if (node->will_overflow(i1->_hi, i2->_lo)) {
 233         return TypeInt::CC;
 234       } else if (node->will_overflow(i1->_hi, i2->_hi)) {
 235         return TypeInt::CC;
 236       }
 237       return TypeInt::ZERO;



















 238     }
 239 
 240     if (!node->can_overflow(t1, t2)) {
 241       return TypeInt::ZERO;
 242     }
 243     return TypeInt::CC;











 244   }
 245 };
 246 
 247 Node* OverflowINode::Ideal(PhaseGVN* phase, bool can_reshape) {
 248   return IdealHelper<OverflowINode>::Ideal(this, phase, can_reshape);



 249 }
 250 
 251 Node* OverflowLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 252   return IdealHelper<OverflowLNode>::Ideal(this, phase, can_reshape);
 253 }



 254 
 255 const Type* OverflowINode::Value(PhaseTransform* phase) const {
 256   return IdealHelper<OverflowINode>::Value(this, phase);
 257 }

 258 
 259 const Type* OverflowLNode::Value(PhaseTransform* phase) const {
 260   return IdealHelper<OverflowLNode>::Value(this, phase);
 261 }
 262 
 263 bool OverflowAddINode::can_overflow(const Type* t1, const Type* t2) const {
 264   return OverflowHelper::can_overflow(t1, t2);
 265 }







 266 
 267 bool OverflowSubINode::can_overflow(const Type* t1, const Type* t2) const {
 268   if (in(1) == in(2)) {
 269     return false;

 270   }
 271   return OverflowHelper::can_overflow(t1, t2);
 272 }
 273 
 274 bool OverflowMulINode::can_overflow(const Type* t1, const Type* t2) const {
 275   return OverflowHelper::can_overflow(t1, t2);
 276 }
 277 
 278 bool OverflowAddLNode::can_overflow(const Type* t1, const Type* t2) const {
 279   return OverflowHelper::can_overflow(t1, t2);
 280 }





 281 
 282 bool OverflowSubLNode::can_overflow(const Type* t1, const Type* t2) const {
 283   return OverflowHelper::can_overflow(t1, t2);
 284 }
 285 
 286 bool OverflowMulLNode::can_overflow(const Type* t1, const Type* t2) const {
 287   return OverflowHelper::can_overflow(t1, t2);
 288 }
 289 
 290 const Type* OverflowINode::sub(const Type* t1, const Type* t2) const {
 291   ShouldNotReachHere();
 292   return TypeInt::CC;
 293 }
 294 
 295 const Type* OverflowLNode::sub(const Type* t1, const Type* t2) const {
 296   ShouldNotReachHere();
 297   return TypeInt::CC;
 298 }
src/share/vm/opto/mathexactnode.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File