--- old/src/share/vm/opto/mulnode.cpp 2019-02-06 17:36:04.545997493 +0100 +++ new/src/share/vm/opto/mulnode.cpp 2019-02-06 17:35:58.616045363 +0100 @@ -169,7 +169,6 @@ return mul_ring(t1,t2); // Local flavor of type multiplication } - //============================================================================= //------------------------------Ideal------------------------------------------ // Check for power-of-2 multiply, then try the regular MulNode::Ideal @@ -184,42 +183,43 @@ } // Now we have a constant Node on the right and the constant in con - if( con == 0 ) return NULL; // By zero is handled by Value call - if( con == 1 ) return NULL; // By one is handled by Identity call + if (con == 0) return NULL; // By zero is handled by Value call + if (con == 1) return NULL; // By one is handled by Identity call // Check for negative constant; if so negate the final result bool sign_flip = false; - if( con < 0 ) { - con = -con; + + unsigned int abs_con = uabs(con); + if (abs_con != (unsigned int)con) { sign_flip = true; } // Get low bit; check for being the only bit Node *res = NULL; - jint bit1 = con & -con; // Extract low bit - if( bit1 == con ) { // Found a power of 2? - res = new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) ); + unsigned int bit1 = abs_con & (0-abs_con); // Extract low bit + if (bit1 == abs_con) { // Found a power of 2? + res = new (phase->C) LShiftINode(in(1), phase->intcon(log2_intptr(bit1))); } else { // Check for constant with 2 bits set - jint bit2 = con-bit1; - bit2 = bit2 & -bit2; // Extract 2nd bit - if( bit2 + bit1 == con ) { // Found all bits in con? - Node *n1 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) ) ); - Node *n2 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit2)) ) ); - res = new (phase->C) AddINode( n2, n1 ); + unsigned int bit2 = abs_con-bit1; + bit2 = bit2 & (0-bit2); // Extract 2nd bit + if (bit2 + bit1 == abs_con) { // Found all bits in con? + Node *n1 = phase->transform( new (phase->C) LShiftINode(in(1), phase->intcon(log2_intptr(bit1)))); + Node *n2 = phase->transform( new (phase->C) LShiftINode(in(1), phase->intcon(log2_intptr(bit2)))); + res = new (phase->C) AddINode(n2, n1); - } else if (is_power_of_2(con+1)) { + } else if (is_power_of_2(abs_con+1)) { // Sleezy: power-of-2 -1. Next time be generic. - jint temp = (jint) (con + 1); - Node *n1 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(temp)) ) ); - res = new (phase->C) SubINode( n1, in(1) ); + unsigned int temp = abs_con + 1; + Node *n1 = phase->transform(new (phase->C) LShiftINode(in(1), phase->intcon(log2_intptr(temp)))); + res = new (phase->C) SubINode(n1, in(1)); } else { return MulNode::Ideal(phase, can_reshape); } } - if( sign_flip ) { // Need to negate result? + if (sign_flip) { // Need to negate result? res = phase->transform(res);// Transform, before making the zero con res = new (phase->C) SubINode(phase->intcon(0),res); } @@ -280,42 +280,42 @@ } // Now we have a constant Node on the right and the constant in con - if( con == CONST64(0) ) return NULL; // By zero is handled by Value call - if( con == CONST64(1) ) return NULL; // By one is handled by Identity call + if (con == CONST64(0)) return NULL; // By zero is handled by Value call + if (con == CONST64(1)) return NULL; // By one is handled by Identity call // Check for negative constant; if so negate the final result bool sign_flip = false; - if( con < 0 ) { - con = -con; + unsigned long abs_con = uabs(con); + if (abs_con != (unsigned long)con) { sign_flip = true; } // Get low bit; check for being the only bit Node *res = NULL; - jlong bit1 = con & -con; // Extract low bit - if( bit1 == con ) { // Found a power of 2? - res = new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit1)) ); + unsigned long bit1 = abs_con & (0-abs_con); // Extract low bit + if (bit1 == abs_con) { // Found a power of 2? + res = new (phase->C) LShiftLNode(in(1), phase->intcon(log2_long(bit1))); } else { // Check for constant with 2 bits set - jlong bit2 = con-bit1; - bit2 = bit2 & -bit2; // Extract 2nd bit - if( bit2 + bit1 == con ) { // Found all bits in con? - Node *n1 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit1)) ) ); - Node *n2 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit2)) ) ); - res = new (phase->C) AddLNode( n2, n1 ); + unsigned long bit2 = abs_con-bit1; + bit2 = bit2 & (0-bit2); // Extract 2nd bit + if (bit2 + bit1 == abs_con) { // Found all bits in con? + Node *n1 = phase->transform(new (phase->C) LShiftLNode(in(1), phase->intcon(log2_long(bit1)))); + Node *n2 = phase->transform(new (phase->C) LShiftLNode(in(1), phase->intcon(log2_long(bit2)))); + res = new (phase->C) AddLNode(n2, n1); - } else if (is_power_of_2_long(con+1)) { + } else if (is_power_of_2_long(abs_con+1)) { // Sleezy: power-of-2 -1. Next time be generic. - jlong temp = (jlong) (con + 1); - Node *n1 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(temp)) ) ); - res = new (phase->C) SubLNode( n1, in(1) ); + unsigned long temp = abs_con + 1; + Node *n1 = phase->transform( new (phase->C) LShiftLNode(in(1), phase->intcon(log2_long(temp)))); + res = new (phase->C) SubLNode(n1, in(1)); } else { return MulNode::Ideal(phase, can_reshape); } } - if( sign_flip ) { // Need to negate result? + if (sign_flip) { // Need to negate result? res = phase->transform(res);// Transform, before making the zero con res = new (phase->C) SubLNode(phase->longcon(0),res); } --- old/src/share/vm/utilities/globalDefinitions.hpp 2019-02-06 17:36:09.768955332 +0100 +++ new/src/share/vm/utilities/globalDefinitions.hpp 2019-02-06 17:36:04.630996807 +0100 @@ -1136,10 +1136,10 @@ //* largest i such that 2^i <= x // A negative value of 'x' will return '31' -inline int log2_intptr(intptr_t x) { +inline int log2_intptr(uintptr_t x) { int i = -1; uintptr_t p = 1; - while (p != 0 && p <= (uintptr_t)x) { + while (p != 0 && p <= x) { // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) i++; p *= 2; } @@ -1150,10 +1150,10 @@ //* largest i such that 2^i <= x // A negative value of 'x' will return '63' -inline int log2_long(jlong x) { +inline int log2_long(unsigned long x) { int i = -1; julong p = 1; - while (p != 0 && p <= (julong)x) { + while (p != 0 && p <= x) { // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) i++; p *= 2; } @@ -1162,6 +1162,22 @@ return i; } +inline int log2_intptr(intptr_t x) { + return log2_intptr((uintptr_t)x); +} + +inline int log2_intptr(int x) { + return log2_intptr((uintptr_t)x); +} + +inline int log2_intptr(uint x) { + return log2_intptr((uintptr_t)x); +} + +inline int log2_long(jlong x) { + return log2_long((unsigned long)x); +} + //* the argument must be exactly a power of 2 inline int exact_log2(intptr_t x) { #ifdef ASSERT @@ -1201,6 +1217,29 @@ inline bool is_odd (intx x) { return x & 1; } inline bool is_even(intx x) { return !is_odd(x); } +// abs methods which cannot overflow and so are well-defined across +// the entire domain of integer types. +static inline unsigned int uabs(unsigned int n) { + union { + unsigned int result; + int value; + }; + result = n; + if (value < 0) result = 0-result; + return result; +} +static inline unsigned long uabs(unsigned long n) { + union { + unsigned long result; + long value; + }; + result = n; + if (value < 0) result = 0-result; + return result; +} +static inline unsigned long uabs(jlong n) { return uabs((unsigned long)n); } +static inline unsigned int uabs(int n) { return uabs((unsigned int)n); } + // "to" should be greater than "from." inline intx byte_size(void* from, void* to) { return (address)to - (address)from;