hotspot/src/share/vm/opto/divnode.cpp
Print this page
rev 611 : Merge
*** 1,10 ****
#ifdef USE_PRAGMA_IDENT_SRC
#pragma ident "@(#)divnode.cpp 1.88 07/05/05 17:06:13 JVM"
#endif
/*
! * Copyright 1997-2006 Sun Microsystems, Inc. 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.
--- 1,10 ----
#ifdef USE_PRAGMA_IDENT_SRC
#pragma ident "@(#)divnode.cpp 1.88 07/05/05 17:06:13 JVM"
#endif
/*
! * Copyright 1997-2009 Sun Microsystems, Inc. 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.
*** 31,153 ****
#include "incls/_precompiled.incl"
#include "incls/_divnode.cpp.incl"
#include <math.h>
! // Implement the integer constant divide -> long multiply transform found in
! // "Division by Invariant Integers using Multiplication"
! // by Granlund and Montgomery
! static Node *transform_int_divide_to_long_multiply( PhaseGVN *phase, Node *dividend, int divisor ) {
// Check for invalid divisors
! assert( divisor != 0 && divisor != min_jint && divisor != 1,
"bad divisor for transforming to long multiply" );
- // Compute l = ceiling(log2(d))
- // presumes d is more likely small
bool d_pos = divisor >= 0;
! int d = d_pos ? divisor : -divisor;
! unsigned ud = (unsigned)d;
const int N = 32;
int l = log2_intptr(d-1)+1;
! int sh_post = l;
! const uint64_t U1 = (uint64_t)1;
! // Cliff pointed out how to prevent overflow (from the paper)
! uint64_t m_low = (((U1 << l) - ud) << N) / ud + (U1 << N);
! uint64_t m_high = ((((U1 << l) - ud) << N) + (U1 << (l+1))) / ud + (U1 << N);
!
! // Reduce to lowest terms
! for ( ; sh_post > 0; sh_post-- ) {
! uint64_t m_low_1 = m_low >> 1;
! uint64_t m_high_1 = m_high >> 1;
! if ( m_low_1 >= m_high_1 )
! break;
! m_low = m_low_1;
! m_high = m_high_1;
}
// Result
! Node *q;
- // division by +/- 1
if (d == 1) {
! // Filtered out as identity above
! if (d_pos)
! return NULL;
!
// Just negate the value
! else {
! q = new (phase->C, 3) SubINode(phase->intcon(0), dividend);
! }
}
// division by +/- a power of 2
- else if ( is_power_of_2(d) ) {
// See if we can simply do a shift without rounding
bool needs_rounding = true;
const Type *dt = phase->type(dividend);
! const TypeInt *dti = dt->isa_int();
// we don't need to round a positive dividend
- if (dti && dti->_lo >= 0)
needs_rounding = false;
!
// An AND mask of sufficient size clears the low bits and
// I can avoid rounding.
! else if( dividend->Opcode() == Op_AndI ) {
! const TypeInt *andconi = phase->type( dividend->in(2) )->isa_int();
! if( andconi && andconi->is_con(-d) ) {
dividend = dividend->in(1);
needs_rounding = false;
}
}
// Add rounding to the shift to handle the sign bit
! if( needs_rounding ) {
! Node *t1 = phase->transform(new (phase->C, 3) RShiftINode(dividend, phase->intcon(l - 1)));
! Node *t2 = phase->transform(new (phase->C, 3) URShiftINode(t1, phase->intcon(N - l)));
! dividend = phase->transform(new (phase->C, 3) AddINode(dividend, t2));
}
! q = new (phase->C, 3) RShiftINode(dividend, phase->intcon(l));
! if (!d_pos)
! q = new (phase->C, 3) SubINode(phase->intcon(0), phase->transform(q));
}
! // division by something else
! else if (m_high < (U1 << (N-1))) {
! Node *t1 = phase->transform(new (phase->C, 2) ConvI2LNode(dividend));
! Node *t2 = phase->transform(new (phase->C, 3) MulLNode(t1, phase->longcon(m_high)));
! Node *t3 = phase->transform(new (phase->C, 3) RShiftLNode(t2, phase->intcon(sh_post+N)));
! Node *t4 = phase->transform(new (phase->C, 2) ConvL2INode(t3));
! Node *t5 = phase->transform(new (phase->C, 3) RShiftINode(dividend, phase->intcon(N-1)));
!
! q = new (phase->C, 3) SubINode(d_pos ? t4 : t5, d_pos ? t5 : t4);
! }
!
! // This handles that case where m_high is >= 2**(N-1). In that case,
! // we subtract out 2**N from the multiply and add it in later as
! // "dividend" in the equation (t5). This case computes the same result
! // as the immediately preceeding case, save that rounding and overflow
! // are accounted for.
! else {
! Node *t1 = phase->transform(new (phase->C, 2) ConvI2LNode(dividend));
! Node *t2 = phase->transform(new (phase->C, 3) MulLNode(t1, phase->longcon(m_high - (U1 << N))));
! Node *t3 = phase->transform(new (phase->C, 3) RShiftLNode(t2, phase->intcon(N)));
! Node *t4 = phase->transform(new (phase->C, 2) ConvL2INode(t3));
! Node *t5 = phase->transform(new (phase->C, 3) AddINode(dividend, t4));
! Node *t6 = phase->transform(new (phase->C, 3) RShiftINode(t5, phase->intcon(sh_post)));
! Node *t7 = phase->transform(new (phase->C, 3) RShiftINode(dividend, phase->intcon(N-1)));
! q = new (phase->C, 3) SubINode(d_pos ? t6 : t7, d_pos ? t7 : t6);
}
! return (q);
}
//=============================================================================
//------------------------------Identity---------------------------------------
// If the divisor is 1, we are an identity on the dividend.
--- 31,405 ----
#include "incls/_precompiled.incl"
#include "incls/_divnode.cpp.incl"
#include <math.h>
! //----------------------magic_int_divide_constants-----------------------------
! // Compute magic multiplier and shift constant for converting a 32 bit divide
! // by constant into a multiply/shift/add series. Return false if calculations
! // fail.
! //
! // Borrowed almost verbatum from Hacker's Delight by Henry S. Warren, Jr. with
! // minor type name and parameter changes.
! static bool magic_int_divide_constants(jint d, jint &M, jint &s) {
! int32_t p;
! uint32_t ad, anc, delta, q1, r1, q2, r2, t;
! const uint32_t two31 = 0x80000000L; // 2**31.
!
! ad = ABS(d);
! if (d == 0 || d == 1) return false;
! t = two31 + ((uint32_t)d >> 31);
! anc = t - 1 - t%ad; // Absolute value of nc.
! p = 31; // Init. p.
! q1 = two31/anc; // Init. q1 = 2**p/|nc|.
! r1 = two31 - q1*anc; // Init. r1 = rem(2**p, |nc|).
! q2 = two31/ad; // Init. q2 = 2**p/|d|.
! r2 = two31 - q2*ad; // Init. r2 = rem(2**p, |d|).
! do {
! p = p + 1;
! q1 = 2*q1; // Update q1 = 2**p/|nc|.
! r1 = 2*r1; // Update r1 = rem(2**p, |nc|).
! if (r1 >= anc) { // (Must be an unsigned
! q1 = q1 + 1; // comparison here).
! r1 = r1 - anc;
! }
! q2 = 2*q2; // Update q2 = 2**p/|d|.
! r2 = 2*r2; // Update r2 = rem(2**p, |d|).
! if (r2 >= ad) { // (Must be an unsigned
! q2 = q2 + 1; // comparison here).
! r2 = r2 - ad;
! }
! delta = ad - r2;
! } while (q1 < delta || (q1 == delta && r1 == 0));
!
! M = q2 + 1;
! if (d < 0) M = -M; // Magic number and
! s = p - 32; // shift amount to return.
!
! return true;
! }
!
! //--------------------------transform_int_divide-------------------------------
! // Convert a division by constant divisor into an alternate Ideal graph.
! // Return NULL if no transformation occurs.
! static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor ) {
// Check for invalid divisors
! assert( divisor != 0 && divisor != min_jint,
"bad divisor for transforming to long multiply" );
bool d_pos = divisor >= 0;
! jint d = d_pos ? divisor : -divisor;
const int N = 32;
+
+ // Result
+ Node *q = NULL;
+
+ if (d == 1) {
+ // division by +/- 1
+ if (!d_pos) {
+ // Just negate the value
+ q = new (phase->C, 3) SubINode(phase->intcon(0), dividend);
+ }
+ } else if ( is_power_of_2(d) ) {
+ // division by +/- a power of 2
+
+ // See if we can simply do a shift without rounding
+ bool needs_rounding = true;
+ const Type *dt = phase->type(dividend);
+ const TypeInt *dti = dt->isa_int();
+ if (dti && dti->_lo >= 0) {
+ // we don't need to round a positive dividend
+ needs_rounding = false;
+ } else if( dividend->Opcode() == Op_AndI ) {
+ // An AND mask of sufficient size clears the low bits and
+ // I can avoid rounding.
+ const TypeInt *andconi_t = phase->type( dividend->in(2) )->isa_int();
+ if( andconi_t && andconi_t->is_con() ) {
+ jint andconi = andconi_t->get_con();
+ if( andconi < 0 && is_power_of_2(-andconi) && (-andconi) >= d ) {
+ dividend = dividend->in(1);
+ needs_rounding = false;
+ }
+ }
+ }
+
+ // Add rounding to the shift to handle the sign bit
int l = log2_intptr(d-1)+1;
! if (needs_rounding) {
! // Divide-by-power-of-2 can be made into a shift, but you have to do
! // more math for the rounding. You need to add 0 for positive
! // numbers, and "i-1" for negative numbers. Example: i=4, so the
! // shift is by 2. You need to add 3 to negative dividends and 0 to
! // positive ones. So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1,
! // (-2+3)>>2 becomes 0, etc.
!
! // Compute 0 or -1, based on sign bit
! Node *sign = phase->transform(new (phase->C, 3) RShiftINode(dividend, phase->intcon(N - 1)));
! // Mask sign bit to the low sign bits
! Node *round = phase->transform(new (phase->C, 3) URShiftINode(sign, phase->intcon(N - l)));
! // Round up before shifting
! dividend = phase->transform(new (phase->C, 3) AddINode(dividend, round));
! }
! // Shift for division
! q = new (phase->C, 3) RShiftINode(dividend, phase->intcon(l));
! if (!d_pos) {
! q = new (phase->C, 3) SubINode(phase->intcon(0), phase->transform(q));
! }
! } else {
! // Attempt the jint constant divide -> multiply transform found in
! // "Division by Invariant Integers using Multiplication"
! // by Granlund and Montgomery
! // See also "Hacker's Delight", chapter 10 by Warren.
!
! jint magic_const;
! jint shift_const;
! if (magic_int_divide_constants(d, magic_const, shift_const)) {
! Node *magic = phase->longcon(magic_const);
! Node *dividend_long = phase->transform(new (phase->C, 2) ConvI2LNode(dividend));
!
! // Compute the high half of the dividend x magic multiplication
! Node *mul_hi = phase->transform(new (phase->C, 3) MulLNode(dividend_long, magic));
!
! if (magic_const < 0) {
! mul_hi = phase->transform(new (phase->C, 3) RShiftLNode(mul_hi, phase->intcon(N)));
! mul_hi = phase->transform(new (phase->C, 2) ConvL2INode(mul_hi));
!
! // The magic multiplier is too large for a 32 bit constant. We've adjusted
! // it down by 2^32, but have to add 1 dividend back in after the multiplication.
! // This handles the "overflow" case described by Granlund and Montgomery.
! mul_hi = phase->transform(new (phase->C, 3) AddINode(dividend, mul_hi));
!
! // Shift over the (adjusted) mulhi
! if (shift_const != 0) {
! mul_hi = phase->transform(new (phase->C, 3) RShiftINode(mul_hi, phase->intcon(shift_const)));
}
+ } else {
+ // No add is required, we can merge the shifts together.
+ mul_hi = phase->transform(new (phase->C, 3) RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
+ mul_hi = phase->transform(new (phase->C, 2) ConvL2INode(mul_hi));
+ }
+
+ // Get a 0 or -1 from the sign of the dividend.
+ Node *addend0 = mul_hi;
+ Node *addend1 = phase->transform(new (phase->C, 3) RShiftINode(dividend, phase->intcon(N-1)));
+
+ // If the divisor is negative, swap the order of the input addends;
+ // this has the effect of negating the quotient.
+ if (!d_pos) {
+ Node *temp = addend0; addend0 = addend1; addend1 = temp;
+ }
+
+ // Adjust the final quotient by subtracting -1 (adding 1)
+ // from the mul_hi.
+ q = new (phase->C, 3) SubINode(addend0, addend1);
+ }
+ }
+
+ return q;
+ }
+
+ //---------------------magic_long_divide_constants-----------------------------
+ // Compute magic multiplier and shift constant for converting a 64 bit divide
+ // by constant into a multiply/shift/add series. Return false if calculations
+ // fail.
+ //
+ // Borrowed almost verbatum from Hacker's Delight by Henry S. Warren, Jr. with
+ // minor type name and parameter changes. Adjusted to 64 bit word width.
+ static bool magic_long_divide_constants(jlong d, jlong &M, jint &s) {
+ int64_t p;
+ uint64_t ad, anc, delta, q1, r1, q2, r2, t;
+ const uint64_t two63 = 0x8000000000000000LL; // 2**63.
+
+ ad = ABS(d);
+ if (d == 0 || d == 1) return false;
+ t = two63 + ((uint64_t)d >> 63);
+ anc = t - 1 - t%ad; // Absolute value of nc.
+ p = 63; // Init. p.
+ q1 = two63/anc; // Init. q1 = 2**p/|nc|.
+ r1 = two63 - q1*anc; // Init. r1 = rem(2**p, |nc|).
+ q2 = two63/ad; // Init. q2 = 2**p/|d|.
+ r2 = two63 - q2*ad; // Init. r2 = rem(2**p, |d|).
+ do {
+ p = p + 1;
+ q1 = 2*q1; // Update q1 = 2**p/|nc|.
+ r1 = 2*r1; // Update r1 = rem(2**p, |nc|).
+ if (r1 >= anc) { // (Must be an unsigned
+ q1 = q1 + 1; // comparison here).
+ r1 = r1 - anc;
+ }
+ q2 = 2*q2; // Update q2 = 2**p/|d|.
+ r2 = 2*r2; // Update r2 = rem(2**p, |d|).
+ if (r2 >= ad) { // (Must be an unsigned
+ q2 = q2 + 1; // comparison here).
+ r2 = r2 - ad;
+ }
+ delta = ad - r2;
+ } while (q1 < delta || (q1 == delta && r1 == 0));
+
+ M = q2 + 1;
+ if (d < 0) M = -M; // Magic number and
+ s = p - 64; // shift amount to return.
+
+ return true;
+ }
+
+ //---------------------long_by_long_mulhi--------------------------------------
+ // Generate ideal node graph for upper half of a 64 bit x 64 bit multiplication
+ static Node *long_by_long_mulhi( PhaseGVN *phase, Node *dividend, jlong magic_const) {
+ // If the architecture supports a 64x64 mulhi, there is
+ // no need to synthesize it in ideal nodes.
+ if (Matcher::has_match_rule(Op_MulHiL)) {
+ Node *v = phase->longcon(magic_const);
+ return new (phase->C, 3) MulHiLNode(dividend, v);
+ }
+
+ const int N = 64;
+
+ Node *u_hi = phase->transform(new (phase->C, 3) RShiftLNode(dividend, phase->intcon(N / 2)));
+ Node *u_lo = phase->transform(new (phase->C, 3) AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
+
+ Node *v_hi = phase->longcon(magic_const >> N/2);
+ Node *v_lo = phase->longcon(magic_const & 0XFFFFFFFF);
+
+ Node *hihi_product = phase->transform(new (phase->C, 3) MulLNode(u_hi, v_hi));
+ Node *hilo_product = phase->transform(new (phase->C, 3) MulLNode(u_hi, v_lo));
+ Node *lohi_product = phase->transform(new (phase->C, 3) MulLNode(u_lo, v_hi));
+ Node *lolo_product = phase->transform(new (phase->C, 3) MulLNode(u_lo, v_lo));
+
+ Node *t1 = phase->transform(new (phase->C, 3) URShiftLNode(lolo_product, phase->intcon(N / 2)));
+ Node *t2 = phase->transform(new (phase->C, 3) AddLNode(hilo_product, t1));
+
+ // Construct both t3 and t4 before transforming so t2 doesn't go dead
+ // prematurely.
+ Node *t3 = new (phase->C, 3) RShiftLNode(t2, phase->intcon(N / 2));
+ Node *t4 = new (phase->C, 3) AndLNode(t2, phase->longcon(0xFFFFFFFF));
+ t3 = phase->transform(t3);
+ t4 = phase->transform(t4);
+
+ Node *t5 = phase->transform(new (phase->C, 3) AddLNode(t4, lohi_product));
+ Node *t6 = phase->transform(new (phase->C, 3) RShiftLNode(t5, phase->intcon(N / 2)));
+ Node *t7 = phase->transform(new (phase->C, 3) AddLNode(t3, hihi_product));
+
+ return new (phase->C, 3) AddLNode(t7, t6);
+ }
+
+
+ //--------------------------transform_long_divide------------------------------
+ // Convert a division by constant divisor into an alternate Ideal graph.
+ // Return NULL if no transformation occurs.
+ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divisor ) {
+ // Check for invalid divisors
+ assert( divisor != 0L && divisor != min_jlong,
+ "bad divisor for transforming to long multiply" );
+
+ bool d_pos = divisor >= 0;
+ jlong d = d_pos ? divisor : -divisor;
+ const int N = 64;
// Result
! Node *q = NULL;
if (d == 1) {
! // division by +/- 1
! if (!d_pos) {
// Just negate the value
! q = new (phase->C, 3) SubLNode(phase->longcon(0), dividend);
}
+ } else if ( is_power_of_2_long(d) ) {
// division by +/- a power of 2
// See if we can simply do a shift without rounding
bool needs_rounding = true;
const Type *dt = phase->type(dividend);
! const TypeLong *dtl = dt->isa_long();
+ if (dtl && dtl->_lo > 0) {
// we don't need to round a positive dividend
needs_rounding = false;
! } else if( dividend->Opcode() == Op_AndL ) {
// An AND mask of sufficient size clears the low bits and
// I can avoid rounding.
! const TypeLong *andconl_t = phase->type( dividend->in(2) )->isa_long();
! if( andconl_t && andconl_t->is_con() ) {
! jlong andconl = andconl_t->get_con();
! if( andconl < 0 && is_power_of_2_long(-andconl) && (-andconl) >= d ) {
dividend = dividend->in(1);
needs_rounding = false;
}
}
+ }
// Add rounding to the shift to handle the sign bit
! int l = log2_long(d-1)+1;
! if (needs_rounding) {
! // Divide-by-power-of-2 can be made into a shift, but you have to do
! // more math for the rounding. You need to add 0 for positive
! // numbers, and "i-1" for negative numbers. Example: i=4, so the
! // shift is by 2. You need to add 3 to negative dividends and 0 to
! // positive ones. So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1,
! // (-2+3)>>2 becomes 0, etc.
!
! // Compute 0 or -1, based on sign bit
! Node *sign = phase->transform(new (phase->C, 3) RShiftLNode(dividend, phase->intcon(N - 1)));
! // Mask sign bit to the low sign bits
! Node *round = phase->transform(new (phase->C, 3) URShiftLNode(sign, phase->intcon(N - l)));
! // Round up before shifting
! dividend = phase->transform(new (phase->C, 3) AddLNode(dividend, round));
}
! // Shift for division
! q = new (phase->C, 3) RShiftLNode(dividend, phase->intcon(l));
! if (!d_pos) {
! q = new (phase->C, 3) SubLNode(phase->longcon(0), phase->transform(q));
}
+ } else {
+ // Attempt the jlong constant divide -> multiply transform found in
+ // "Division by Invariant Integers using Multiplication"
+ // by Granlund and Montgomery
+ // See also "Hacker's Delight", chapter 10 by Warren.
! jlong magic_const;
! jint shift_const;
! if (magic_long_divide_constants(d, magic_const, shift_const)) {
! // Compute the high half of the dividend x magic multiplication
! Node *mul_hi = phase->transform(long_by_long_mulhi(phase, dividend, magic_const));
! // The high half of the 128-bit multiply is computed.
! if (magic_const < 0) {
! // The magic multiplier is too large for a 64 bit constant. We've adjusted
! // it down by 2^64, but have to add 1 dividend back in after the multiplication.
! // This handles the "overflow" case described by Granlund and Montgomery.
! mul_hi = phase->transform(new (phase->C, 3) AddLNode(dividend, mul_hi));
}
! // Shift over the (adjusted) mulhi
! if (shift_const != 0) {
! mul_hi = phase->transform(new (phase->C, 3) RShiftLNode(mul_hi, phase->intcon(shift_const)));
! }
!
! // Get a 0 or -1 from the sign of the dividend.
! Node *addend0 = mul_hi;
! Node *addend1 = phase->transform(new (phase->C, 3) RShiftLNode(dividend, phase->intcon(N-1)));
!
! // If the divisor is negative, swap the order of the input addends;
! // this has the effect of negating the quotient.
! if (!d_pos) {
! Node *temp = addend0; addend0 = addend1; addend1 = temp;
! }
!
! // Adjust the final quotient by subtracting -1 (adding 1)
! // from the mul_hi.
! q = new (phase->C, 3) SubLNode(addend0, addend1);
! }
! }
!
! return q;
}
//=============================================================================
//------------------------------Identity---------------------------------------
// If the divisor is 1, we are an identity on the dividend.
*** 157,184 ****
//------------------------------Idealize---------------------------------------
// Divides can be changed to multiplies and/or shifts
Node *DivINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
const Type *t = phase->type( in(2) );
if( t == TypeInt::ONE ) // Identity?
return NULL; // Skip it
const TypeInt *ti = t->isa_int();
if( !ti ) return NULL;
if( !ti->is_con() ) return NULL;
! int i = ti->get_con(); // Get divisor
if (i == 0) return NULL; // Dividing by zero constant does not idealize
set_req(0,NULL); // Dividing by a not-zero constant; no faulting
// Dividing by MININT does not optimize as a power-of-2 shift.
if( i == min_jint ) return NULL;
! return transform_int_divide_to_long_multiply( phase, in(1), i );
}
//------------------------------Value------------------------------------------
// A DivINode divides its inputs. The third input is a Control input, used to
// prevent hoisting the divide above an unsafe test.
--- 409,438 ----
//------------------------------Idealize---------------------------------------
// Divides can be changed to multiplies and/or shifts
Node *DivINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
+ // Don't bother trying to transform a dead node
+ if( in(0) && in(0)->is_top() ) return NULL;
const Type *t = phase->type( in(2) );
if( t == TypeInt::ONE ) // Identity?
return NULL; // Skip it
const TypeInt *ti = t->isa_int();
if( !ti ) return NULL;
if( !ti->is_con() ) return NULL;
! jint i = ti->get_con(); // Get divisor
if (i == 0) return NULL; // Dividing by zero constant does not idealize
set_req(0,NULL); // Dividing by a not-zero constant; no faulting
// Dividing by MININT does not optimize as a power-of-2 shift.
if( i == min_jint ) return NULL;
! return transform_int_divide( phase, in(1), i );
}
//------------------------------Value------------------------------------------
// A DivINode divides its inputs. The third input is a Control input, used to
// prevent hoisting the divide above an unsafe test.
*** 254,344 ****
//------------------------------Idealize---------------------------------------
// Dividing by a power of 2 is a shift.
Node *DivLNode::Ideal( PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
const Type *t = phase->type( in(2) );
if( t == TypeLong::ONE ) // Identity?
return NULL; // Skip it
! const TypeLong *ti = t->isa_long();
! if( !ti ) return NULL;
! if( !ti->is_con() ) return NULL;
! jlong i = ti->get_con(); // Get divisor
! if( i ) set_req(0, NULL); // Dividing by a not-zero constant; no faulting
!
! // Dividing by MININT does not optimize as a power-of-2 shift.
! if( i == min_jlong ) return NULL;
!
! // Check for negative power of 2 divisor, if so, negate it and set a flag
! // to indicate result needs to be negated. Note that negating the dividend
! // here does not work when it has the value MININT
! Node *dividend = in(1);
! bool negate_res = false;
! if (is_power_of_2_long(-i)) {
! i = -i; // Flip divisor
! negate_res = true;
! }
!
! // Check for power of 2
! if (!is_power_of_2_long(i)) // Is divisor a power of 2?
! return NULL; // Not a power of 2
! // Compute number of bits to shift
! int log_i = log2_long(i);
! // See if we can simply do a shift without rounding
! bool needs_rounding = true;
! const Type *dt = phase->type(dividend);
! const TypeLong *dtl = dt->isa_long();
!
! if (dtl && dtl->_lo > 0) {
! // we don't need to round a positive dividend
! needs_rounding = false;
! } else if( dividend->Opcode() == Op_AndL ) {
! // An AND mask of sufficient size clears the low bits and
! // I can avoid rounding.
! const TypeLong *andconi = phase->type( dividend->in(2) )->isa_long();
! if( andconi &&
! andconi->is_con() &&
! andconi->get_con() == -i ) {
! dividend = dividend->in(1);
! needs_rounding = false;
! }
! }
!
! if (!needs_rounding) {
! Node *result = new (phase->C, 3) RShiftLNode(dividend, phase->intcon(log_i));
! if (negate_res) {
! result = phase->transform(result);
! result = new (phase->C, 3) SubLNode(phase->longcon(0), result);
! }
! return result;
! }
!
! // Divide-by-power-of-2 can be made into a shift, but you have to do
! // more math for the rounding. You need to add 0 for positive
! // numbers, and "i-1" for negative numbers. Example: i=4, so the
! // shift is by 2. You need to add 3 to negative dividends and 0 to
! // positive ones. So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1,
! // (-2+3)>>2 becomes 0, etc.
! // Compute 0 or -1, based on sign bit
! Node *sign = phase->transform(new (phase->C, 3) RShiftLNode(dividend,phase->intcon(63)));
! // Mask sign bit to the low sign bits
! Node *round = phase->transform(new (phase->C, 3) AndLNode(sign,phase->longcon(i-1)));
! // Round up before shifting
! Node *sum = phase->transform(new (phase->C, 3) AddLNode(dividend,round));
! // Shift for division
! Node *result = new (phase->C, 3) RShiftLNode(sum, phase->intcon(log_i));
! if (negate_res) {
! result = phase->transform(result);
! result = new (phase->C, 3) SubLNode(phase->longcon(0), result);
! }
! return result;
}
//------------------------------Value------------------------------------------
// A DivLNode divides its inputs. The third input is a Control input, used to
// prevent hoisting the divide above an unsafe test.
--- 508,537 ----
//------------------------------Idealize---------------------------------------
// Dividing by a power of 2 is a shift.
Node *DivLNode::Ideal( PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
+ // Don't bother trying to transform a dead node
+ if( in(0) && in(0)->is_top() ) return NULL;
const Type *t = phase->type( in(2) );
if( t == TypeLong::ONE ) // Identity?
return NULL; // Skip it
! const TypeLong *tl = t->isa_long();
! if( !tl ) return NULL;
! if( !tl->is_con() ) return NULL;
! jlong l = tl->get_con(); // Get divisor
! if (l == 0) return NULL; // Dividing by zero constant does not idealize
! set_req(0,NULL); // Dividing by a not-zero constant; no faulting
! // Dividing by MININT does not optimize as a power-of-2 shift.
! if( l == min_jlong ) return NULL;
! return transform_long_divide( phase, in(1), l );
}
//------------------------------Value------------------------------------------
// A DivLNode divides its inputs. The third input is a Control input, used to
// prevent hoisting the divide above an unsafe test.
*** 422,432 ****
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
// x/x == 1, we ignore 0/0.
// Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
! // does not work for variables because of NaN's
if( phase->eqv( in(1), in(2) ) && t1->base() == Type::FloatCon)
if (!g_isnan(t1->getf()) && g_isfinite(t1->getf()) && t1->getf() != 0.0) // could be negative ZERO or NaN
return TypeF::ONE;
if( t2 == TypeF::ONE )
--- 615,625 ----
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
// x/x == 1, we ignore 0/0.
// Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
! // Does not work for variables because of NaN's
if( phase->eqv( in(1), in(2) ) && t1->base() == Type::FloatCon)
if (!g_isnan(t1->getf()) && g_isfinite(t1->getf()) && t1->getf() != 0.0) // could be negative ZERO or NaN
return TypeF::ONE;
if( t2 == TypeF::ONE )
*** 458,467 ****
--- 651,662 ----
//------------------------------Idealize---------------------------------------
Node *DivFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
+ // Don't bother trying to transform a dead node
+ if( in(0) && in(0)->is_top() ) return NULL;
const Type *t2 = phase->type( in(2) );
if( t2 == TypeF::ONE ) // Identity?
return NULL; // Skip it
*** 492,502 ****
}
//=============================================================================
//------------------------------Value------------------------------------------
// An DivDNode divides its inputs. The third input is a Control input, used to
! // prvent hoisting the divide above an unsafe test.
const Type *DivDNode::Value( PhaseTransform *phase ) const {
// Either input is TOP ==> the result is TOP
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
if( t1 == Type::TOP ) return Type::TOP;
--- 687,697 ----
}
//=============================================================================
//------------------------------Value------------------------------------------
// An DivDNode divides its inputs. The third input is a Control input, used to
! // prevent hoisting the divide above an unsafe test.
const Type *DivDNode::Value( PhaseTransform *phase ) const {
// Either input is TOP ==> the result is TOP
const Type *t1 = phase->type( in(1) );
const Type *t2 = phase->type( in(2) );
if( t1 == Type::TOP ) return Type::TOP;
*** 516,530 ****
--- 711,732 ----
return TypeD::ONE;
if( t2 == TypeD::ONE )
return t1;
+ #if defined(IA32)
+ if (!phase->C->method()->is_strict())
+ // Can't trust native compilers to properly fold strict double
+ // division with round-to-zero on this platform.
+ #endif
+ {
// If divisor is a constant and not zero, divide them numbers
if( t1->base() == Type::DoubleCon &&
t2->base() == Type::DoubleCon &&
t2->getd() != 0.0 ) // could be negative zero
return TypeD::make( t1->getd()/t2->getd() );
+ }
// If the dividend is a constant zero
// Note: if t1 and t2 are zero then result is NaN (JVMS page 213)
// Test TypeF::ZERO is not sufficient as it could be negative zero
if( t1 == TypeD::ZERO && !g_isnan(t2->getd()) && t2->getd() != 0.0 )
*** 543,552 ****
--- 745,756 ----
}
//------------------------------Idealize---------------------------------------
Node *DivDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (in(0) && remove_dead_region(phase, can_reshape)) return this;
+ // Don't bother trying to transform a dead node
+ if( in(0) && in(0)->is_top() ) return NULL;
const Type *t2 = phase->type( in(2) );
if( t2 == TypeD::ONE ) // Identity?
return NULL; // Skip it
*** 578,588 ****
//=============================================================================
//------------------------------Idealize---------------------------------------
Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Check for dead control input
! if( remove_dead_region(phase, can_reshape) ) return this;
// Get the modulus
const Type *t = phase->type( in(2) );
if( t == Type::TOP ) return NULL;
const TypeInt *ti = t->is_int();
--- 782,794 ----
//=============================================================================
//------------------------------Idealize---------------------------------------
Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Check for dead control input
! if( in(0) && remove_dead_region(phase, can_reshape) ) return this;
! // Don't bother trying to transform a dead node
! if( in(0) && in(0)->is_top() ) return NULL;
// Get the modulus
const Type *t = phase->type( in(2) );
if( t == Type::TOP ) return NULL;
const TypeInt *ti = t->is_int();
*** 676,697 ****
// Save in(1) so that it cannot be changed or deleted
hook->init_req(0, in(1));
// Divide using the transform from DivI to MulL
! Node *divide = phase->transform( transform_int_divide_to_long_multiply( phase, in(1), pos_con ) );
// Re-multiply, using a shift if this is a power of two
Node *mult = NULL;
if( log2_con >= 0 )
mult = phase->transform( new (phase->C, 3) LShiftINode( divide, phase->intcon( log2_con ) ) );
else
mult = phase->transform( new (phase->C, 3) MulINode( divide, phase->intcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original
! Node *result = new (phase->C, 3) SubINode( in(1), mult );
// Now remove the bogus extra edges used to keep things alive
if (can_reshape) {
phase->is_IterGVN()->remove_dead_node(hook);
} else {
--- 882,906 ----
// Save in(1) so that it cannot be changed or deleted
hook->init_req(0, in(1));
// Divide using the transform from DivI to MulL
! Node *result = transform_int_divide( phase, in(1), pos_con );
! if (result != NULL) {
! Node *divide = phase->transform(result);
// Re-multiply, using a shift if this is a power of two
Node *mult = NULL;
if( log2_con >= 0 )
mult = phase->transform( new (phase->C, 3) LShiftINode( divide, phase->intcon( log2_con ) ) );
else
mult = phase->transform( new (phase->C, 3) MulINode( divide, phase->intcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original
! result = new (phase->C, 3) SubINode( in(1), mult );
! }
// Now remove the bogus extra edges used to keep things alive
if (can_reshape) {
phase->is_IterGVN()->remove_dead_node(hook);
} else {
*** 744,802 ****
//=============================================================================
//------------------------------Idealize---------------------------------------
Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Check for dead control input
! if( remove_dead_region(phase, can_reshape) ) return this;
// Get the modulus
const Type *t = phase->type( in(2) );
if( t == Type::TOP ) return NULL;
! const TypeLong *ti = t->is_long();
// Check for useless control input
// Check for excluding mod-zero case
! if( in(0) && (ti->_hi < 0 || ti->_lo > 0) ) {
set_req(0, NULL); // Yank control input
return this;
}
// See if we are MOD'ing by 2^k or 2^k-1.
! if( !ti->is_con() ) return NULL;
! jlong con = ti->get_con();
! bool m1 = false;
! if( !is_power_of_2_long(con) ) { // Not 2^k
! if( !is_power_of_2_long(con+1) ) // Not 2^k-1?
! return NULL; // No interesting mod hacks
! m1 = true; // Found 2^k-1
! con++; // Convert to 2^k form
! }
! uint k = log2_long(con); // Extract k
// Expand mod
! if( !m1 ) { // Case 2^k
! } else { // Case 2^k-1
// Basic algorithm by David Detlefs. See fastmod_long.java for gory details.
// Used to help a popular random number generator which does a long-mod
// of 2^31-1 and shows up in SpecJBB and SciMark.
static int unroll_factor[] = { 999, 999, 61, 30, 20, 15, 12, 10, 8, 7, 6, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 /*past here we assume 1 forever*/};
int trip_count = 1;
if( k < ARRAY_SIZE(unroll_factor)) trip_count = unroll_factor[k];
- if( trip_count > 4 ) return NULL; // Too much unrolling
- if (ConditionalMoveLimit == 0) return NULL; // cmov is required
Node *x = in(1); // Value being mod'd
Node *divisor = in(2); // Also is mask
! Node *hook = new (phase->C, 1) Node(x);
// Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C, 3) AndLNode(x,divisor) );
Node *xh = phase->transform( new (phase->C, 3) RShiftLNode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C, 3) AddLNode(xh,xl) );
hook->set_req(0, x); // Add a use to x to prevent him from dying
}
// Generate sign-fixup code. Was original value positive?
// long hack_res = (i >= 0) ? divisor : CONST64(1);
Node *cmp1 = phase->transform( new (phase->C, 3) CmpLNode( in(1), phase->longcon(0) ) );
Node *bol1 = phase->transform( new (phase->C, 2) BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C, 4) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
--- 953,1010 ----
//=============================================================================
//------------------------------Idealize---------------------------------------
Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Check for dead control input
! if( in(0) && remove_dead_region(phase, can_reshape) ) return this;
! // Don't bother trying to transform a dead node
! if( in(0) && in(0)->is_top() ) return NULL;
// Get the modulus
const Type *t = phase->type( in(2) );
if( t == Type::TOP ) return NULL;
! const TypeLong *tl = t->is_long();
// Check for useless control input
// Check for excluding mod-zero case
! if( in(0) && (tl->_hi < 0 || tl->_lo > 0) ) {
set_req(0, NULL); // Yank control input
return this;
}
// See if we are MOD'ing by 2^k or 2^k-1.
! if( !tl->is_con() ) return NULL;
! jlong con = tl->get_con();
!
! Node *hook = new (phase->C, 1) Node(1);
// Expand mod
! if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) {
! uint k = exact_log2_long(con+1); // Extract k
!
// Basic algorithm by David Detlefs. See fastmod_long.java for gory details.
// Used to help a popular random number generator which does a long-mod
// of 2^31-1 and shows up in SpecJBB and SciMark.
static int unroll_factor[] = { 999, 999, 61, 30, 20, 15, 12, 10, 8, 7, 6, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 /*past here we assume 1 forever*/};
int trip_count = 1;
if( k < ARRAY_SIZE(unroll_factor)) trip_count = unroll_factor[k];
+ // If the unroll factor is not too large, and if conditional moves are
+ // ok, then use this case
+ if( trip_count <= 5 && ConditionalMoveLimit != 0 ) {
Node *x = in(1); // Value being mod'd
Node *divisor = in(2); // Also is mask
! hook->init_req(0, x); // Add a use to x to prevent him from dying
// Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C, 3) AndLNode(x,divisor) );
Node *xh = phase->transform( new (phase->C, 3) RShiftLNode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C, 3) AddLNode(xh,xl) );
hook->set_req(0, x); // Add a use to x to prevent him from dying
}
+
// Generate sign-fixup code. Was original value positive?
// long hack_res = (i >= 0) ? divisor : CONST64(1);
Node *cmp1 = phase->transform( new (phase->C, 3) CmpLNode( in(1), phase->longcon(0) ) );
Node *bol1 = phase->transform( new (phase->C, 2) BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C, 4) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
*** 815,825 ****
} else {
hook->set_req(0, NULL); // Just yank bogus edge during Parse phase
}
return cmov2;
}
! return NULL;
}
//------------------------------Value------------------------------------------
const Type *ModLNode::Value( PhaseTransform *phase ) const {
// Either input is TOP ==> the result is TOP
--- 1023,1089 ----
} else {
hook->set_req(0, NULL); // Just yank bogus edge during Parse phase
}
return cmov2;
}
! }
!
! // Fell thru, the unroll case is not appropriate. Transform the modulo
! // into a long multiply/int multiply/subtract case
!
! // Cannot handle mod 0, and min_jint isn't handled by the transform
! if( con == 0 || con == min_jlong ) return NULL;
!
! // Get the absolute value of the constant; at this point, we can use this
! jlong pos_con = (con >= 0) ? con : -con;
!
! // integer Mod 1 is always 0
! if( pos_con == 1 ) return new (phase->C, 1) ConLNode(TypeLong::ZERO);
!
! int log2_con = -1;
!
! // If this is a power of two, they maybe we can mask it
! if( is_power_of_2_long(pos_con) ) {
! log2_con = log2_long(pos_con);
!
! const Type *dt = phase->type(in(1));
! const TypeLong *dtl = dt->isa_long();
!
! // See if this can be masked, if the dividend is non-negative
! if( dtl && dtl->_lo >= 0 )
! return ( new (phase->C, 3) AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
! }
!
! // Save in(1) so that it cannot be changed or deleted
! hook->init_req(0, in(1));
!
! // Divide using the transform from DivI to MulL
! Node *result = transform_long_divide( phase, in(1), pos_con );
! if (result != NULL) {
! Node *divide = phase->transform(result);
!
! // Re-multiply, using a shift if this is a power of two
! Node *mult = NULL;
!
! if( log2_con >= 0 )
! mult = phase->transform( new (phase->C, 3) LShiftLNode( divide, phase->intcon( log2_con ) ) );
! else
! mult = phase->transform( new (phase->C, 3) MulLNode( divide, phase->longcon( pos_con ) ) );
!
! // Finally, subtract the multiplied divided value from the original
! result = new (phase->C, 3) SubLNode( in(1), mult );
! }
!
! // Now remove the bogus extra edges used to keep things alive
! if (can_reshape) {
! phase->is_IterGVN()->remove_dead_node(hook);
! } else {
! hook->set_req(0, NULL); // Just yank bogus edge during Parse phase
! }
!
! // return the value
! return result;
}
//------------------------------Value------------------------------------------
const Type *ModLNode::Value( PhaseTransform *phase ) const {
// Either input is TOP ==> the result is TOP
*** 873,932 ****
const Type *bot = bottom_type();
if( (t1 == bot) || (t2 == bot) ||
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
! // If either is a NaN, return an input NaN
! if( g_isnan(t1->getf()) ) return t1;
! if( g_isnan(t2->getf()) ) return t2;
! // It is not worth trying to constant fold this stuff!
! return Type::FLOAT;
! /*
! // If dividend is infinity or divisor is zero, or both, the result is NaN
! if( !g_isfinite(t1->getf()) || ((t2->getf() == 0.0) || (jint_cast(t2->getf()) == 0x80000000)) )
!
! // X MOD infinity = X
! if( !g_isfinite(t2->getf()) && !g_isnan(t2->getf()) ) return t1;
! // 0 MOD finite = dividend (positive or negative zero)
! // Not valid for: NaN MOD any; any MOD nan; 0 MOD 0; or for 0 MOD NaN
! // NaNs are handled previously.
! if( !(t2->getf() == 0.0) && !((int)t2->getf() == 0x80000000)) {
! if (((t1->getf() == 0.0) || ((int)t1->getf() == 0x80000000)) && g_isfinite(t2->getf()) ) {
! return t1;
! }
! }
! // X MOD X is 0
! // Does not work for variables because of NaN's
! if( phase->eqv( in(1), in(2) ) && t1->base() == Type::FloatCon)
! if (!g_isnan(t1->getf()) && (t1->getf() != 0.0) && ((int)t1->getf() != 0x80000000)) {
! if(t1->getf() < 0.0) {
! float result = jfloat_cast(0x80000000);
! return TypeF::make( result );
! }
! else
! return TypeF::ZERO;
! }
! // If both numbers are not constants, we know nothing.
! if( (t1->base() != Type::FloatCon) || (t2->base() != Type::FloatCon) )
return Type::FLOAT;
// We must be modulo'ing 2 float constants.
// Make sure that the sign of the fmod is equal to the sign of the dividend
! float result = (float)fmod( t1->getf(), t2->getf() );
! float dividend = t1->getf();
! if( (dividend < 0.0) || ((int)dividend == 0x80000000) ) {
! if( result > 0.0 )
! result = 0.0 - result;
! else if( result == 0.0 ) {
! result = jfloat_cast(0x80000000);
}
! }
! return TypeF::make( result );
! */
}
//=============================================================================
//------------------------------Value------------------------------------------
--- 1137,1172 ----
const Type *bot = bottom_type();
if( (t1 == bot) || (t2 == bot) ||
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
! // If either number is not a constant, we know nothing.
! if ((t1->base() != Type::FloatCon) || (t2->base() != Type::FloatCon)) {
! return Type::FLOAT; // note: x%x can be either NaN or 0
! }
! float f1 = t1->getf();
! float f2 = t2->getf();
! jint x1 = jint_cast(f1); // note: *(int*)&f1, not just (int)f1
! jint x2 = jint_cast(f2);
! // If either is a NaN, return an input NaN
! if (g_isnan(f1)) return t1;
! if (g_isnan(f2)) return t2;
! // If an operand is infinity or the divisor is +/- zero, punt.
! if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jint)
return Type::FLOAT;
// We must be modulo'ing 2 float constants.
// Make sure that the sign of the fmod is equal to the sign of the dividend
! jint xr = jint_cast(fmod(f1, f2));
! if ((x1 ^ xr) < 0) {
! xr ^= min_jint;
}
!
! return TypeF::make(jfloat_cast(xr));
}
//=============================================================================
//------------------------------Value------------------------------------------
*** 941,977 ****
const Type *bot = bottom_type();
if( (t1 == bot) || (t2 == bot) ||
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
! // If either is a NaN, return an input NaN
! if( g_isnan(t1->getd()) ) return t1;
! if( g_isnan(t2->getd()) ) return t2;
! // X MOD infinity = X
! if( !g_isfinite(t2->getd())) return t1;
! // 0 MOD finite = dividend (positive or negative zero)
! // Not valid for: NaN MOD any; any MOD nan; 0 MOD 0; or for 0 MOD NaN
! // NaNs are handled previously.
! if( !(t2->getd() == 0.0) ) {
! if( t1->getd() == 0.0 && g_isfinite(t2->getd()) ) {
! return t1;
! }
}
! // X MOD X is 0
! // does not work for variables because of NaN's
! if( phase->eqv( in(1), in(2) ) && t1->base() == Type::DoubleCon )
! if (!g_isnan(t1->getd()) && t1->getd() != 0.0)
! return TypeD::ZERO;
! // If both numbers are not constants, we know nothing.
! if( (t1->base() != Type::DoubleCon) || (t2->base() != Type::DoubleCon) )
return Type::DOUBLE;
// We must be modulo'ing 2 double constants.
! return TypeD::make( fmod( t1->getd(), t2->getd() ) );
}
//=============================================================================
DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
--- 1181,1216 ----
const Type *bot = bottom_type();
if( (t1 == bot) || (t2 == bot) ||
(t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
return bot;
! // If either number is not a constant, we know nothing.
! if ((t1->base() != Type::DoubleCon) || (t2->base() != Type::DoubleCon)) {
! return Type::DOUBLE; // note: x%x can be either NaN or 0
}
! double f1 = t1->getd();
! double f2 = t2->getd();
! jlong x1 = jlong_cast(f1); // note: *(long*)&f1, not just (long)f1
! jlong x2 = jlong_cast(f2);
+ // If either is a NaN, return an input NaN
+ if (g_isnan(f1)) return t1;
+ if (g_isnan(f2)) return t2;
! // If an operand is infinity or the divisor is +/- zero, punt.
! if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jlong)
return Type::DOUBLE;
// We must be modulo'ing 2 double constants.
! // Make sure that the sign of the fmod is equal to the sign of the dividend
! jlong xr = jlong_cast(fmod(f1, f2));
! if ((x1 ^ xr) < 0) {
! xr ^= min_jlong;
! }
!
! return TypeD::make(jdouble_cast(xr));
}
//=============================================================================
DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {