src/share/vm/opto/mathexactnode.cpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File
*** old/src/share/vm/opto/mathexactnode.cpp	Thu Jan 23 12:10:15 2014
--- new/src/share/vm/opto/mathexactnode.cpp	Thu Jan 23 12:10:15 2014

*** 29,430 **** --- 29,305 ---- #include "opto/machnode.hpp" #include "opto/matcher.hpp" #include "opto/mathexactnode.hpp" #include "opto/subnode.hpp" ! MathExactNode::MathExactNode(Node* ctrl, Node* in1) : MultiNode(2) { init_class_id(Class_MathExact); init_req(0, ctrl); init_req(1, in1); ! OverflowNode::OverflowNode(Node* in1) : CmpNode(in1, in1) { } ! MathExactNode::MathExactNode(Node* ctrl, Node* in1, Node* in2) : MultiNode(3) { init_class_id(Class_MathExact); init_req(0, ctrl); init_req(1, in1); init_req(2, in2); ! OverflowNode::OverflowNode(Node* in1, Node* in2) : CmpNode(in1, in2) { } ! BoolNode* MathExactNode::bool_node() const { ! Node* flags = flags_node(); ! BoolNode* boolnode = flags->unique_out()->as_Bool(); assert(boolnode != NULL, "must have BoolNode"); return boolnode; ! bool OverflowINode::will_overflow(jint v1, jint v2) const { ! ShouldNotReachHere(); ! return true; } ! IfNode* MathExactNode::if_node() const { ! BoolNode* boolnode = bool_node(); ! IfNode* ifnode = boolnode->unique_out()->as_If(); assert(ifnode != NULL, "must have IfNode"); return ifnode; ! bool OverflowLNode::will_overflow(jlong v1, jlong v2) const { ! ShouldNotReachHere(); ! return true; } ! Node* MathExactNode::control_node() const { ! IfNode* ifnode = if_node(); ! return ifnode->in(0); ! bool OverflowINode::can_overflow(const Type* t1, const Type* t2) const { ! ShouldNotReachHere(); ! return true; } ! Node* MathExactNode::non_throwing_branch() const { ! IfNode* ifnode = if_node(); if (bool_node()->_test._test == BoolTest::overflow) { return ifnode->proj_out(0); } return ifnode->proj_out(1); ! bool OverflowLNode::can_overflow(const Type* t1, const Type* t2) const { ! ShouldNotReachHere(); + return true; } // If the MathExactNode won't overflow we have to replace the // FlagsProjNode and ProjNode that is generated by the MathExactNode Node* MathExactNode::no_overflow(PhaseGVN* phase, Node* new_result) { PhaseIterGVN* igvn = phase->is_IterGVN(); if (igvn) { ProjNode* result = result_node(); ProjNode* flags = flags_node(); if (result != NULL) { igvn->replace_node(result, new_result); } if (flags != NULL) { BoolNode* boolnode = bool_node(); switch (boolnode->_test._test) { case BoolTest::overflow: // if the check is for overflow - never taken igvn->replace_node(boolnode, phase->intcon(0)); break; case BoolTest::no_overflow: // if the check is for no overflow - always taken igvn->replace_node(boolnode, phase->intcon(1)); break; default: fatal("Unexpected value of BoolTest"); break; } flags->del_req(0); } + bool OverflowAddINode::will_overflow(jint v1, jint v2) const { + jint result = v1 + v2; + // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result + if ( (((v1 ^ result) & (v2 ^ result)) >= 0)) { + return false; } ! return new_result; ! return true; } ! Node* MathExactINode::match(const ProjNode* proj, const Matcher* m) { ! uint ideal_reg = proj->ideal_reg(); RegMask rm; if (proj->_con == result_proj_node) { rm = m->mathExactI_result_proj_mask(); } else { assert(proj->_con == flags_proj_node, "must be result or flags"); assert(ideal_reg == Op_RegFlags, "sanity"); rm = m->mathExactI_flags_proj_mask(); ! bool OverflowSubINode::will_overflow(jint v1, jint v2) const { ! jint result = v1 - v2; + // Hacker's Delight 2-12 Overflow iff the arguments have different signs and + // the sign of the result is different than the sign of arg1 + if (((v1 ^ v2) & (v1 ^ result)) >= 0) { + return false; } ! return new (m->C) MachProjNode(this, proj->_con, rm, ideal_reg); ! return true; } ! Node* MathExactLNode::match(const ProjNode* proj, const Matcher* m) { ! uint ideal_reg = proj->ideal_reg(); RegMask rm; if (proj->_con == result_proj_node) { rm = m->mathExactL_result_proj_mask(); } else { assert(proj->_con == flags_proj_node, "must be result or flags"); assert(ideal_reg == Op_RegFlags, "sanity"); rm = m->mathExactI_flags_proj_mask(); ! bool OverflowMulINode::will_overflow(jint v1, jint v2) const { ! jlong result = (jlong) v1 * (jlong) v2; + if ((jint) result == result) { + return false; } ! return new (m->C) MachProjNode(this, proj->_con, rm, ideal_reg); ! return true; } ! Node* AddExactINode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node* arg1 = in(1); Node* arg2 = in(2); const Type* type1 = phase->type(arg1); const Type* type2 = phase->type(arg2); if (type1 != Type::TOP && type1->singleton() && type2 != Type::TOP && type2->singleton()) { jint val1 = arg1->get_int(); jint val2 = arg2->get_int(); jint result = val1 + val2; ! bool OverflowAddLNode::will_overflow(jlong v1, jlong v2) const { ! jlong result = v1 + v2; // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result ! if ( (((val1 ^ result) & (val2 ^ result)) >= 0)) { ! Node* con_result = ConINode::make(phase->C, result); return no_overflow(phase, con_result); ! if ( (((v1 ^ result) & (v2 ^ result)) >= 0)) { ! return false; } ! return NULL; } if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) { // (Add 0 x) == x Node* add_result = new (phase->C) AddINode(arg1, arg2); return no_overflow(phase, add_result); } if (type2->singleton()) { return NULL; // no change - keep constant on the right } if (type1->singleton()) { // Make it x + Constant - move constant to the right swap_edges(1, 2); return this; } if (arg2->is_Load()) { return NULL; // no change - keep load on the right } if (arg1->is_Load()) { // Make it x + Load - move load to the right swap_edges(1, 2); return this; } if (arg1->_idx > arg2->_idx) { // Sort the edges swap_edges(1, 2); return this; } return NULL; ! return true; } ! Node* AddExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node* arg1 = in(1); Node* arg2 = in(2); const Type* type1 = phase->type(arg1); ! const Type* type2 = phase->type(arg2); if (type1 != Type::TOP && type1->singleton() && type2 != Type::TOP && type2->singleton()) { jlong val1 = arg1->get_long(); jlong val2 = arg2->get_long(); jlong result = val1 + val2; // Hacker's Delight 2-12 Overflow if both arguments have the opposite sign of the result if ( (((val1 ^ result) & (val2 ^ result)) >= 0)) { Node* con_result = ConLNode::make(phase->C, result); return no_overflow(phase, con_result); } return NULL; } if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) { // (Add 0 x) == x Node* add_result = new (phase->C) AddLNode(arg1, arg2); return no_overflow(phase, add_result); } if (type2->singleton()) { return NULL; // no change - keep constant on the right } if (type1->singleton()) { // Make it x + Constant - move constant to the right swap_edges(1, 2); return this; ! bool OverflowSubLNode::will_overflow(jlong v1, jlong v2) const { ! jlong result = v1 - v2; + // Hacker's Delight 2-12 Overflow iff the arguments have different signs and + // the sign of the result is different than the sign of arg1 + if (((v1 ^ v2) & (v1 ^ result)) >= 0) { ! return false; } + return true; + } ! if (arg2->is_Load()) { return NULL; // no change - keep load on the right } ! bool OverflowMulLNode::will_overflow(jlong val1, jlong val2) const { + jlong result = val1 * val2; + jlong ax = (val1 < 0 ? -val1 : val1); + jlong ay = (val2 < 0 ? -val2 : val2); if (arg1->is_Load()) { // Make it x + Load - move load to the right swap_edges(1, 2); return this; + bool overflow = false; + if ((ax | ay) & CONST64(0xFFFFFFFF00000000)) { + // potential overflow if any bit in upper 32 bits are set + if ((val1 == min_jlong && val2 == -1) || (val2 == min_jlong && val1 == -1)) { + // -1 * Long.MIN_VALUE will overflow + overflow = true; + } else if (val2 != 0 && (result / val2 != val1)) { + overflow = true; } if (arg1->_idx > arg2->_idx) { // Sort the edges swap_edges(1, 2); return this; } ! return NULL; ! return overflow; } ! Node* SubExactINode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node* OverflowINode::Ideal(PhaseGVN* phase, bool can_reshape) { Node* arg1 = in(1); Node* arg2 = in(2); const Type* type1 = phase->type(arg1); const Type* type2 = phase->type(arg2); if (type1 != Type::TOP && type1->singleton() && type2 != Type::TOP && type2->singleton()) { jint val1 = arg1->get_int(); jint val2 = arg2->get_int(); jint result = val1 - val2; // Hacker's Delight 2-12 Overflow iff the arguments have different signs and // the sign of the result is different than the sign of arg1 if (((val1 ^ val2) & (val1 ^ result)) >= 0) { Node* con_result = ConINode::make(phase->C, result); return no_overflow(phase, con_result); + if (will_overflow(val1, val2) == false) { + Node* con_result = ConINode::make(phase->C, 0); + return con_result; } return NULL; } if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) { // Sub with zero is the same as add with zero Node* add_result = new (phase->C) AddINode(arg1, arg2); return no_overflow(phase, add_result); } return NULL; } ! Node* SubExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node* OverflowLNode::Ideal(PhaseGVN* phase, bool can_reshape) { Node* arg1 = in(1); Node* arg2 = in(2); const Type* type1 = phase->type(arg1); const Type* type2 = phase->type(arg2); if (type1 != Type::TOP && type1->singleton() && type2 != Type::TOP && type2->singleton()) { jlong val1 = arg1->get_long(); jlong val2 = arg2->get_long(); jlong result = val1 - val2; // Hacker's Delight 2-12 Overflow iff the arguments have different signs and // the sign of the result is different than the sign of arg1 if (((val1 ^ val2) & (val1 ^ result)) >= 0) { Node* con_result = ConLNode::make(phase->C, result); return no_overflow(phase, con_result); + if (will_overflow(val1, val2) == false) { + Node* con_result = ConINode::make(phase->C, 0); + return con_result; } return NULL; } if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) { // Sub with zero is the same as add with zero Node* add_result = new (phase->C) AddLNode(arg1, arg2); return no_overflow(phase, add_result); } return NULL; } ! Node* NegExactINode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node *arg = in(1); ! const Type* OverflowINode::Value(PhaseTransform* phase) const { ! const Type *t1 = phase->type( in(1) ); + const Type *t2 = phase->type( in(2) ); + if( t1 == Type::TOP ) return Type::TOP; + if( t2 == Type::TOP ) return Type::TOP; ! const Type* type = phase->type(arg); if (type != Type::TOP && type->singleton()) { jint value = arg->get_int(); if (value != min_jint) { Node* neg_result = ConINode::make(phase->C, -value); return no_overflow(phase, neg_result); } } return NULL; } ! const TypeInt *i1 = t1->isa_int(); + const TypeInt *i2 = t2->isa_int(); ! Node* NegExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) { Node *arg = in(1); ! if (t1->singleton() && t2->singleton()) { + if (i1 == NULL || i2 == NULL) { + return TypeInt::CC; + } ! const Type* type = phase->type(arg); if (type != Type::TOP && type->singleton()) { jlong value = arg->get_long(); if (value != min_jlong) { Node* neg_result = ConLNode::make(phase->C, -value); return no_overflow(phase, neg_result); ! jint val1 = i1->get_con(); + jint val2 = i2->get_con(); + if (will_overflow(val1, val2)) { + return TypeInt::CC; } + return TypeInt::ZERO; + } else if (i1 != TypeInt::INT && i2 != TypeInt::INT) { + if (will_overflow(i1->_lo, i2->_lo)) { + return TypeInt::CC; + } else if (will_overflow(i1->_lo, i2->_hi)) { + return TypeInt::CC; + } else if (will_overflow(i1->_hi, i2->_lo)) { + return TypeInt::CC; + } else if (will_overflow(i1->_hi, i2->_hi)) { + return TypeInt::CC; } ! return NULL; ! return TypeInt::ZERO; + } + + if (!can_overflow(t1, t2)) { + return TypeInt::ZERO; + } + return TypeInt::CC; } ! Node* MulExactINode::Ideal(PhaseGVN* phase, bool can_reshape) { ! Node* arg1 = in(1); ! Node* arg2 = in(2); ! const Type* OverflowLNode::Value(PhaseTransform* phase) const { ! const Type *t1 = phase->type( in(1) ); ! const Type *t2 = phase->type( in(2) ); + if( t1 == Type::TOP ) return Type::TOP; + if( t2 == Type::TOP ) return Type::TOP; ! const Type* type1 = phase->type(arg1); ! const Type* type2 = phase->type(arg2); ! const TypeLong *i1 = t1->isa_long(); ! const TypeLong *i2 = t2->isa_long(); ! if (type1 != Type::TOP && type1->singleton() && ! type2 != Type::TOP && type2->singleton()) { ! jint val1 = arg1->get_int(); jint val2 = arg2->get_int(); jlong result = (jlong) val1 * (jlong) val2; if ((jint) result == result) { // no overflow Node* mul_result = ConINode::make(phase->C, result); return no_overflow(phase, mul_result); } ! if (t1->singleton() && t2->singleton()) { ! if (i1 == NULL || i2 == NULL) { ! return TypeInt::CC; } if (type1 == TypeInt::ZERO || type2 == TypeInt::ZERO) { ! return no_overflow(phase, ConINode::make(phase->C, 0)); + jlong val1 = i1->get_con(); ! jlong val2 = i2->get_con(); + if (will_overflow(val1, val2)) { + return TypeInt::CC; } ! if (type1 == TypeInt::ONE) { Node* mul_result = new (phase->C) AddINode(arg2, phase->intcon(0)); ! return no_overflow(phase, mul_result); + return TypeInt::ZERO; ! } else if (i1 != TypeLong::LONG && i2 != TypeLong::LONG) { + if (will_overflow(i1->_lo, i2->_lo)) { ! return TypeInt::CC; + } else if (will_overflow(i1->_lo, i2->_hi)) { + return TypeInt::CC; + } else if (will_overflow(i1->_hi, i2->_lo)) { + return TypeInt::CC; + } else if (will_overflow(i1->_hi, i2->_hi)) { + return TypeInt::CC; } if (type2 == TypeInt::ONE) { Node* mul_result = new (phase->C) AddINode(arg1, phase->intcon(0)); return no_overflow(phase, mul_result); + return TypeInt::ZERO; } if (type1 == TypeInt::MINUS_1) { return new (phase->C) NegExactINode(NULL, arg2); + if (!can_overflow(t1, t2)) { + return TypeInt::ZERO; } + return TypeInt::CC; + } ! if (type2 == TypeInt::MINUS_1) { return new (phase->C) NegExactINode(NULL, arg1); ! bool OverflowAddINode::can_overflow(const Type* t1, const Type* t2) const { + if (t1 == TypeInt::ZERO || t2 == TypeInt::ZERO) { + return false; } return NULL; + return true; } ! Node* MulExactLNode::Ideal(PhaseGVN* phase, bool can_reshape) { Node* arg1 = in(1); ! Node* arg2 = in(2); const Type* type1 = phase->type(arg1); const Type* type2 = phase->type(arg2); if (type1 != Type::TOP && type1->singleton() && type2 != Type::TOP && type2->singleton()) { jlong val1 = arg1->get_long(); jlong val2 = arg2->get_long(); jlong result = val1 * val2; jlong ax = (val1 < 0 ? -val1 : val1); jlong ay = (val2 < 0 ? -val2 : val2); bool overflow = false; if ((ax | ay) & CONST64(0xFFFFFFFF00000000)) { // potential overflow if any bit in upper 32 bits are set if ((val1 == min_jlong && val2 == -1) || (val2 == min_jlong && val1 == -1)) { // -1 * Long.MIN_VALUE will overflow overflow = true; } else if (val2 != 0 && (result / val2 != val1)) { overflow = true; } ! bool OverflowSubINode::can_overflow(const Type* t1, const Type* t2) const { + if (in(1) == in(2)) { ! return false; } ! if (!overflow) { ! Node* mul_result = ConLNode::make(phase->C, result); return no_overflow(phase, mul_result); } ! if (t2 == TypeInt::ZERO) { ! return false; } + return true; + } ! if (type1 == TypeLong::ZERO || type2 == TypeLong::ZERO) { return no_overflow(phase, ConLNode::make(phase->C, 0)); ! bool OverflowMulINode::can_overflow(const Type* t1, const Type* t2) const { + if (t1 == TypeInt::ZERO || t2 == TypeInt::ZERO) { + return false; + } else if (t1 == TypeInt::ONE || t2 == TypeInt::ONE) { + return false; } + return true; + } ! if (type1 == TypeLong::ONE) { Node* mul_result = new (phase->C) AddLNode(arg2, phase->longcon(0)); ! return no_overflow(phase, mul_result); ! bool OverflowAddLNode::can_overflow(const Type* t1, const Type* t2) const { + if (t1 == TypeLong::ZERO || t2 == TypeLong::ZERO) { ! return false; } if (type2 == TypeLong::ONE) { Node* mul_result = new (phase->C) AddLNode(arg1, phase->longcon(0)); return no_overflow(phase, mul_result); + return true; + } + + bool OverflowSubLNode::can_overflow(const Type* t1, const Type* t2) const { + if (in(1) == in(2)) { + return false; } ! if (type1 == TypeLong::MINUS_1) { ! return new (phase->C) NegExactLNode(NULL, arg2); ! if (t2 == TypeLong::ZERO) { ! return false; } + return true; + } ! if (type2 == TypeLong::MINUS_1) { return new (phase->C) NegExactLNode(NULL, arg1); ! bool OverflowMulLNode::can_overflow(const Type* t1, const Type* t2) const { + if (t1 == TypeLong::ZERO || t2 == TypeLong::ZERO) { + return false; + } else if (t1 == TypeLong::ONE || t2 == TypeLong::ONE) { + return false; } + return true; + } return NULL; + const Type* OverflowINode::sub(const Type* t1, const Type* t2) const { + ShouldNotReachHere(); + return TypeInt::CC; } + const Type* OverflowLNode::sub(const Type* t1, const Type* t2) const { + ShouldNotReachHere(); + return TypeInt::CC; + }

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