Mercurial > hg > truffle
annotate src/share/vm/opto/divnode.cpp @ 14649:f6301b007a16
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | b9a9ed0f8eeb |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6804
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1154
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1154
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1154
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "memory/allocation.inline.hpp" | |
| 27 #include "opto/addnode.hpp" | |
| 28 #include "opto/connode.hpp" | |
| 29 #include "opto/divnode.hpp" | |
| 30 #include "opto/machnode.hpp" | |
| 31 #include "opto/matcher.hpp" | |
| 32 #include "opto/mulnode.hpp" | |
| 33 #include "opto/phaseX.hpp" | |
| 34 #include "opto/subnode.hpp" | |
| 35 | |
| 0 | 36 // Portions of code courtesy of Clifford Click |
| 37 | |
| 38 // Optimization - Graph Style | |
| 39 | |
| 40 #include <math.h> | |
| 41 | |
| 145 | 42 //----------------------magic_int_divide_constants----------------------------- |
| 43 // Compute magic multiplier and shift constant for converting a 32 bit divide | |
| 44 // by constant into a multiply/shift/add series. Return false if calculations | |
| 45 // fail. | |
| 46 // | |
| 605 | 47 // Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with |
| 145 | 48 // minor type name and parameter changes. |
| 49 static bool magic_int_divide_constants(jint d, jint &M, jint &s) { | |
| 50 int32_t p; | |
| 51 uint32_t ad, anc, delta, q1, r1, q2, r2, t; | |
| 52 const uint32_t two31 = 0x80000000L; // 2**31. | |
| 53 | |
| 54 ad = ABS(d); | |
| 55 if (d == 0 || d == 1) return false; | |
| 56 t = two31 + ((uint32_t)d >> 31); | |
| 57 anc = t - 1 - t%ad; // Absolute value of nc. | |
| 58 p = 31; // Init. p. | |
| 59 q1 = two31/anc; // Init. q1 = 2**p/|nc|. | |
| 60 r1 = two31 - q1*anc; // Init. r1 = rem(2**p, |nc|). | |
| 61 q2 = two31/ad; // Init. q2 = 2**p/|d|. | |
| 62 r2 = two31 - q2*ad; // Init. r2 = rem(2**p, |d|). | |
| 63 do { | |
| 64 p = p + 1; | |
| 65 q1 = 2*q1; // Update q1 = 2**p/|nc|. | |
| 66 r1 = 2*r1; // Update r1 = rem(2**p, |nc|). | |
| 67 if (r1 >= anc) { // (Must be an unsigned | |
| 68 q1 = q1 + 1; // comparison here). | |
| 69 r1 = r1 - anc; | |
| 70 } | |
| 71 q2 = 2*q2; // Update q2 = 2**p/|d|. | |
| 72 r2 = 2*r2; // Update r2 = rem(2**p, |d|). | |
| 73 if (r2 >= ad) { // (Must be an unsigned | |
| 74 q2 = q2 + 1; // comparison here). | |
| 75 r2 = r2 - ad; | |
| 76 } | |
| 77 delta = ad - r2; | |
| 78 } while (q1 < delta || (q1 == delta && r1 == 0)); | |
| 79 | |
| 80 M = q2 + 1; | |
| 81 if (d < 0) M = -M; // Magic number and | |
| 82 s = p - 32; // shift amount to return. | |
| 83 | |
| 84 return true; | |
| 85 } | |
| 86 | |
| 87 //--------------------------transform_int_divide------------------------------- | |
| 88 // Convert a division by constant divisor into an alternate Ideal graph. | |
| 89 // Return NULL if no transformation occurs. | |
| 90 static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor ) { | |
| 0 | 91 |
| 92 // Check for invalid divisors | |
| 145 | 93 assert( divisor != 0 && divisor != min_jint, |
| 94 "bad divisor for transforming to long multiply" ); | |
| 0 | 95 |
| 145 | 96 bool d_pos = divisor >= 0; |
| 97 jint d = d_pos ? divisor : -divisor; | |
| 98 const int N = 32; | |
| 0 | 99 |
| 100 // Result | |
| 145 | 101 Node *q = NULL; |
| 0 | 102 |
| 103 if (d == 1) { | |
| 145 | 104 // division by +/- 1 |
| 105 if (!d_pos) { | |
| 106 // Just negate the value | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
107 q = new (phase->C) SubINode(phase->intcon(0), dividend); |
| 0 | 108 } |
| 145 | 109 } else if ( is_power_of_2(d) ) { |
| 110 // division by +/- a power of 2 | |
| 0 | 111 |
| 112 // See if we can simply do a shift without rounding | |
| 113 bool needs_rounding = true; | |
| 114 const Type *dt = phase->type(dividend); | |
| 115 const TypeInt *dti = dt->isa_int(); | |
| 145 | 116 if (dti && dti->_lo >= 0) { |
| 117 // we don't need to round a positive dividend | |
| 0 | 118 needs_rounding = false; |
| 145 | 119 } else if( dividend->Opcode() == Op_AndI ) { |
| 120 // An AND mask of sufficient size clears the low bits and | |
| 121 // I can avoid rounding. | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
122 const TypeInt *andconi_t = phase->type( dividend->in(2) )->isa_int(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
123 if( andconi_t && andconi_t->is_con() ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
124 jint andconi = andconi_t->get_con(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
125 if( andconi < 0 && is_power_of_2(-andconi) && (-andconi) >= d ) { |
|
1154
174ade00803b
6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents:
756
diff
changeset
|
126 if( (-andconi) == d ) // Remove AND if it clears bits which will be shifted |
|
174ade00803b
6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents:
756
diff
changeset
|
127 dividend = dividend->in(1); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
128 needs_rounding = false; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
129 } |
| 0 | 130 } |
| 131 } | |
| 132 | |
| 133 // Add rounding to the shift to handle the sign bit | |
| 145 | 134 int l = log2_intptr(d-1)+1; |
| 135 if (needs_rounding) { | |
| 136 // Divide-by-power-of-2 can be made into a shift, but you have to do | |
| 137 // more math for the rounding. You need to add 0 for positive | |
| 138 // numbers, and "i-1" for negative numbers. Example: i=4, so the | |
| 139 // shift is by 2. You need to add 3 to negative dividends and 0 to | |
| 140 // positive ones. So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1, | |
| 141 // (-2+3)>>2 becomes 0, etc. | |
| 142 | |
| 143 // Compute 0 or -1, based on sign bit | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
144 Node *sign = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N - 1))); |
| 145 | 145 // Mask sign bit to the low sign bits |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
146 Node *round = phase->transform(new (phase->C) URShiftINode(sign, phase->intcon(N - l))); |
| 145 | 147 // Round up before shifting |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
148 dividend = phase->transform(new (phase->C) AddINode(dividend, round)); |
| 0 | 149 } |
| 150 | |
| 145 | 151 // Shift for division |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
152 q = new (phase->C) RShiftINode(dividend, phase->intcon(l)); |
| 0 | 153 |
| 145 | 154 if (!d_pos) { |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
155 q = new (phase->C) SubINode(phase->intcon(0), phase->transform(q)); |
| 145 | 156 } |
| 157 } else { | |
| 158 // Attempt the jint constant divide -> multiply transform found in | |
| 159 // "Division by Invariant Integers using Multiplication" | |
| 160 // by Granlund and Montgomery | |
| 161 // See also "Hacker's Delight", chapter 10 by Warren. | |
| 162 | |
| 163 jint magic_const; | |
| 164 jint shift_const; | |
| 165 if (magic_int_divide_constants(d, magic_const, shift_const)) { | |
| 166 Node *magic = phase->longcon(magic_const); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
167 Node *dividend_long = phase->transform(new (phase->C) ConvI2LNode(dividend)); |
| 145 | 168 |
| 169 // Compute the high half of the dividend x magic multiplication | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
170 Node *mul_hi = phase->transform(new (phase->C) MulLNode(dividend_long, magic)); |
| 145 | 171 |
| 172 if (magic_const < 0) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
173 mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
174 mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi)); |
| 145 | 175 |
| 176 // The magic multiplier is too large for a 32 bit constant. We've adjusted | |
| 177 // it down by 2^32, but have to add 1 dividend back in after the multiplication. | |
| 178 // This handles the "overflow" case described by Granlund and Montgomery. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
179 mul_hi = phase->transform(new (phase->C) AddINode(dividend, mul_hi)); |
| 145 | 180 |
| 181 // Shift over the (adjusted) mulhi | |
| 182 if (shift_const != 0) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
183 mul_hi = phase->transform(new (phase->C) RShiftINode(mul_hi, phase->intcon(shift_const))); |
| 145 | 184 } |
| 185 } else { | |
| 186 // No add is required, we can merge the shifts together. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
187 mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N + shift_const))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
188 mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi)); |
| 145 | 189 } |
| 190 | |
| 191 // Get a 0 or -1 from the sign of the dividend. | |
| 192 Node *addend0 = mul_hi; | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
193 Node *addend1 = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N-1))); |
| 145 | 194 |
| 195 // If the divisor is negative, swap the order of the input addends; | |
| 196 // this has the effect of negating the quotient. | |
| 197 if (!d_pos) { | |
| 198 Node *temp = addend0; addend0 = addend1; addend1 = temp; | |
| 199 } | |
| 200 | |
| 201 // Adjust the final quotient by subtracting -1 (adding 1) | |
| 202 // from the mul_hi. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
203 q = new (phase->C) SubINode(addend0, addend1); |
| 145 | 204 } |
| 205 } | |
| 206 | |
| 207 return q; | |
| 208 } | |
| 209 | |
| 210 //---------------------magic_long_divide_constants----------------------------- | |
| 211 // Compute magic multiplier and shift constant for converting a 64 bit divide | |
| 212 // by constant into a multiply/shift/add series. Return false if calculations | |
| 213 // fail. | |
| 214 // | |
| 605 | 215 // Borrowed almost verbatim from Hacker's Delight by Henry S. Warren, Jr. with |
| 145 | 216 // minor type name and parameter changes. Adjusted to 64 bit word width. |
| 217 static bool magic_long_divide_constants(jlong d, jlong &M, jint &s) { | |
| 218 int64_t p; | |
| 219 uint64_t ad, anc, delta, q1, r1, q2, r2, t; | |
| 220 const uint64_t two63 = 0x8000000000000000LL; // 2**63. | |
| 221 | |
| 222 ad = ABS(d); | |
| 223 if (d == 0 || d == 1) return false; | |
| 224 t = two63 + ((uint64_t)d >> 63); | |
| 225 anc = t - 1 - t%ad; // Absolute value of nc. | |
| 226 p = 63; // Init. p. | |
| 227 q1 = two63/anc; // Init. q1 = 2**p/|nc|. | |
| 228 r1 = two63 - q1*anc; // Init. r1 = rem(2**p, |nc|). | |
| 229 q2 = two63/ad; // Init. q2 = 2**p/|d|. | |
| 230 r2 = two63 - q2*ad; // Init. r2 = rem(2**p, |d|). | |
| 231 do { | |
| 232 p = p + 1; | |
| 233 q1 = 2*q1; // Update q1 = 2**p/|nc|. | |
| 234 r1 = 2*r1; // Update r1 = rem(2**p, |nc|). | |
| 235 if (r1 >= anc) { // (Must be an unsigned | |
| 236 q1 = q1 + 1; // comparison here). | |
| 237 r1 = r1 - anc; | |
| 238 } | |
| 239 q2 = 2*q2; // Update q2 = 2**p/|d|. | |
| 240 r2 = 2*r2; // Update r2 = rem(2**p, |d|). | |
| 241 if (r2 >= ad) { // (Must be an unsigned | |
| 242 q2 = q2 + 1; // comparison here). | |
| 243 r2 = r2 - ad; | |
| 244 } | |
| 245 delta = ad - r2; | |
| 246 } while (q1 < delta || (q1 == delta && r1 == 0)); | |
| 247 | |
| 248 M = q2 + 1; | |
| 249 if (d < 0) M = -M; // Magic number and | |
| 250 s = p - 64; // shift amount to return. | |
| 251 | |
| 252 return true; | |
| 253 } | |
| 254 | |
| 255 //---------------------long_by_long_mulhi-------------------------------------- | |
| 256 // Generate ideal node graph for upper half of a 64 bit x 64 bit multiplication | |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
257 static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_const) { |
| 145 | 258 // If the architecture supports a 64x64 mulhi, there is |
| 259 // no need to synthesize it in ideal nodes. | |
| 260 if (Matcher::has_match_rule(Op_MulHiL)) { | |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
261 Node* v = phase->longcon(magic_const); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
262 return new (phase->C) MulHiLNode(dividend, v); |
| 0 | 263 } |
| 264 | |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
265 // Taken from Hacker's Delight, Fig. 8-2. Multiply high signed. |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
266 // (http://www.hackersdelight.org/HDcode/mulhs.c) |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
267 // |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
268 // int mulhs(int u, int v) { |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
269 // unsigned u0, v0, w0; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
270 // int u1, v1, w1, w2, t; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
271 // |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
272 // u0 = u & 0xFFFF; u1 = u >> 16; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
273 // v0 = v & 0xFFFF; v1 = v >> 16; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
274 // w0 = u0*v0; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
275 // t = u1*v0 + (w0 >> 16); |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
276 // w1 = t & 0xFFFF; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
277 // w2 = t >> 16; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
278 // w1 = u0*v1 + w1; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
279 // return u1*v1 + w2 + (w1 >> 16); |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
280 // } |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
281 // |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
282 // Note: The version above is for 32x32 multiplications, while the |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
283 // following inline comments are adapted to 64x64. |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
284 |
| 145 | 285 const int N = 64; |
| 286 | |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
287 // Dummy node to keep intermediate nodes alive during construction |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
288 Node* hook = new (phase->C) Node(4); |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
289 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
290 // u0 = u & 0xFFFFFFFF; u1 = u >> 32; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
291 Node* u0 = phase->transform(new (phase->C) AndLNode(dividend, phase->longcon(0xFFFFFFFF))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
292 Node* u1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N / 2))); |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
293 hook->init_req(0, u0); |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
294 hook->init_req(1, u1); |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
295 |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
296 // v0 = v & 0xFFFFFFFF; v1 = v >> 32; |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
297 Node* v0 = phase->longcon(magic_const & 0xFFFFFFFF); |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
298 Node* v1 = phase->longcon(magic_const >> (N / 2)); |
| 145 | 299 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
300 // w0 = u0*v0; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
301 Node* w0 = phase->transform(new (phase->C) MulLNode(u0, v0)); |
| 145 | 302 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
303 // t = u1*v0 + (w0 >> 32); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
304 Node* u1v0 = phase->transform(new (phase->C) MulLNode(u1, v0)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
305 Node* temp = phase->transform(new (phase->C) URShiftLNode(w0, phase->intcon(N / 2))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
306 Node* t = phase->transform(new (phase->C) AddLNode(u1v0, temp)); |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
307 hook->init_req(2, t); |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
308 |
|
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
309 // w1 = t & 0xFFFFFFFF; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
310 Node* w1 = phase->transform(new (phase->C) AndLNode(t, phase->longcon(0xFFFFFFFF))); |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
311 hook->init_req(3, w1); |
| 145 | 312 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
313 // w2 = t >> 32; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
314 Node* w2 = phase->transform(new (phase->C) RShiftLNode(t, phase->intcon(N / 2))); |
|
294
616a07a75c3c
6732154: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
rasbold
parents:
196
diff
changeset
|
315 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
316 // w1 = u0*v1 + w1; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
317 Node* u0v1 = phase->transform(new (phase->C) MulLNode(u0, v1)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
318 w1 = phase->transform(new (phase->C) AddLNode(u0v1, w1)); |
|
294
616a07a75c3c
6732154: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
rasbold
parents:
196
diff
changeset
|
319 |
|
567
bbef4344adb2
6800154: Add comments to long_by_long_mulhi() for better understandability
twisti
parents:
404
diff
changeset
|
320 // return u1*v1 + w2 + (w1 >> 32); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
321 Node* u1v1 = phase->transform(new (phase->C) MulLNode(u1, v1)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
322 Node* temp1 = phase->transform(new (phase->C) AddLNode(u1v1, w2)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
323 Node* temp2 = phase->transform(new (phase->C) RShiftLNode(w1, phase->intcon(N / 2))); |
| 145 | 324 |
|
6142
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
325 // Remove the bogus extra edges used to keep things alive |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
326 PhaseIterGVN* igvn = phase->is_IterGVN(); |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
327 if (igvn != NULL) { |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
328 igvn->remove_dead_node(hook); |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
329 } else { |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
330 for (int i = 0; i < 4; i++) { |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
331 hook->set_req(i, NULL); |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
332 } |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
333 } |
|
121e5708ae96
7169782: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
kvn
parents:
1972
diff
changeset
|
334 |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
335 return new (phase->C) AddLNode(temp1, temp2); |
| 145 | 336 } |
| 337 | |
| 338 | |
| 339 //--------------------------transform_long_divide------------------------------ | |
| 340 // Convert a division by constant divisor into an alternate Ideal graph. | |
| 341 // Return NULL if no transformation occurs. | |
| 342 static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divisor ) { | |
| 343 // Check for invalid divisors | |
| 344 assert( divisor != 0L && divisor != min_jlong, | |
| 345 "bad divisor for transforming to long multiply" ); | |
| 346 | |
| 347 bool d_pos = divisor >= 0; | |
| 348 jlong d = d_pos ? divisor : -divisor; | |
| 349 const int N = 64; | |
| 350 | |
| 351 // Result | |
| 352 Node *q = NULL; | |
| 353 | |
| 354 if (d == 1) { | |
| 355 // division by +/- 1 | |
| 356 if (!d_pos) { | |
| 357 // Just negate the value | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
358 q = new (phase->C) SubLNode(phase->longcon(0), dividend); |
| 145 | 359 } |
| 360 } else if ( is_power_of_2_long(d) ) { | |
| 361 | |
| 362 // division by +/- a power of 2 | |
| 363 | |
| 364 // See if we can simply do a shift without rounding | |
| 365 bool needs_rounding = true; | |
| 366 const Type *dt = phase->type(dividend); | |
| 367 const TypeLong *dtl = dt->isa_long(); | |
| 0 | 368 |
| 145 | 369 if (dtl && dtl->_lo > 0) { |
| 370 // we don't need to round a positive dividend | |
| 371 needs_rounding = false; | |
| 372 } else if( dividend->Opcode() == Op_AndL ) { | |
| 373 // An AND mask of sufficient size clears the low bits and | |
| 374 // I can avoid rounding. | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
375 const TypeLong *andconl_t = phase->type( dividend->in(2) )->isa_long(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
376 if( andconl_t && andconl_t->is_con() ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
377 jlong andconl = andconl_t->get_con(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
378 if( andconl < 0 && is_power_of_2_long(-andconl) && (-andconl) >= d ) { |
|
1154
174ade00803b
6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents:
756
diff
changeset
|
379 if( (-andconl) == d ) // Remove AND if it clears bits which will be shifted |
|
174ade00803b
6910484: incorrect integer optimization (loosing and op-r in a given example)
kvn
parents:
756
diff
changeset
|
380 dividend = dividend->in(1); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
381 needs_rounding = false; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
305
diff
changeset
|
382 } |
| 145 | 383 } |
| 384 } | |
| 385 | |
| 386 // Add rounding to the shift to handle the sign bit | |
| 387 int l = log2_long(d-1)+1; | |
| 388 if (needs_rounding) { | |
| 389 // Divide-by-power-of-2 can be made into a shift, but you have to do | |
| 390 // more math for the rounding. You need to add 0 for positive | |
| 391 // numbers, and "i-1" for negative numbers. Example: i=4, so the | |
| 392 // shift is by 2. You need to add 3 to negative dividends and 0 to | |
| 393 // positive ones. So (-7+3)>>2 becomes -1, (-4+3)>>2 becomes -1, | |
| 394 // (-2+3)>>2 becomes 0, etc. | |
| 395 | |
| 396 // Compute 0 or -1, based on sign bit | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
397 Node *sign = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N - 1))); |
| 145 | 398 // Mask sign bit to the low sign bits |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
399 Node *round = phase->transform(new (phase->C) URShiftLNode(sign, phase->intcon(N - l))); |
| 145 | 400 // Round up before shifting |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
401 dividend = phase->transform(new (phase->C) AddLNode(dividend, round)); |
| 145 | 402 } |
| 403 | |
| 404 // Shift for division | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
405 q = new (phase->C) RShiftLNode(dividend, phase->intcon(l)); |
| 145 | 406 |
| 407 if (!d_pos) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
408 q = new (phase->C) SubLNode(phase->longcon(0), phase->transform(q)); |
| 145 | 409 } |
|
1914
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
410 } else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when |
|
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
411 // it is faster than code generated below. |
| 145 | 412 // Attempt the jlong constant divide -> multiply transform found in |
| 413 // "Division by Invariant Integers using Multiplication" | |
| 414 // by Granlund and Montgomery | |
| 415 // See also "Hacker's Delight", chapter 10 by Warren. | |
| 416 | |
| 417 jlong magic_const; | |
| 418 jint shift_const; | |
| 419 if (magic_long_divide_constants(d, magic_const, shift_const)) { | |
| 420 // Compute the high half of the dividend x magic multiplication | |
| 421 Node *mul_hi = phase->transform(long_by_long_mulhi(phase, dividend, magic_const)); | |
| 422 | |
| 423 // The high half of the 128-bit multiply is computed. | |
| 424 if (magic_const < 0) { | |
| 425 // The magic multiplier is too large for a 64 bit constant. We've adjusted | |
| 426 // it down by 2^64, but have to add 1 dividend back in after the multiplication. | |
| 427 // This handles the "overflow" case described by Granlund and Montgomery. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
428 mul_hi = phase->transform(new (phase->C) AddLNode(dividend, mul_hi)); |
| 145 | 429 } |
| 430 | |
| 431 // Shift over the (adjusted) mulhi | |
| 432 if (shift_const != 0) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
433 mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(shift_const))); |
| 145 | 434 } |
| 435 | |
| 436 // Get a 0 or -1 from the sign of the dividend. | |
| 437 Node *addend0 = mul_hi; | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
438 Node *addend1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N-1))); |
| 145 | 439 |
| 440 // If the divisor is negative, swap the order of the input addends; | |
| 441 // this has the effect of negating the quotient. | |
| 442 if (!d_pos) { | |
| 443 Node *temp = addend0; addend0 = addend1; addend1 = temp; | |
| 444 } | |
| 445 | |
| 446 // Adjust the final quotient by subtracting -1 (adding 1) | |
| 447 // from the mul_hi. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
448 q = new (phase->C) SubLNode(addend0, addend1); |
| 145 | 449 } |
| 0 | 450 } |
| 451 | |
| 145 | 452 return q; |
| 0 | 453 } |
| 454 | |
| 455 //============================================================================= | |
| 456 //------------------------------Identity--------------------------------------- | |
| 457 // If the divisor is 1, we are an identity on the dividend. | |
| 458 Node *DivINode::Identity( PhaseTransform *phase ) { | |
| 459 return (phase->type( in(2) )->higher_equal(TypeInt::ONE)) ? in(1) : this; | |
| 460 } | |
| 461 | |
| 462 //------------------------------Idealize--------------------------------------- | |
| 463 // Divides can be changed to multiplies and/or shifts | |
| 464 Node *DivINode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 465 if (in(0) && remove_dead_region(phase, can_reshape)) return this; | |
| 305 | 466 // Don't bother trying to transform a dead node |
| 467 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 468 |
| 469 const Type *t = phase->type( in(2) ); | |
| 470 if( t == TypeInt::ONE ) // Identity? | |
| 471 return NULL; // Skip it | |
| 472 | |
| 473 const TypeInt *ti = t->isa_int(); | |
| 474 if( !ti ) return NULL; | |
| 475 if( !ti->is_con() ) return NULL; | |
| 145 | 476 jint i = ti->get_con(); // Get divisor |
| 0 | 477 |
| 478 if (i == 0) return NULL; // Dividing by zero constant does not idealize | |
| 479 | |
| 480 set_req(0,NULL); // Dividing by a not-zero constant; no faulting | |
| 481 | |
| 482 // Dividing by MININT does not optimize as a power-of-2 shift. | |
| 483 if( i == min_jint ) return NULL; | |
| 484 | |
| 145 | 485 return transform_int_divide( phase, in(1), i ); |
| 0 | 486 } |
| 487 | |
| 488 //------------------------------Value------------------------------------------ | |
| 489 // A DivINode divides its inputs. The third input is a Control input, used to | |
| 490 // prevent hoisting the divide above an unsafe test. | |
| 491 const Type *DivINode::Value( PhaseTransform *phase ) const { | |
| 492 // Either input is TOP ==> the result is TOP | |
| 493 const Type *t1 = phase->type( in(1) ); | |
| 494 const Type *t2 = phase->type( in(2) ); | |
| 495 if( t1 == Type::TOP ) return Type::TOP; | |
| 496 if( t2 == Type::TOP ) return Type::TOP; | |
| 497 | |
| 498 // x/x == 1 since we always generate the dynamic divisor check for 0. | |
| 499 if( phase->eqv( in(1), in(2) ) ) | |
| 500 return TypeInt::ONE; | |
| 501 | |
| 502 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 503 const Type *bot = bottom_type(); | |
| 504 if( (t1 == bot) || (t2 == bot) || | |
| 505 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 506 return bot; | |
| 507 | |
| 508 // Divide the two numbers. We approximate. | |
| 509 // If divisor is a constant and not zero | |
| 510 const TypeInt *i1 = t1->is_int(); | |
| 511 const TypeInt *i2 = t2->is_int(); | |
| 512 int widen = MAX2(i1->_widen, i2->_widen); | |
| 513 | |
| 514 if( i2->is_con() && i2->get_con() != 0 ) { | |
| 515 int32 d = i2->get_con(); // Divisor | |
| 516 jint lo, hi; | |
| 517 if( d >= 0 ) { | |
| 518 lo = i1->_lo/d; | |
| 519 hi = i1->_hi/d; | |
| 520 } else { | |
| 521 if( d == -1 && i1->_lo == min_jint ) { | |
| 522 // 'min_jint/-1' throws arithmetic exception during compilation | |
| 523 lo = min_jint; | |
| 524 // do not support holes, 'hi' must go to either min_jint or max_jint: | |
| 525 // [min_jint, -10]/[-1,-1] ==> [min_jint] UNION [10,max_jint] | |
| 526 hi = i1->_hi == min_jint ? min_jint : max_jint; | |
| 527 } else { | |
| 528 lo = i1->_hi/d; | |
| 529 hi = i1->_lo/d; | |
| 530 } | |
| 531 } | |
| 532 return TypeInt::make(lo, hi, widen); | |
| 533 } | |
| 534 | |
| 535 // If the dividend is a constant | |
| 536 if( i1->is_con() ) { | |
| 537 int32 d = i1->get_con(); | |
| 538 if( d < 0 ) { | |
| 539 if( d == min_jint ) { | |
| 540 // (-min_jint) == min_jint == (min_jint / -1) | |
| 541 return TypeInt::make(min_jint, max_jint/2 + 1, widen); | |
| 542 } else { | |
| 543 return TypeInt::make(d, -d, widen); | |
| 544 } | |
| 545 } | |
| 546 return TypeInt::make(-d, d, widen); | |
| 547 } | |
| 548 | |
| 549 // Otherwise we give up all hope | |
| 550 return TypeInt::INT; | |
| 551 } | |
| 552 | |
| 553 | |
| 554 //============================================================================= | |
| 555 //------------------------------Identity--------------------------------------- | |
| 556 // If the divisor is 1, we are an identity on the dividend. | |
| 557 Node *DivLNode::Identity( PhaseTransform *phase ) { | |
| 558 return (phase->type( in(2) )->higher_equal(TypeLong::ONE)) ? in(1) : this; | |
| 559 } | |
| 560 | |
| 561 //------------------------------Idealize--------------------------------------- | |
| 562 // Dividing by a power of 2 is a shift. | |
| 563 Node *DivLNode::Ideal( PhaseGVN *phase, bool can_reshape) { | |
| 564 if (in(0) && remove_dead_region(phase, can_reshape)) return this; | |
| 305 | 565 // Don't bother trying to transform a dead node |
| 566 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 567 |
| 568 const Type *t = phase->type( in(2) ); | |
| 145 | 569 if( t == TypeLong::ONE ) // Identity? |
| 0 | 570 return NULL; // Skip it |
| 571 | |
| 145 | 572 const TypeLong *tl = t->isa_long(); |
| 573 if( !tl ) return NULL; | |
| 574 if( !tl->is_con() ) return NULL; | |
| 575 jlong l = tl->get_con(); // Get divisor | |
| 576 | |
| 577 if (l == 0) return NULL; // Dividing by zero constant does not idealize | |
| 578 | |
| 579 set_req(0,NULL); // Dividing by a not-zero constant; no faulting | |
| 0 | 580 |
|
1914
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
581 // Dividing by MINLONG does not optimize as a power-of-2 shift. |
| 145 | 582 if( l == min_jlong ) return NULL; |
| 0 | 583 |
| 145 | 584 return transform_long_divide( phase, in(1), l ); |
| 0 | 585 } |
| 586 | |
| 587 //------------------------------Value------------------------------------------ | |
| 588 // A DivLNode divides its inputs. The third input is a Control input, used to | |
| 589 // prevent hoisting the divide above an unsafe test. | |
| 590 const Type *DivLNode::Value( PhaseTransform *phase ) const { | |
| 591 // Either input is TOP ==> the result is TOP | |
| 592 const Type *t1 = phase->type( in(1) ); | |
| 593 const Type *t2 = phase->type( in(2) ); | |
| 594 if( t1 == Type::TOP ) return Type::TOP; | |
| 595 if( t2 == Type::TOP ) return Type::TOP; | |
| 596 | |
| 597 // x/x == 1 since we always generate the dynamic divisor check for 0. | |
| 598 if( phase->eqv( in(1), in(2) ) ) | |
| 599 return TypeLong::ONE; | |
| 600 | |
| 601 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 602 const Type *bot = bottom_type(); | |
| 603 if( (t1 == bot) || (t2 == bot) || | |
| 604 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 605 return bot; | |
| 606 | |
| 607 // Divide the two numbers. We approximate. | |
| 608 // If divisor is a constant and not zero | |
| 609 const TypeLong *i1 = t1->is_long(); | |
| 610 const TypeLong *i2 = t2->is_long(); | |
| 611 int widen = MAX2(i1->_widen, i2->_widen); | |
| 612 | |
| 613 if( i2->is_con() && i2->get_con() != 0 ) { | |
| 614 jlong d = i2->get_con(); // Divisor | |
| 615 jlong lo, hi; | |
| 616 if( d >= 0 ) { | |
| 617 lo = i1->_lo/d; | |
| 618 hi = i1->_hi/d; | |
| 619 } else { | |
| 620 if( d == CONST64(-1) && i1->_lo == min_jlong ) { | |
| 621 // 'min_jlong/-1' throws arithmetic exception during compilation | |
| 622 lo = min_jlong; | |
| 623 // do not support holes, 'hi' must go to either min_jlong or max_jlong: | |
| 624 // [min_jlong, -10]/[-1,-1] ==> [min_jlong] UNION [10,max_jlong] | |
| 625 hi = i1->_hi == min_jlong ? min_jlong : max_jlong; | |
| 626 } else { | |
| 627 lo = i1->_hi/d; | |
| 628 hi = i1->_lo/d; | |
| 629 } | |
| 630 } | |
| 631 return TypeLong::make(lo, hi, widen); | |
| 632 } | |
| 633 | |
| 634 // If the dividend is a constant | |
| 635 if( i1->is_con() ) { | |
| 636 jlong d = i1->get_con(); | |
| 637 if( d < 0 ) { | |
| 638 if( d == min_jlong ) { | |
| 639 // (-min_jlong) == min_jlong == (min_jlong / -1) | |
| 640 return TypeLong::make(min_jlong, max_jlong/2 + 1, widen); | |
| 641 } else { | |
| 642 return TypeLong::make(d, -d, widen); | |
| 643 } | |
| 644 } | |
| 645 return TypeLong::make(-d, d, widen); | |
| 646 } | |
| 647 | |
| 648 // Otherwise we give up all hope | |
| 649 return TypeLong::LONG; | |
| 650 } | |
| 651 | |
| 652 | |
| 653 //============================================================================= | |
| 654 //------------------------------Value------------------------------------------ | |
| 655 // An DivFNode divides its inputs. The third input is a Control input, used to | |
| 656 // prevent hoisting the divide above an unsafe test. | |
| 657 const Type *DivFNode::Value( PhaseTransform *phase ) const { | |
| 658 // Either input is TOP ==> the result is TOP | |
| 659 const Type *t1 = phase->type( in(1) ); | |
| 660 const Type *t2 = phase->type( in(2) ); | |
| 661 if( t1 == Type::TOP ) return Type::TOP; | |
| 662 if( t2 == Type::TOP ) return Type::TOP; | |
| 663 | |
| 664 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 665 const Type *bot = bottom_type(); | |
| 666 if( (t1 == bot) || (t2 == bot) || | |
| 667 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 668 return bot; | |
| 669 | |
| 670 // x/x == 1, we ignore 0/0. | |
| 671 // Note: if t1 and t2 are zero then result is NaN (JVMS page 213) | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
672 // Does not work for variables because of NaN's |
| 0 | 673 if( phase->eqv( in(1), in(2) ) && t1->base() == Type::FloatCon) |
| 674 if (!g_isnan(t1->getf()) && g_isfinite(t1->getf()) && t1->getf() != 0.0) // could be negative ZERO or NaN | |
| 675 return TypeF::ONE; | |
| 676 | |
| 677 if( t2 == TypeF::ONE ) | |
| 678 return t1; | |
| 679 | |
| 680 // If divisor is a constant and not zero, divide them numbers | |
| 681 if( t1->base() == Type::FloatCon && | |
| 682 t2->base() == Type::FloatCon && | |
| 683 t2->getf() != 0.0 ) // could be negative zero | |
| 684 return TypeF::make( t1->getf()/t2->getf() ); | |
| 685 | |
| 686 // If the dividend is a constant zero | |
| 687 // Note: if t1 and t2 are zero then result is NaN (JVMS page 213) | |
| 688 // Test TypeF::ZERO is not sufficient as it could be negative zero | |
| 689 | |
| 690 if( t1 == TypeF::ZERO && !g_isnan(t2->getf()) && t2->getf() != 0.0 ) | |
| 691 return TypeF::ZERO; | |
| 692 | |
| 693 // Otherwise we give up all hope | |
| 694 return Type::FLOAT; | |
| 695 } | |
| 696 | |
| 697 //------------------------------isA_Copy--------------------------------------- | |
| 698 // Dividing by self is 1. | |
| 699 // If the divisor is 1, we are an identity on the dividend. | |
| 700 Node *DivFNode::Identity( PhaseTransform *phase ) { | |
| 701 return (phase->type( in(2) ) == TypeF::ONE) ? in(1) : this; | |
| 702 } | |
| 703 | |
| 704 | |
| 705 //------------------------------Idealize--------------------------------------- | |
| 706 Node *DivFNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 707 if (in(0) && remove_dead_region(phase, can_reshape)) return this; | |
| 305 | 708 // Don't bother trying to transform a dead node |
| 709 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 710 |
| 711 const Type *t2 = phase->type( in(2) ); | |
| 712 if( t2 == TypeF::ONE ) // Identity? | |
| 713 return NULL; // Skip it | |
| 714 | |
| 715 const TypeF *tf = t2->isa_float_constant(); | |
| 716 if( !tf ) return NULL; | |
| 717 if( tf->base() != Type::FloatCon ) return NULL; | |
| 718 | |
| 719 // Check for out of range values | |
| 720 if( tf->is_nan() || !tf->is_finite() ) return NULL; | |
| 721 | |
| 722 // Get the value | |
| 723 float f = tf->getf(); | |
| 724 int exp; | |
| 725 | |
| 726 // Only for special case of dividing by a power of 2 | |
| 727 if( frexp((double)f, &exp) != 0.5 ) return NULL; | |
| 728 | |
| 729 // Limit the range of acceptable exponents | |
| 730 if( exp < -126 || exp > 126 ) return NULL; | |
| 731 | |
| 732 // Compute the reciprocal | |
| 733 float reciprocal = ((float)1.0) / f; | |
| 734 | |
| 735 assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" ); | |
| 736 | |
| 737 // return multiplication by the reciprocal | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
738 return (new (phase->C) MulFNode(in(1), phase->makecon(TypeF::make(reciprocal)))); |
| 0 | 739 } |
| 740 | |
| 741 //============================================================================= | |
| 742 //------------------------------Value------------------------------------------ | |
| 743 // An DivDNode divides its inputs. The third input is a Control input, used to | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
744 // prevent hoisting the divide above an unsafe test. |
| 0 | 745 const Type *DivDNode::Value( PhaseTransform *phase ) const { |
| 746 // Either input is TOP ==> the result is TOP | |
| 747 const Type *t1 = phase->type( in(1) ); | |
| 748 const Type *t2 = phase->type( in(2) ); | |
| 749 if( t1 == Type::TOP ) return Type::TOP; | |
| 750 if( t2 == Type::TOP ) return Type::TOP; | |
| 751 | |
| 752 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 753 const Type *bot = bottom_type(); | |
| 754 if( (t1 == bot) || (t2 == bot) || | |
| 755 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 756 return bot; | |
| 757 | |
| 758 // x/x == 1, we ignore 0/0. | |
| 759 // Note: if t1 and t2 are zero then result is NaN (JVMS page 213) | |
| 760 // Does not work for variables because of NaN's | |
| 761 if( phase->eqv( in(1), in(2) ) && t1->base() == Type::DoubleCon) | |
| 762 if (!g_isnan(t1->getd()) && g_isfinite(t1->getd()) && t1->getd() != 0.0) // could be negative ZERO or NaN | |
| 763 return TypeD::ONE; | |
| 764 | |
| 765 if( t2 == TypeD::ONE ) | |
| 766 return t1; | |
| 767 | |
|
404
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
768 #if defined(IA32) |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
769 if (!phase->C->method()->is_strict()) |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
770 // Can't trust native compilers to properly fold strict double |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
771 // division with round-to-zero on this platform. |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
772 #endif |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
773 { |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
774 // If divisor is a constant and not zero, divide them numbers |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
775 if( t1->base() == Type::DoubleCon && |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
776 t2->base() == Type::DoubleCon && |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
777 t2->getd() != 0.0 ) // could be negative zero |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
778 return TypeD::make( t1->getd()/t2->getd() ); |
|
78c058bc5cdc
6717150: improper constant folding of subnormal strictfp multiplications and divides
rasbold
parents:
400
diff
changeset
|
779 } |
| 0 | 780 |
| 781 // If the dividend is a constant zero | |
| 782 // Note: if t1 and t2 are zero then result is NaN (JVMS page 213) | |
| 783 // Test TypeF::ZERO is not sufficient as it could be negative zero | |
| 784 if( t1 == TypeD::ZERO && !g_isnan(t2->getd()) && t2->getd() != 0.0 ) | |
| 785 return TypeD::ZERO; | |
| 786 | |
| 787 // Otherwise we give up all hope | |
| 788 return Type::DOUBLE; | |
| 789 } | |
| 790 | |
| 791 | |
| 792 //------------------------------isA_Copy--------------------------------------- | |
| 793 // Dividing by self is 1. | |
| 794 // If the divisor is 1, we are an identity on the dividend. | |
| 795 Node *DivDNode::Identity( PhaseTransform *phase ) { | |
| 796 return (phase->type( in(2) ) == TypeD::ONE) ? in(1) : this; | |
| 797 } | |
| 798 | |
| 799 //------------------------------Idealize--------------------------------------- | |
| 800 Node *DivDNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 801 if (in(0) && remove_dead_region(phase, can_reshape)) return this; | |
| 305 | 802 // Don't bother trying to transform a dead node |
| 803 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 804 |
| 805 const Type *t2 = phase->type( in(2) ); | |
| 806 if( t2 == TypeD::ONE ) // Identity? | |
| 807 return NULL; // Skip it | |
| 808 | |
| 809 const TypeD *td = t2->isa_double_constant(); | |
| 810 if( !td ) return NULL; | |
| 811 if( td->base() != Type::DoubleCon ) return NULL; | |
| 812 | |
| 813 // Check for out of range values | |
| 814 if( td->is_nan() || !td->is_finite() ) return NULL; | |
| 815 | |
| 816 // Get the value | |
| 817 double d = td->getd(); | |
| 818 int exp; | |
| 819 | |
| 820 // Only for special case of dividing by a power of 2 | |
| 821 if( frexp(d, &exp) != 0.5 ) return NULL; | |
| 822 | |
| 823 // Limit the range of acceptable exponents | |
| 824 if( exp < -1021 || exp > 1022 ) return NULL; | |
| 825 | |
| 826 // Compute the reciprocal | |
| 827 double reciprocal = 1.0 / d; | |
| 828 | |
| 829 assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" ); | |
| 830 | |
| 831 // return multiplication by the reciprocal | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
832 return (new (phase->C) MulDNode(in(1), phase->makecon(TypeD::make(reciprocal)))); |
| 0 | 833 } |
| 834 | |
| 835 //============================================================================= | |
| 836 //------------------------------Idealize--------------------------------------- | |
| 837 Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 838 // Check for dead control input | |
| 305 | 839 if( in(0) && remove_dead_region(phase, can_reshape) ) return this; |
| 840 // Don't bother trying to transform a dead node | |
| 841 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 842 |
| 843 // Get the modulus | |
| 844 const Type *t = phase->type( in(2) ); | |
| 845 if( t == Type::TOP ) return NULL; | |
| 846 const TypeInt *ti = t->is_int(); | |
| 847 | |
| 848 // Check for useless control input | |
| 849 // Check for excluding mod-zero case | |
| 850 if( in(0) && (ti->_hi < 0 || ti->_lo > 0) ) { | |
| 851 set_req(0, NULL); // Yank control input | |
| 852 return this; | |
| 853 } | |
| 854 | |
| 855 // See if we are MOD'ing by 2^k or 2^k-1. | |
| 856 if( !ti->is_con() ) return NULL; | |
| 857 jint con = ti->get_con(); | |
| 858 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
859 Node *hook = new (phase->C) Node(1); |
| 0 | 860 |
| 861 // First, special check for modulo 2^k-1 | |
| 862 if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) { | |
| 863 uint k = exact_log2(con+1); // Extract k | |
| 864 | |
| 865 // Basic algorithm by David Detlefs. See fastmod_int.java for gory details. | |
| 866 static int unroll_factor[] = { 999, 999, 29, 14, 9, 7, 5, 4, 4, 3, 3, 2, 2, 2, 2, 2, 1 /*past here we assume 1 forever*/}; | |
| 867 int trip_count = 1; | |
| 868 if( k < ARRAY_SIZE(unroll_factor)) trip_count = unroll_factor[k]; | |
| 869 | |
| 870 // If the unroll factor is not too large, and if conditional moves are | |
| 871 // ok, then use this case | |
| 872 if( trip_count <= 5 && ConditionalMoveLimit != 0 ) { | |
| 873 Node *x = in(1); // Value being mod'd | |
| 874 Node *divisor = in(2); // Also is mask | |
| 875 | |
| 876 hook->init_req(0, x); // Add a use to x to prevent him from dying | |
| 877 // Generate code to reduce X rapidly to nearly 2^k-1. | |
| 878 for( int i = 0; i < trip_count; i++ ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
879 Node *xl = phase->transform( new (phase->C) AndINode(x,divisor) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
880 Node *xh = phase->transform( new (phase->C) RShiftINode(x,phase->intcon(k)) ); // Must be signed |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
881 x = phase->transform( new (phase->C) AddINode(xh,xl) ); |
| 145 | 882 hook->set_req(0, x); |
| 0 | 883 } |
| 884 | |
| 885 // Generate sign-fixup code. Was original value positive? | |
| 886 // int hack_res = (i >= 0) ? divisor : 1; | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
887 Node *cmp1 = phase->transform( new (phase->C) CmpINode( in(1), phase->intcon(0) ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
888 Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
889 Node *cmov1= phase->transform( new (phase->C) CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) ); |
| 0 | 890 // if( x >= hack_res ) x -= divisor; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
891 Node *sub = phase->transform( new (phase->C) SubINode( x, divisor ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
892 Node *cmp2 = phase->transform( new (phase->C) CmpINode( x, cmov1 ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
893 Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) ); |
| 0 | 894 // Convention is to not transform the return value of an Ideal |
| 895 // since Ideal is expected to return a modified 'this' or a new node. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
896 Node *cmov2= new (phase->C) CMoveINode(bol2, x, sub, TypeInt::INT); |
| 0 | 897 // cmov2 is now the mod |
| 898 | |
| 899 // Now remove the bogus extra edges used to keep things alive | |
| 900 if (can_reshape) { | |
| 901 phase->is_IterGVN()->remove_dead_node(hook); | |
| 902 } else { | |
| 903 hook->set_req(0, NULL); // Just yank bogus edge during Parse phase | |
| 904 } | |
| 905 return cmov2; | |
| 906 } | |
| 907 } | |
| 908 | |
| 909 // Fell thru, the unroll case is not appropriate. Transform the modulo | |
| 910 // into a long multiply/int multiply/subtract case | |
| 911 | |
| 912 // Cannot handle mod 0, and min_jint isn't handled by the transform | |
| 913 if( con == 0 || con == min_jint ) return NULL; | |
| 914 | |
| 915 // Get the absolute value of the constant; at this point, we can use this | |
| 916 jint pos_con = (con >= 0) ? con : -con; | |
| 917 | |
| 918 // integer Mod 1 is always 0 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
919 if( pos_con == 1 ) return new (phase->C) ConINode(TypeInt::ZERO); |
| 0 | 920 |
| 921 int log2_con = -1; | |
| 922 | |
| 923 // If this is a power of two, they maybe we can mask it | |
| 924 if( is_power_of_2(pos_con) ) { | |
| 925 log2_con = log2_intptr((intptr_t)pos_con); | |
| 926 | |
| 927 const Type *dt = phase->type(in(1)); | |
| 928 const TypeInt *dti = dt->isa_int(); | |
| 929 | |
| 930 // See if this can be masked, if the dividend is non-negative | |
| 931 if( dti && dti->_lo >= 0 ) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
932 return ( new (phase->C) AndINode( in(1), phase->intcon( pos_con-1 ) ) ); |
| 0 | 933 } |
| 934 | |
| 935 // Save in(1) so that it cannot be changed or deleted | |
| 936 hook->init_req(0, in(1)); | |
| 937 | |
| 938 // Divide using the transform from DivI to MulL | |
| 145 | 939 Node *result = transform_int_divide( phase, in(1), pos_con ); |
| 940 if (result != NULL) { | |
| 941 Node *divide = phase->transform(result); | |
| 0 | 942 |
| 145 | 943 // Re-multiply, using a shift if this is a power of two |
| 944 Node *mult = NULL; | |
| 0 | 945 |
| 145 | 946 if( log2_con >= 0 ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
947 mult = phase->transform( new (phase->C) LShiftINode( divide, phase->intcon( log2_con ) ) ); |
| 145 | 948 else |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
949 mult = phase->transform( new (phase->C) MulINode( divide, phase->intcon( pos_con ) ) ); |
| 0 | 950 |
| 145 | 951 // Finally, subtract the multiplied divided value from the original |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
952 result = new (phase->C) SubINode( in(1), mult ); |
| 145 | 953 } |
| 0 | 954 |
| 955 // Now remove the bogus extra edges used to keep things alive | |
| 956 if (can_reshape) { | |
| 957 phase->is_IterGVN()->remove_dead_node(hook); | |
| 958 } else { | |
| 959 hook->set_req(0, NULL); // Just yank bogus edge during Parse phase | |
| 960 } | |
| 961 | |
| 962 // return the value | |
| 963 return result; | |
| 964 } | |
| 965 | |
| 966 //------------------------------Value------------------------------------------ | |
| 967 const Type *ModINode::Value( PhaseTransform *phase ) const { | |
| 968 // Either input is TOP ==> the result is TOP | |
| 969 const Type *t1 = phase->type( in(1) ); | |
| 970 const Type *t2 = phase->type( in(2) ); | |
| 971 if( t1 == Type::TOP ) return Type::TOP; | |
| 972 if( t2 == Type::TOP ) return Type::TOP; | |
| 973 | |
| 974 // We always generate the dynamic check for 0. | |
| 975 // 0 MOD X is 0 | |
| 976 if( t1 == TypeInt::ZERO ) return TypeInt::ZERO; | |
| 977 // X MOD X is 0 | |
| 978 if( phase->eqv( in(1), in(2) ) ) return TypeInt::ZERO; | |
| 979 | |
| 980 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 981 const Type *bot = bottom_type(); | |
| 982 if( (t1 == bot) || (t2 == bot) || | |
| 983 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 984 return bot; | |
| 985 | |
| 986 const TypeInt *i1 = t1->is_int(); | |
| 987 const TypeInt *i2 = t2->is_int(); | |
| 988 if( !i1->is_con() || !i2->is_con() ) { | |
| 989 if( i1->_lo >= 0 && i2->_lo >= 0 ) | |
| 990 return TypeInt::POS; | |
| 991 // If both numbers are not constants, we know little. | |
| 992 return TypeInt::INT; | |
| 993 } | |
| 994 // Mod by zero? Throw exception at runtime! | |
| 995 if( !i2->get_con() ) return TypeInt::POS; | |
| 996 | |
| 997 // We must be modulo'ing 2 float constants. | |
| 998 // Check for min_jint % '-1', result is defined to be '0'. | |
| 999 if( i1->get_con() == min_jint && i2->get_con() == -1 ) | |
| 1000 return TypeInt::ZERO; | |
| 1001 | |
| 1002 return TypeInt::make( i1->get_con() % i2->get_con() ); | |
| 1003 } | |
| 1004 | |
| 1005 | |
| 1006 //============================================================================= | |
| 1007 //------------------------------Idealize--------------------------------------- | |
| 1008 Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1009 // Check for dead control input | |
| 305 | 1010 if( in(0) && remove_dead_region(phase, can_reshape) ) return this; |
| 1011 // Don't bother trying to transform a dead node | |
| 1012 if( in(0) && in(0)->is_top() ) return NULL; | |
| 0 | 1013 |
| 1014 // Get the modulus | |
| 1015 const Type *t = phase->type( in(2) ); | |
| 1016 if( t == Type::TOP ) return NULL; | |
| 145 | 1017 const TypeLong *tl = t->is_long(); |
| 0 | 1018 |
| 1019 // Check for useless control input | |
| 1020 // Check for excluding mod-zero case | |
| 145 | 1021 if( in(0) && (tl->_hi < 0 || tl->_lo > 0) ) { |
| 0 | 1022 set_req(0, NULL); // Yank control input |
| 1023 return this; | |
| 1024 } | |
| 1025 | |
| 1026 // See if we are MOD'ing by 2^k or 2^k-1. | |
| 145 | 1027 if( !tl->is_con() ) return NULL; |
| 1028 jlong con = tl->get_con(); | |
| 1029 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1030 Node *hook = new (phase->C) Node(1); |
| 0 | 1031 |
| 1032 // Expand mod | |
| 145 | 1033 if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) { |
|
568
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
567
diff
changeset
|
1034 uint k = exact_log2_long(con+1); // Extract k |
| 145 | 1035 |
| 0 | 1036 // Basic algorithm by David Detlefs. See fastmod_long.java for gory details. |
| 1037 // Used to help a popular random number generator which does a long-mod | |
| 1038 // of 2^31-1 and shows up in SpecJBB and SciMark. | |
| 1039 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*/}; | |
| 1040 int trip_count = 1; | |
| 1041 if( k < ARRAY_SIZE(unroll_factor)) trip_count = unroll_factor[k]; | |
| 1042 | |
| 145 | 1043 // If the unroll factor is not too large, and if conditional moves are |
| 1044 // ok, then use this case | |
| 1045 if( trip_count <= 5 && ConditionalMoveLimit != 0 ) { | |
| 1046 Node *x = in(1); // Value being mod'd | |
| 1047 Node *divisor = in(2); // Also is mask | |
| 0 | 1048 |
| 145 | 1049 hook->init_req(0, x); // Add a use to x to prevent him from dying |
| 1050 // Generate code to reduce X rapidly to nearly 2^k-1. | |
| 1051 for( int i = 0; i < trip_count; i++ ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1052 Node *xl = phase->transform( new (phase->C) AndLNode(x,divisor) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1053 Node *xh = phase->transform( new (phase->C) RShiftLNode(x,phase->intcon(k)) ); // Must be signed |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1054 x = phase->transform( new (phase->C) AddLNode(xh,xl) ); |
| 0 | 1055 hook->set_req(0, x); // Add a use to x to prevent him from dying |
| 145 | 1056 } |
| 1057 | |
| 1058 // Generate sign-fixup code. Was original value positive? | |
| 1059 // long hack_res = (i >= 0) ? divisor : CONST64(1); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1060 Node *cmp1 = phase->transform( new (phase->C) CmpLNode( in(1), phase->longcon(0) ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1061 Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1062 Node *cmov1= phase->transform( new (phase->C) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) ); |
| 145 | 1063 // if( x >= hack_res ) x -= divisor; |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1064 Node *sub = phase->transform( new (phase->C) SubLNode( x, divisor ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1065 Node *cmp2 = phase->transform( new (phase->C) CmpLNode( x, cmov1 ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1066 Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) ); |
| 145 | 1067 // Convention is to not transform the return value of an Ideal |
| 1068 // since Ideal is expected to return a modified 'this' or a new node. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1069 Node *cmov2= new (phase->C) CMoveLNode(bol2, x, sub, TypeLong::LONG); |
| 145 | 1070 // cmov2 is now the mod |
| 1071 | |
| 1072 // Now remove the bogus extra edges used to keep things alive | |
| 1073 if (can_reshape) { | |
| 1074 phase->is_IterGVN()->remove_dead_node(hook); | |
| 1075 } else { | |
| 1076 hook->set_req(0, NULL); // Just yank bogus edge during Parse phase | |
| 1077 } | |
| 1078 return cmov2; | |
| 0 | 1079 } |
| 145 | 1080 } |
| 1081 | |
| 1082 // Fell thru, the unroll case is not appropriate. Transform the modulo | |
| 1083 // into a long multiply/int multiply/subtract case | |
| 1084 | |
|
1914
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
1085 // Cannot handle mod 0, and min_jlong isn't handled by the transform |
| 145 | 1086 if( con == 0 || con == min_jlong ) return NULL; |
| 1087 | |
| 1088 // Get the absolute value of the constant; at this point, we can use this | |
| 1089 jlong pos_con = (con >= 0) ? con : -con; | |
| 1090 | |
| 1091 // integer Mod 1 is always 0 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1092 if( pos_con == 1 ) return new (phase->C) ConLNode(TypeLong::ZERO); |
| 145 | 1093 |
| 1094 int log2_con = -1; | |
| 1095 | |
| 605 | 1096 // If this is a power of two, then maybe we can mask it |
| 145 | 1097 if( is_power_of_2_long(pos_con) ) { |
|
1914
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
1098 log2_con = exact_log2_long(pos_con); |
| 145 | 1099 |
| 1100 const Type *dt = phase->type(in(1)); | |
| 1101 const TypeLong *dtl = dt->isa_long(); | |
| 1102 | |
| 1103 // See if this can be masked, if the dividend is non-negative | |
| 1104 if( dtl && dtl->_lo >= 0 ) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1105 return ( new (phase->C) AndLNode( in(1), phase->longcon( pos_con-1 ) ) ); |
| 145 | 1106 } |
| 0 | 1107 |
| 145 | 1108 // Save in(1) so that it cannot be changed or deleted |
| 1109 hook->init_req(0, in(1)); | |
| 1110 | |
|
1914
ae065c367d93
6987135: Performance regression on Intel platform with 32-bits edition between 6u13 and 6u14.
kvn
parents:
1552
diff
changeset
|
1111 // Divide using the transform from DivL to MulL |
| 145 | 1112 Node *result = transform_long_divide( phase, in(1), pos_con ); |
| 1113 if (result != NULL) { | |
| 1114 Node *divide = phase->transform(result); | |
| 1115 | |
| 1116 // Re-multiply, using a shift if this is a power of two | |
| 1117 Node *mult = NULL; | |
| 1118 | |
| 1119 if( log2_con >= 0 ) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1120 mult = phase->transform( new (phase->C) LShiftLNode( divide, phase->intcon( log2_con ) ) ); |
| 145 | 1121 else |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1122 mult = phase->transform( new (phase->C) MulLNode( divide, phase->longcon( pos_con ) ) ); |
| 145 | 1123 |
| 1124 // Finally, subtract the multiplied divided value from the original | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1125 result = new (phase->C) SubLNode( in(1), mult ); |
| 0 | 1126 } |
| 145 | 1127 |
| 1128 // Now remove the bogus extra edges used to keep things alive | |
| 1129 if (can_reshape) { | |
| 1130 phase->is_IterGVN()->remove_dead_node(hook); | |
| 1131 } else { | |
| 1132 hook->set_req(0, NULL); // Just yank bogus edge during Parse phase | |
| 1133 } | |
| 1134 | |
| 1135 // return the value | |
| 1136 return result; | |
| 0 | 1137 } |
| 1138 | |
| 1139 //------------------------------Value------------------------------------------ | |
| 1140 const Type *ModLNode::Value( PhaseTransform *phase ) const { | |
| 1141 // Either input is TOP ==> the result is TOP | |
| 1142 const Type *t1 = phase->type( in(1) ); | |
| 1143 const Type *t2 = phase->type( in(2) ); | |
| 1144 if( t1 == Type::TOP ) return Type::TOP; | |
| 1145 if( t2 == Type::TOP ) return Type::TOP; | |
| 1146 | |
| 1147 // We always generate the dynamic check for 0. | |
| 1148 // 0 MOD X is 0 | |
| 1149 if( t1 == TypeLong::ZERO ) return TypeLong::ZERO; | |
| 1150 // X MOD X is 0 | |
| 1151 if( phase->eqv( in(1), in(2) ) ) return TypeLong::ZERO; | |
| 1152 | |
| 1153 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 1154 const Type *bot = bottom_type(); | |
| 1155 if( (t1 == bot) || (t2 == bot) || | |
| 1156 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 1157 return bot; | |
| 1158 | |
| 1159 const TypeLong *i1 = t1->is_long(); | |
| 1160 const TypeLong *i2 = t2->is_long(); | |
| 1161 if( !i1->is_con() || !i2->is_con() ) { | |
| 1162 if( i1->_lo >= CONST64(0) && i2->_lo >= CONST64(0) ) | |
| 1163 return TypeLong::POS; | |
| 1164 // If both numbers are not constants, we know little. | |
| 1165 return TypeLong::LONG; | |
| 1166 } | |
| 1167 // Mod by zero? Throw exception at runtime! | |
| 1168 if( !i2->get_con() ) return TypeLong::POS; | |
| 1169 | |
| 1170 // We must be modulo'ing 2 float constants. | |
| 1171 // Check for min_jint % '-1', result is defined to be '0'. | |
| 1172 if( i1->get_con() == min_jlong && i2->get_con() == -1 ) | |
| 1173 return TypeLong::ZERO; | |
| 1174 | |
| 1175 return TypeLong::make( i1->get_con() % i2->get_con() ); | |
| 1176 } | |
| 1177 | |
| 1178 | |
| 1179 //============================================================================= | |
| 1180 //------------------------------Value------------------------------------------ | |
| 1181 const Type *ModFNode::Value( PhaseTransform *phase ) const { | |
| 1182 // Either input is TOP ==> the result is TOP | |
| 1183 const Type *t1 = phase->type( in(1) ); | |
| 1184 const Type *t2 = phase->type( in(2) ); | |
| 1185 if( t1 == Type::TOP ) return Type::TOP; | |
| 1186 if( t2 == Type::TOP ) return Type::TOP; | |
| 1187 | |
| 1188 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 1189 const Type *bot = bottom_type(); | |
| 1190 if( (t1 == bot) || (t2 == bot) || | |
| 1191 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 1192 return bot; | |
| 1193 | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1194 // If either number is not a constant, we know nothing. |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1195 if ((t1->base() != Type::FloatCon) || (t2->base() != Type::FloatCon)) { |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1196 return Type::FLOAT; // note: x%x can be either NaN or 0 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1197 } |
| 0 | 1198 |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1199 float f1 = t1->getf(); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1200 float f2 = t2->getf(); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1201 jint x1 = jint_cast(f1); // note: *(int*)&f1, not just (int)f1 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1202 jint x2 = jint_cast(f2); |
| 0 | 1203 |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1204 // If either is a NaN, return an input NaN |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1205 if (g_isnan(f1)) return t1; |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1206 if (g_isnan(f2)) return t2; |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1207 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1208 // If an operand is infinity or the divisor is +/- zero, punt. |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1209 if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jint) |
| 0 | 1210 return Type::FLOAT; |
| 1211 | |
| 1212 // We must be modulo'ing 2 float constants. | |
| 1213 // Make sure that the sign of the fmod is equal to the sign of the dividend | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1214 jint xr = jint_cast(fmod(f1, f2)); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1215 if ((x1 ^ xr) < 0) { |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1216 xr ^= min_jint; |
| 0 | 1217 } |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1218 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1219 return TypeF::make(jfloat_cast(xr)); |
| 0 | 1220 } |
| 1221 | |
| 1222 | |
| 1223 //============================================================================= | |
| 1224 //------------------------------Value------------------------------------------ | |
| 1225 const Type *ModDNode::Value( PhaseTransform *phase ) const { | |
| 1226 // Either input is TOP ==> the result is TOP | |
| 1227 const Type *t1 = phase->type( in(1) ); | |
| 1228 const Type *t2 = phase->type( in(2) ); | |
| 1229 if( t1 == Type::TOP ) return Type::TOP; | |
| 1230 if( t2 == Type::TOP ) return Type::TOP; | |
| 1231 | |
| 1232 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 1233 const Type *bot = bottom_type(); | |
| 1234 if( (t1 == bot) || (t2 == bot) || | |
| 1235 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 1236 return bot; | |
| 1237 | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1238 // If either number is not a constant, we know nothing. |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1239 if ((t1->base() != Type::DoubleCon) || (t2->base() != Type::DoubleCon)) { |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1240 return Type::DOUBLE; // note: x%x can be either NaN or 0 |
| 0 | 1241 } |
| 1242 | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1243 double f1 = t1->getd(); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1244 double f2 = t2->getd(); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1245 jlong x1 = jlong_cast(f1); // note: *(long*)&f1, not just (long)f1 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1246 jlong x2 = jlong_cast(f2); |
| 0 | 1247 |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1248 // If either is a NaN, return an input NaN |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1249 if (g_isnan(f1)) return t1; |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1250 if (g_isnan(f2)) return t2; |
| 0 | 1251 |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1252 // If an operand is infinity or the divisor is +/- zero, punt. |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1253 if (!g_isfinite(f1) || !g_isfinite(f2) || x2 == 0 || x2 == min_jlong) |
| 0 | 1254 return Type::DOUBLE; |
| 1255 | |
| 1256 // We must be modulo'ing 2 double constants. | |
|
131
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1257 // Make sure that the sign of the fmod is equal to the sign of the dividend |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1258 jlong xr = jlong_cast(fmod(f1, f2)); |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1259 if ((x1 ^ xr) < 0) { |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1260 xr ^= min_jlong; |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1261 } |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1262 |
|
6e825ad773c6
6695288: runThese tests expr30303 and drem00301m1 fail when compiled code executes without deopt
jrose
parents:
0
diff
changeset
|
1263 return TypeD::make(jdouble_cast(xr)); |
| 0 | 1264 } |
| 1265 | |
| 1266 //============================================================================= | |
| 1267 | |
| 1268 DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) { | |
| 1269 init_req(0, c); | |
| 1270 init_req(1, dividend); | |
| 1271 init_req(2, divisor); | |
| 1272 } | |
| 1273 | |
| 1274 //------------------------------make------------------------------------------ | |
| 1275 DivModINode* DivModINode::make(Compile* C, Node* div_or_mod) { | |
| 1276 Node* n = div_or_mod; | |
| 1277 assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI, | |
| 1278 "only div or mod input pattern accepted"); | |
| 1279 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1280 DivModINode* divmod = new (C) DivModINode(n->in(0), n->in(1), n->in(2)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1281 Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1282 Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num); |
| 0 | 1283 return divmod; |
| 1284 } | |
| 1285 | |
| 1286 //------------------------------make------------------------------------------ | |
| 1287 DivModLNode* DivModLNode::make(Compile* C, Node* div_or_mod) { | |
| 1288 Node* n = div_or_mod; | |
| 1289 assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL, | |
| 1290 "only div or mod input pattern accepted"); | |
| 1291 | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1292 DivModLNode* divmod = new (C) DivModLNode(n->in(0), n->in(1), n->in(2)); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1293 Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1294 Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num); |
| 0 | 1295 return divmod; |
| 1296 } | |
| 1297 | |
| 1298 //------------------------------match------------------------------------------ | |
| 1299 // return result(s) along with their RegMask info | |
| 1300 Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) { | |
| 1301 uint ideal_reg = proj->ideal_reg(); | |
| 1302 RegMask rm; | |
| 1303 if (proj->_con == div_proj_num) { | |
| 1304 rm = match->divI_proj_mask(); | |
| 1305 } else { | |
| 1306 assert(proj->_con == mod_proj_num, "must be div or mod projection"); | |
| 1307 rm = match->modI_proj_mask(); | |
| 1308 } | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1309 return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg); |
| 0 | 1310 } |
| 1311 | |
| 1312 | |
| 1313 //------------------------------match------------------------------------------ | |
| 1314 // return result(s) along with their RegMask info | |
| 1315 Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) { | |
| 1316 uint ideal_reg = proj->ideal_reg(); | |
| 1317 RegMask rm; | |
| 1318 if (proj->_con == div_proj_num) { | |
| 1319 rm = match->divL_proj_mask(); | |
| 1320 } else { | |
| 1321 assert(proj->_con == mod_proj_num, "must be div or mod projection"); | |
| 1322 rm = match->modL_proj_mask(); | |
| 1323 } | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
6142
diff
changeset
|
1324 return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg); |
| 0 | 1325 } |