Mercurial > hg > truffle
annotate src/share/vm/opto/subnode.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | f1d6640088a1 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1174
diff
changeset
|
2 * Copyright (c) 1997, 2010, 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:
1174
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1174
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:
1174
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "compiler/compileLog.hpp" | |
| 27 #include "memory/allocation.inline.hpp" | |
| 28 #include "opto/addnode.hpp" | |
| 29 #include "opto/callnode.hpp" | |
| 30 #include "opto/cfgnode.hpp" | |
| 31 #include "opto/connode.hpp" | |
| 32 #include "opto/loopnode.hpp" | |
| 33 #include "opto/matcher.hpp" | |
| 34 #include "opto/mulnode.hpp" | |
| 35 #include "opto/opcodes.hpp" | |
| 36 #include "opto/phaseX.hpp" | |
| 37 #include "opto/subnode.hpp" | |
| 38 #include "runtime/sharedRuntime.hpp" | |
| 39 | |
| 0 | 40 // Portions of code courtesy of Clifford Click |
| 41 | |
| 42 // Optimization - Graph Style | |
| 43 | |
| 44 #include "math.h" | |
| 45 | |
| 46 //============================================================================= | |
| 47 //------------------------------Identity--------------------------------------- | |
| 48 // If right input is a constant 0, return the left input. | |
| 49 Node *SubNode::Identity( PhaseTransform *phase ) { | |
| 50 assert(in(1) != this, "Must already have called Value"); | |
| 51 assert(in(2) != this, "Must already have called Value"); | |
| 52 | |
| 53 // Remove double negation | |
| 54 const Type *zero = add_id(); | |
| 55 if( phase->type( in(1) )->higher_equal( zero ) && | |
| 56 in(2)->Opcode() == Opcode() && | |
| 57 phase->type( in(2)->in(1) )->higher_equal( zero ) ) { | |
| 58 return in(2)->in(2); | |
| 59 } | |
| 60 | |
| 212 | 61 // Convert "(X+Y) - Y" into X and "(X+Y) - X" into Y |
| 0 | 62 if( in(1)->Opcode() == Op_AddI ) { |
| 63 if( phase->eqv(in(1)->in(2),in(2)) ) | |
| 64 return in(1)->in(1); | |
| 212 | 65 if (phase->eqv(in(1)->in(1),in(2))) |
| 66 return in(1)->in(2); | |
| 67 | |
| 0 | 68 // Also catch: "(X + Opaque2(Y)) - Y". In this case, 'Y' is a loop-varying |
| 69 // trip counter and X is likely to be loop-invariant (that's how O2 Nodes | |
| 70 // are originally used, although the optimizer sometimes jiggers things). | |
| 71 // This folding through an O2 removes a loop-exit use of a loop-varying | |
| 72 // value and generally lowers register pressure in and around the loop. | |
| 73 if( in(1)->in(2)->Opcode() == Op_Opaque2 && | |
| 74 phase->eqv(in(1)->in(2)->in(1),in(2)) ) | |
| 75 return in(1)->in(1); | |
| 76 } | |
| 77 | |
| 78 return ( phase->type( in(2) )->higher_equal( zero ) ) ? in(1) : this; | |
| 79 } | |
| 80 | |
| 81 //------------------------------Value------------------------------------------ | |
| 82 // A subtract node differences it's two inputs. | |
| 83 const Type *SubNode::Value( PhaseTransform *phase ) const { | |
| 84 const Node* in1 = in(1); | |
| 85 const Node* in2 = in(2); | |
| 86 // Either input is TOP ==> the result is TOP | |
| 87 const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1); | |
| 88 if( t1 == Type::TOP ) return Type::TOP; | |
| 89 const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2); | |
| 90 if( t2 == Type::TOP ) return Type::TOP; | |
| 91 | |
| 92 // Not correct for SubFnode and AddFNode (must check for infinity) | |
| 93 // Equal? Subtract is zero | |
| 94 if (phase->eqv_uncast(in1, in2)) return add_id(); | |
| 95 | |
| 96 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 97 if( t1 == Type::BOTTOM || t2 == Type::BOTTOM ) | |
| 98 return bottom_type(); | |
| 99 | |
| 100 return sub(t1,t2); // Local flavor of type subtraction | |
| 101 | |
| 102 } | |
| 103 | |
| 104 //============================================================================= | |
| 105 | |
| 106 //------------------------------Helper function-------------------------------- | |
| 107 static bool ok_to_convert(Node* inc, Node* iv) { | |
| 108 // Do not collapse (x+c0)-y if "+" is a loop increment, because the | |
| 109 // "-" is loop invariant and collapsing extends the live-range of "x" | |
| 110 // to overlap with the "+", forcing another register to be used in | |
| 111 // the loop. | |
| 112 // This test will be clearer with '&&' (apply DeMorgan's rule) | |
| 113 // but I like the early cutouts that happen here. | |
| 114 const PhiNode *phi; | |
| 115 if( ( !inc->in(1)->is_Phi() || | |
| 116 !(phi=inc->in(1)->as_Phi()) || | |
| 117 phi->is_copy() || | |
| 118 !phi->region()->is_CountedLoop() || | |
| 119 inc != phi->region()->as_CountedLoop()->incr() ) | |
| 120 && | |
| 121 // Do not collapse (x+c0)-iv if "iv" is a loop induction variable, | |
| 122 // because "x" maybe invariant. | |
| 123 ( !iv->is_loop_iv() ) | |
| 124 ) { | |
| 125 return true; | |
| 126 } else { | |
| 127 return false; | |
| 128 } | |
| 129 } | |
| 130 //------------------------------Ideal------------------------------------------ | |
| 131 Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){ | |
| 132 Node *in1 = in(1); | |
| 133 Node *in2 = in(2); | |
| 134 uint op1 = in1->Opcode(); | |
| 135 uint op2 = in2->Opcode(); | |
| 136 | |
| 137 #ifdef ASSERT | |
| 138 // Check for dead loop | |
| 139 if( phase->eqv( in1, this ) || phase->eqv( in2, this ) || | |
| 140 ( op1 == Op_AddI || op1 == Op_SubI ) && | |
| 141 ( phase->eqv( in1->in(1), this ) || phase->eqv( in1->in(2), this ) || | |
| 142 phase->eqv( in1->in(1), in1 ) || phase->eqv( in1->in(2), in1 ) ) ) | |
| 143 assert(false, "dead loop in SubINode::Ideal"); | |
| 144 #endif | |
| 145 | |
| 146 const Type *t2 = phase->type( in2 ); | |
| 147 if( t2 == Type::TOP ) return NULL; | |
| 148 // Convert "x-c0" into "x+ -c0". | |
| 149 if( t2->base() == Type::Int ){ // Might be bottom or top... | |
| 150 const TypeInt *i = t2->is_int(); | |
| 151 if( i->is_con() ) | |
| 152 return new (phase->C, 3) AddINode(in1, phase->intcon(-i->get_con())); | |
| 153 } | |
| 154 | |
| 155 // Convert "(x+c0) - y" into (x-y) + c0" | |
| 156 // Do not collapse (x+c0)-y if "+" is a loop increment or | |
| 157 // if "y" is a loop induction variable. | |
| 158 if( op1 == Op_AddI && ok_to_convert(in1, in2) ) { | |
| 159 const Type *tadd = phase->type( in1->in(2) ); | |
| 160 if( tadd->singleton() && tadd != Type::TOP ) { | |
| 161 Node *sub2 = phase->transform( new (phase->C, 3) SubINode( in1->in(1), in2 )); | |
| 162 return new (phase->C, 3) AddINode( sub2, in1->in(2) ); | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 | |
| 167 // Convert "x - (y+c0)" into "(x-y) - c0" | |
| 168 // Need the same check as in above optimization but reversed. | |
| 169 if (op2 == Op_AddI && ok_to_convert(in2, in1)) { | |
| 170 Node* in21 = in2->in(1); | |
| 171 Node* in22 = in2->in(2); | |
| 172 const TypeInt* tcon = phase->type(in22)->isa_int(); | |
| 173 if (tcon != NULL && tcon->is_con()) { | |
| 174 Node* sub2 = phase->transform( new (phase->C, 3) SubINode(in1, in21) ); | |
| 175 Node* neg_c0 = phase->intcon(- tcon->get_con()); | |
| 176 return new (phase->C, 3) AddINode(sub2, neg_c0); | |
| 177 } | |
| 178 } | |
| 179 | |
| 180 const Type *t1 = phase->type( in1 ); | |
| 181 if( t1 == Type::TOP ) return NULL; | |
| 182 | |
| 183 #ifdef ASSERT | |
| 184 // Check for dead loop | |
| 185 if( ( op2 == Op_AddI || op2 == Op_SubI ) && | |
| 186 ( phase->eqv( in2->in(1), this ) || phase->eqv( in2->in(2), this ) || | |
| 187 phase->eqv( in2->in(1), in2 ) || phase->eqv( in2->in(2), in2 ) ) ) | |
| 188 assert(false, "dead loop in SubINode::Ideal"); | |
| 189 #endif | |
| 190 | |
| 191 // Convert "x - (x+y)" into "-y" | |
| 192 if( op2 == Op_AddI && | |
| 193 phase->eqv( in1, in2->in(1) ) ) | |
| 194 return new (phase->C, 3) SubINode( phase->intcon(0),in2->in(2)); | |
| 195 // Convert "(x-y) - x" into "-y" | |
| 196 if( op1 == Op_SubI && | |
| 197 phase->eqv( in1->in(1), in2 ) ) | |
| 198 return new (phase->C, 3) SubINode( phase->intcon(0),in1->in(2)); | |
| 199 // Convert "x - (y+x)" into "-y" | |
| 200 if( op2 == Op_AddI && | |
| 201 phase->eqv( in1, in2->in(2) ) ) | |
| 202 return new (phase->C, 3) SubINode( phase->intcon(0),in2->in(1)); | |
| 203 | |
| 204 // Convert "0 - (x-y)" into "y-x" | |
| 205 if( t1 == TypeInt::ZERO && op2 == Op_SubI ) | |
| 206 return new (phase->C, 3) SubINode( in2->in(2), in2->in(1) ); | |
| 207 | |
| 208 // Convert "0 - (x+con)" into "-con-x" | |
| 209 jint con; | |
| 210 if( t1 == TypeInt::ZERO && op2 == Op_AddI && | |
| 211 (con = in2->in(2)->find_int_con(0)) != 0 ) | |
| 212 return new (phase->C, 3) SubINode( phase->intcon(-con), in2->in(1) ); | |
| 213 | |
| 214 // Convert "(X+A) - (X+B)" into "A - B" | |
| 215 if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(1) ) | |
| 216 return new (phase->C, 3) SubINode( in1->in(2), in2->in(2) ); | |
| 217 | |
| 218 // Convert "(A+X) - (B+X)" into "A - B" | |
| 219 if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(2) ) | |
| 220 return new (phase->C, 3) SubINode( in1->in(1), in2->in(1) ); | |
| 221 | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
222 // Convert "(A+X) - (X+B)" into "A - B" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
223 if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(1) ) |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
224 return new (phase->C, 3) SubINode( in1->in(1), in2->in(2) ); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
225 |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
226 // Convert "(X+A) - (B+X)" into "A - B" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
227 if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(2) ) |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
228 return new (phase->C, 3) SubINode( in1->in(2), in2->in(1) ); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
296
diff
changeset
|
229 |
| 0 | 230 // Convert "A-(B-C)" into (A+C)-B", since add is commutative and generally |
| 231 // nicer to optimize than subtract. | |
| 232 if( op2 == Op_SubI && in2->outcnt() == 1) { | |
| 233 Node *add1 = phase->transform( new (phase->C, 3) AddINode( in1, in2->in(2) ) ); | |
| 234 return new (phase->C, 3) SubINode( add1, in2->in(1) ); | |
| 235 } | |
| 236 | |
| 237 return NULL; | |
| 238 } | |
| 239 | |
| 240 //------------------------------sub-------------------------------------------- | |
| 241 // A subtract node differences it's two inputs. | |
| 242 const Type *SubINode::sub( const Type *t1, const Type *t2 ) const { | |
| 243 const TypeInt *r0 = t1->is_int(); // Handy access | |
| 244 const TypeInt *r1 = t2->is_int(); | |
| 245 int32 lo = r0->_lo - r1->_hi; | |
| 246 int32 hi = r0->_hi - r1->_lo; | |
| 247 | |
| 248 // We next check for 32-bit overflow. | |
| 249 // If that happens, we just assume all integers are possible. | |
| 250 if( (((r0->_lo ^ r1->_hi) >= 0) || // lo ends have same signs OR | |
| 251 ((r0->_lo ^ lo) >= 0)) && // lo results have same signs AND | |
| 252 (((r0->_hi ^ r1->_lo) >= 0) || // hi ends have same signs OR | |
| 253 ((r0->_hi ^ hi) >= 0)) ) // hi results have same signs | |
| 254 return TypeInt::make(lo,hi,MAX2(r0->_widen,r1->_widen)); | |
| 255 else // Overflow; assume all integers | |
| 256 return TypeInt::INT; | |
| 257 } | |
| 258 | |
| 259 //============================================================================= | |
| 260 //------------------------------Ideal------------------------------------------ | |
| 261 Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 262 Node *in1 = in(1); | |
| 263 Node *in2 = in(2); | |
| 264 uint op1 = in1->Opcode(); | |
| 265 uint op2 = in2->Opcode(); | |
| 266 | |
| 267 #ifdef ASSERT | |
| 268 // Check for dead loop | |
| 269 if( phase->eqv( in1, this ) || phase->eqv( in2, this ) || | |
| 270 ( op1 == Op_AddL || op1 == Op_SubL ) && | |
| 271 ( phase->eqv( in1->in(1), this ) || phase->eqv( in1->in(2), this ) || | |
| 272 phase->eqv( in1->in(1), in1 ) || phase->eqv( in1->in(2), in1 ) ) ) | |
| 273 assert(false, "dead loop in SubLNode::Ideal"); | |
| 274 #endif | |
| 275 | |
| 276 if( phase->type( in2 ) == Type::TOP ) return NULL; | |
| 277 const TypeLong *i = phase->type( in2 )->isa_long(); | |
| 278 // Convert "x-c0" into "x+ -c0". | |
| 279 if( i && // Might be bottom or top... | |
| 280 i->is_con() ) | |
| 281 return new (phase->C, 3) AddLNode(in1, phase->longcon(-i->get_con())); | |
| 282 | |
| 283 // Convert "(x+c0) - y" into (x-y) + c0" | |
| 284 // Do not collapse (x+c0)-y if "+" is a loop increment or | |
| 285 // if "y" is a loop induction variable. | |
| 286 if( op1 == Op_AddL && ok_to_convert(in1, in2) ) { | |
| 287 Node *in11 = in1->in(1); | |
| 288 const Type *tadd = phase->type( in1->in(2) ); | |
| 289 if( tadd->singleton() && tadd != Type::TOP ) { | |
| 290 Node *sub2 = phase->transform( new (phase->C, 3) SubLNode( in11, in2 )); | |
| 291 return new (phase->C, 3) AddLNode( sub2, in1->in(2) ); | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 // Convert "x - (y+c0)" into "(x-y) - c0" | |
| 296 // Need the same check as in above optimization but reversed. | |
| 297 if (op2 == Op_AddL && ok_to_convert(in2, in1)) { | |
| 298 Node* in21 = in2->in(1); | |
| 299 Node* in22 = in2->in(2); | |
| 300 const TypeLong* tcon = phase->type(in22)->isa_long(); | |
| 301 if (tcon != NULL && tcon->is_con()) { | |
| 302 Node* sub2 = phase->transform( new (phase->C, 3) SubLNode(in1, in21) ); | |
| 303 Node* neg_c0 = phase->longcon(- tcon->get_con()); | |
| 304 return new (phase->C, 3) AddLNode(sub2, neg_c0); | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 const Type *t1 = phase->type( in1 ); | |
| 309 if( t1 == Type::TOP ) return NULL; | |
| 310 | |
| 311 #ifdef ASSERT | |
| 312 // Check for dead loop | |
| 313 if( ( op2 == Op_AddL || op2 == Op_SubL ) && | |
| 314 ( phase->eqv( in2->in(1), this ) || phase->eqv( in2->in(2), this ) || | |
| 315 phase->eqv( in2->in(1), in2 ) || phase->eqv( in2->in(2), in2 ) ) ) | |
| 316 assert(false, "dead loop in SubLNode::Ideal"); | |
| 317 #endif | |
| 318 | |
| 319 // Convert "x - (x+y)" into "-y" | |
| 320 if( op2 == Op_AddL && | |
| 321 phase->eqv( in1, in2->in(1) ) ) | |
| 322 return new (phase->C, 3) SubLNode( phase->makecon(TypeLong::ZERO), in2->in(2)); | |
| 323 // Convert "x - (y+x)" into "-y" | |
| 324 if( op2 == Op_AddL && | |
| 325 phase->eqv( in1, in2->in(2) ) ) | |
| 326 return new (phase->C, 3) SubLNode( phase->makecon(TypeLong::ZERO),in2->in(1)); | |
| 327 | |
| 328 // Convert "0 - (x-y)" into "y-x" | |
| 329 if( phase->type( in1 ) == TypeLong::ZERO && op2 == Op_SubL ) | |
| 330 return new (phase->C, 3) SubLNode( in2->in(2), in2->in(1) ); | |
| 331 | |
| 332 // Convert "(X+A) - (X+B)" into "A - B" | |
| 333 if( op1 == Op_AddL && op2 == Op_AddL && in1->in(1) == in2->in(1) ) | |
| 334 return new (phase->C, 3) SubLNode( in1->in(2), in2->in(2) ); | |
| 335 | |
| 336 // Convert "(A+X) - (B+X)" into "A - B" | |
| 337 if( op1 == Op_AddL && op2 == Op_AddL && in1->in(2) == in2->in(2) ) | |
| 338 return new (phase->C, 3) SubLNode( in1->in(1), in2->in(1) ); | |
| 339 | |
| 340 // Convert "A-(B-C)" into (A+C)-B" | |
| 341 if( op2 == Op_SubL && in2->outcnt() == 1) { | |
| 342 Node *add1 = phase->transform( new (phase->C, 3) AddLNode( in1, in2->in(2) ) ); | |
| 343 return new (phase->C, 3) SubLNode( add1, in2->in(1) ); | |
| 344 } | |
| 345 | |
| 346 return NULL; | |
| 347 } | |
| 348 | |
| 349 //------------------------------sub-------------------------------------------- | |
| 350 // A subtract node differences it's two inputs. | |
| 351 const Type *SubLNode::sub( const Type *t1, const Type *t2 ) const { | |
| 352 const TypeLong *r0 = t1->is_long(); // Handy access | |
| 353 const TypeLong *r1 = t2->is_long(); | |
| 354 jlong lo = r0->_lo - r1->_hi; | |
| 355 jlong hi = r0->_hi - r1->_lo; | |
| 356 | |
| 357 // We next check for 32-bit overflow. | |
| 358 // If that happens, we just assume all integers are possible. | |
| 359 if( (((r0->_lo ^ r1->_hi) >= 0) || // lo ends have same signs OR | |
| 360 ((r0->_lo ^ lo) >= 0)) && // lo results have same signs AND | |
| 361 (((r0->_hi ^ r1->_lo) >= 0) || // hi ends have same signs OR | |
| 362 ((r0->_hi ^ hi) >= 0)) ) // hi results have same signs | |
| 363 return TypeLong::make(lo,hi,MAX2(r0->_widen,r1->_widen)); | |
| 364 else // Overflow; assume all integers | |
| 365 return TypeLong::LONG; | |
| 366 } | |
| 367 | |
| 368 //============================================================================= | |
| 369 //------------------------------Value------------------------------------------ | |
| 370 // A subtract node differences its two inputs. | |
| 371 const Type *SubFPNode::Value( PhaseTransform *phase ) const { | |
| 372 const Node* in1 = in(1); | |
| 373 const Node* in2 = in(2); | |
| 374 // Either input is TOP ==> the result is TOP | |
| 375 const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1); | |
| 376 if( t1 == Type::TOP ) return Type::TOP; | |
| 377 const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2); | |
| 378 if( t2 == Type::TOP ) return Type::TOP; | |
| 379 | |
| 380 // if both operands are infinity of same sign, the result is NaN; do | |
| 381 // not replace with zero | |
| 382 if( (t1->is_finite() && t2->is_finite()) ) { | |
| 383 if( phase->eqv(in1, in2) ) return add_id(); | |
| 384 } | |
| 385 | |
| 386 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 387 const Type *bot = bottom_type(); | |
| 388 if( (t1 == bot) || (t2 == bot) || | |
| 389 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 390 return bot; | |
| 391 | |
| 392 return sub(t1,t2); // Local flavor of type subtraction | |
| 393 } | |
| 394 | |
| 395 | |
| 396 //============================================================================= | |
| 397 //------------------------------Ideal------------------------------------------ | |
| 398 Node *SubFNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 399 const Type *t2 = phase->type( in(2) ); | |
| 400 // Convert "x-c0" into "x+ -c0". | |
| 401 if( t2->base() == Type::FloatCon ) { // Might be bottom or top... | |
| 402 // return new (phase->C, 3) AddFNode(in(1), phase->makecon( TypeF::make(-t2->getf()) ) ); | |
| 403 } | |
| 404 | |
| 405 // Not associative because of boundary conditions (infinity) | |
| 406 if( IdealizedNumerics && !phase->C->method()->is_strict() ) { | |
| 407 // Convert "x - (x+y)" into "-y" | |
| 408 if( in(2)->is_Add() && | |
| 409 phase->eqv(in(1),in(2)->in(1) ) ) | |
| 410 return new (phase->C, 3) SubFNode( phase->makecon(TypeF::ZERO),in(2)->in(2)); | |
| 411 } | |
| 412 | |
| 413 // Cannot replace 0.0-X with -X because a 'fsub' bytecode computes | |
| 414 // 0.0-0.0 as +0.0, while a 'fneg' bytecode computes -0.0. | |
| 415 //if( phase->type(in(1)) == TypeF::ZERO ) | |
| 416 //return new (phase->C, 2) NegFNode(in(2)); | |
| 417 | |
| 418 return NULL; | |
| 419 } | |
| 420 | |
| 421 //------------------------------sub-------------------------------------------- | |
| 422 // A subtract node differences its two inputs. | |
| 423 const Type *SubFNode::sub( const Type *t1, const Type *t2 ) const { | |
| 424 // no folding if one of operands is infinity or NaN, do not do constant folding | |
| 425 if( g_isfinite(t1->getf()) && g_isfinite(t2->getf()) ) { | |
| 426 return TypeF::make( t1->getf() - t2->getf() ); | |
| 427 } | |
| 428 else if( g_isnan(t1->getf()) ) { | |
| 429 return t1; | |
| 430 } | |
| 431 else if( g_isnan(t2->getf()) ) { | |
| 432 return t2; | |
| 433 } | |
| 434 else { | |
| 435 return Type::FLOAT; | |
| 436 } | |
| 437 } | |
| 438 | |
| 439 //============================================================================= | |
| 440 //------------------------------Ideal------------------------------------------ | |
| 441 Node *SubDNode::Ideal(PhaseGVN *phase, bool can_reshape){ | |
| 442 const Type *t2 = phase->type( in(2) ); | |
| 443 // Convert "x-c0" into "x+ -c0". | |
| 444 if( t2->base() == Type::DoubleCon ) { // Might be bottom or top... | |
| 445 // return new (phase->C, 3) AddDNode(in(1), phase->makecon( TypeD::make(-t2->getd()) ) ); | |
| 446 } | |
| 447 | |
| 448 // Not associative because of boundary conditions (infinity) | |
| 449 if( IdealizedNumerics && !phase->C->method()->is_strict() ) { | |
| 450 // Convert "x - (x+y)" into "-y" | |
| 451 if( in(2)->is_Add() && | |
| 452 phase->eqv(in(1),in(2)->in(1) ) ) | |
| 453 return new (phase->C, 3) SubDNode( phase->makecon(TypeD::ZERO),in(2)->in(2)); | |
| 454 } | |
| 455 | |
| 456 // Cannot replace 0.0-X with -X because a 'dsub' bytecode computes | |
| 457 // 0.0-0.0 as +0.0, while a 'dneg' bytecode computes -0.0. | |
| 458 //if( phase->type(in(1)) == TypeD::ZERO ) | |
| 459 //return new (phase->C, 2) NegDNode(in(2)); | |
| 460 | |
| 461 return NULL; | |
| 462 } | |
| 463 | |
| 464 //------------------------------sub-------------------------------------------- | |
| 465 // A subtract node differences its two inputs. | |
| 466 const Type *SubDNode::sub( const Type *t1, const Type *t2 ) const { | |
| 467 // no folding if one of operands is infinity or NaN, do not do constant folding | |
| 468 if( g_isfinite(t1->getd()) && g_isfinite(t2->getd()) ) { | |
| 469 return TypeD::make( t1->getd() - t2->getd() ); | |
| 470 } | |
| 471 else if( g_isnan(t1->getd()) ) { | |
| 472 return t1; | |
| 473 } | |
| 474 else if( g_isnan(t2->getd()) ) { | |
| 475 return t2; | |
| 476 } | |
| 477 else { | |
| 478 return Type::DOUBLE; | |
| 479 } | |
| 480 } | |
| 481 | |
| 482 //============================================================================= | |
| 483 //------------------------------Idealize--------------------------------------- | |
| 484 // Unlike SubNodes, compare must still flatten return value to the | |
| 485 // range -1, 0, 1. | |
| 486 // And optimizations like those for (X + Y) - X fail if overflow happens. | |
| 487 Node *CmpNode::Identity( PhaseTransform *phase ) { | |
| 488 return this; | |
| 489 } | |
| 490 | |
| 491 //============================================================================= | |
| 492 //------------------------------cmp-------------------------------------------- | |
| 493 // Simplify a CmpI (compare 2 integers) node, based on local information. | |
| 494 // If both inputs are constants, compare them. | |
| 495 const Type *CmpINode::sub( const Type *t1, const Type *t2 ) const { | |
| 496 const TypeInt *r0 = t1->is_int(); // Handy access | |
| 497 const TypeInt *r1 = t2->is_int(); | |
| 498 | |
| 499 if( r0->_hi < r1->_lo ) // Range is always low? | |
| 500 return TypeInt::CC_LT; | |
| 501 else if( r0->_lo > r1->_hi ) // Range is always high? | |
| 502 return TypeInt::CC_GT; | |
| 503 | |
| 504 else if( r0->is_con() && r1->is_con() ) { // comparing constants? | |
| 505 assert(r0->get_con() == r1->get_con(), "must be equal"); | |
| 506 return TypeInt::CC_EQ; // Equal results. | |
| 507 } else if( r0->_hi == r1->_lo ) // Range is never high? | |
| 508 return TypeInt::CC_LE; | |
| 509 else if( r0->_lo == r1->_hi ) // Range is never low? | |
| 510 return TypeInt::CC_GE; | |
| 511 return TypeInt::CC; // else use worst case results | |
| 512 } | |
| 513 | |
| 514 // Simplify a CmpU (compare 2 integers) node, based on local information. | |
| 515 // If both inputs are constants, compare them. | |
| 516 const Type *CmpUNode::sub( const Type *t1, const Type *t2 ) const { | |
| 517 assert(!t1->isa_ptr(), "obsolete usage of CmpU"); | |
| 518 | |
| 519 // comparing two unsigned ints | |
| 520 const TypeInt *r0 = t1->is_int(); // Handy access | |
| 521 const TypeInt *r1 = t2->is_int(); | |
| 522 | |
| 523 // Current installed version | |
| 524 // Compare ranges for non-overlap | |
| 525 juint lo0 = r0->_lo; | |
| 526 juint hi0 = r0->_hi; | |
| 527 juint lo1 = r1->_lo; | |
| 528 juint hi1 = r1->_hi; | |
| 529 | |
| 530 // If either one has both negative and positive values, | |
| 531 // it therefore contains both 0 and -1, and since [0..-1] is the | |
| 532 // full unsigned range, the type must act as an unsigned bottom. | |
| 533 bool bot0 = ((jint)(lo0 ^ hi0) < 0); | |
| 534 bool bot1 = ((jint)(lo1 ^ hi1) < 0); | |
| 535 | |
| 536 if (bot0 || bot1) { | |
| 537 // All unsigned values are LE -1 and GE 0. | |
| 538 if (lo0 == 0 && hi0 == 0) { | |
| 539 return TypeInt::CC_LE; // 0 <= bot | |
| 540 } else if (lo1 == 0 && hi1 == 0) { | |
| 541 return TypeInt::CC_GE; // bot >= 0 | |
| 542 } | |
| 543 } else { | |
| 544 // We can use ranges of the form [lo..hi] if signs are the same. | |
| 545 assert(lo0 <= hi0 && lo1 <= hi1, "unsigned ranges are valid"); | |
| 546 // results are reversed, '-' > '+' for unsigned compare | |
| 547 if (hi0 < lo1) { | |
| 548 return TypeInt::CC_LT; // smaller | |
| 549 } else if (lo0 > hi1) { | |
| 550 return TypeInt::CC_GT; // greater | |
| 551 } else if (hi0 == lo1 && lo0 == hi1) { | |
| 552 return TypeInt::CC_EQ; // Equal results | |
| 553 } else if (lo0 >= hi1) { | |
| 554 return TypeInt::CC_GE; | |
| 555 } else if (hi0 <= lo1) { | |
| 556 // Check for special case in Hashtable::get. (See below.) | |
| 557 if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && | |
| 558 in(1)->Opcode() == Op_ModI && | |
| 559 in(1)->in(2) == in(2) ) | |
| 560 return TypeInt::CC_LT; | |
| 561 return TypeInt::CC_LE; | |
| 562 } | |
| 563 } | |
| 564 // Check for special case in Hashtable::get - the hash index is | |
| 565 // mod'ed to the table size so the following range check is useless. | |
| 566 // Check for: (X Mod Y) CmpU Y, where the mod result and Y both have | |
| 567 // to be positive. | |
| 568 // (This is a gross hack, since the sub method never | |
| 569 // looks at the structure of the node in any other case.) | |
| 570 if ((jint)lo0 >= 0 && (jint)lo1 >= 0 && | |
| 571 in(1)->Opcode() == Op_ModI && | |
| 572 in(1)->in(2)->uncast() == in(2)->uncast()) | |
| 573 return TypeInt::CC_LT; | |
| 574 return TypeInt::CC; // else use worst case results | |
| 575 } | |
| 576 | |
| 577 //------------------------------Idealize--------------------------------------- | |
| 578 Node *CmpINode::Ideal( PhaseGVN *phase, bool can_reshape ) { | |
| 579 if (phase->type(in(2))->higher_equal(TypeInt::ZERO)) { | |
| 580 switch (in(1)->Opcode()) { | |
| 581 case Op_CmpL3: // Collapse a CmpL3/CmpI into a CmpL | |
| 582 return new (phase->C, 3) CmpLNode(in(1)->in(1),in(1)->in(2)); | |
| 583 case Op_CmpF3: // Collapse a CmpF3/CmpI into a CmpF | |
| 584 return new (phase->C, 3) CmpFNode(in(1)->in(1),in(1)->in(2)); | |
| 585 case Op_CmpD3: // Collapse a CmpD3/CmpI into a CmpD | |
| 586 return new (phase->C, 3) CmpDNode(in(1)->in(1),in(1)->in(2)); | |
| 587 //case Op_SubI: | |
| 588 // If (x - y) cannot overflow, then ((x - y) <?> 0) | |
| 589 // can be turned into (x <?> y). | |
| 590 // This is handled (with more general cases) by Ideal_sub_algebra. | |
| 591 } | |
| 592 } | |
| 593 return NULL; // No change | |
| 594 } | |
| 595 | |
| 596 | |
| 597 //============================================================================= | |
| 598 // Simplify a CmpL (compare 2 longs ) node, based on local information. | |
| 599 // If both inputs are constants, compare them. | |
| 600 const Type *CmpLNode::sub( const Type *t1, const Type *t2 ) const { | |
| 601 const TypeLong *r0 = t1->is_long(); // Handy access | |
| 602 const TypeLong *r1 = t2->is_long(); | |
| 603 | |
| 604 if( r0->_hi < r1->_lo ) // Range is always low? | |
| 605 return TypeInt::CC_LT; | |
| 606 else if( r0->_lo > r1->_hi ) // Range is always high? | |
| 607 return TypeInt::CC_GT; | |
| 608 | |
| 609 else if( r0->is_con() && r1->is_con() ) { // comparing constants? | |
| 610 assert(r0->get_con() == r1->get_con(), "must be equal"); | |
| 611 return TypeInt::CC_EQ; // Equal results. | |
| 612 } else if( r0->_hi == r1->_lo ) // Range is never high? | |
| 613 return TypeInt::CC_LE; | |
| 614 else if( r0->_lo == r1->_hi ) // Range is never low? | |
| 615 return TypeInt::CC_GE; | |
| 616 return TypeInt::CC; // else use worst case results | |
| 617 } | |
| 618 | |
| 619 //============================================================================= | |
| 620 //------------------------------sub-------------------------------------------- | |
| 621 // Simplify an CmpP (compare 2 pointers) node, based on local information. | |
| 622 // If both inputs are constants, compare them. | |
| 623 const Type *CmpPNode::sub( const Type *t1, const Type *t2 ) const { | |
| 624 const TypePtr *r0 = t1->is_ptr(); // Handy access | |
| 625 const TypePtr *r1 = t2->is_ptr(); | |
| 626 | |
| 627 // Undefined inputs makes for an undefined result | |
| 628 if( TypePtr::above_centerline(r0->_ptr) || | |
| 629 TypePtr::above_centerline(r1->_ptr) ) | |
| 630 return Type::TOP; | |
| 631 | |
| 632 if (r0 == r1 && r0->singleton()) { | |
| 633 // Equal pointer constants (klasses, nulls, etc.) | |
| 634 return TypeInt::CC_EQ; | |
| 635 } | |
| 636 | |
| 637 // See if it is 2 unrelated classes. | |
| 638 const TypeOopPtr* p0 = r0->isa_oopptr(); | |
| 639 const TypeOopPtr* p1 = r1->isa_oopptr(); | |
| 640 if (p0 && p1) { | |
| 33 | 641 Node* in1 = in(1)->uncast(); |
| 642 Node* in2 = in(2)->uncast(); | |
| 643 AllocateNode* alloc1 = AllocateNode::Ideal_allocation(in1, NULL); | |
| 644 AllocateNode* alloc2 = AllocateNode::Ideal_allocation(in2, NULL); | |
| 645 if (MemNode::detect_ptr_independence(in1, alloc1, in2, alloc2, NULL)) { | |
| 646 return TypeInt::CC_GT; // different pointers | |
| 647 } | |
| 0 | 648 ciKlass* klass0 = p0->klass(); |
| 649 bool xklass0 = p0->klass_is_exact(); | |
| 650 ciKlass* klass1 = p1->klass(); | |
| 651 bool xklass1 = p1->klass_is_exact(); | |
| 652 int kps = (p0->isa_klassptr()?1:0) + (p1->isa_klassptr()?1:0); | |
| 653 if (klass0 && klass1 && | |
| 654 kps != 1 && // both or neither are klass pointers | |
|
668
90a66aa50514
6820510: assertion failure with unloaded class in subnode.cpp
never
parents:
400
diff
changeset
|
655 klass0->is_loaded() && !klass0->is_interface() && // do not trust interfaces |
|
783
a9e116455022
6832293: JIT compiler got wrong result in type checking with -server
kvn
parents:
668
diff
changeset
|
656 klass1->is_loaded() && !klass1->is_interface() && |
|
a9e116455022
6832293: JIT compiler got wrong result in type checking with -server
kvn
parents:
668
diff
changeset
|
657 (!klass0->is_obj_array_klass() || |
|
a9e116455022
6832293: JIT compiler got wrong result in type checking with -server
kvn
parents:
668
diff
changeset
|
658 !klass0->as_obj_array_klass()->base_element_klass()->is_interface()) && |
|
a9e116455022
6832293: JIT compiler got wrong result in type checking with -server
kvn
parents:
668
diff
changeset
|
659 (!klass1->is_obj_array_klass() || |
|
a9e116455022
6832293: JIT compiler got wrong result in type checking with -server
kvn
parents:
668
diff
changeset
|
660 !klass1->as_obj_array_klass()->base_element_klass()->is_interface())) { |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
661 bool unrelated_classes = false; |
| 0 | 662 // See if neither subclasses the other, or if the class on top |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
663 // is precise. In either of these cases, the compare is known |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
664 // to fail if at least one of the pointers is provably not null. |
| 0 | 665 if (klass0->equals(klass1) || // if types are unequal but klasses are |
| 666 !klass0->is_java_klass() || // types not part of Java language? | |
| 667 !klass1->is_java_klass()) { // types not part of Java language? | |
| 668 // Do nothing; we know nothing for imprecise types | |
| 669 } else if (klass0->is_subtype_of(klass1)) { | |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
670 // If klass1's type is PRECISE, then classes are unrelated. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
671 unrelated_classes = xklass1; |
| 0 | 672 } else if (klass1->is_subtype_of(klass0)) { |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
673 // If klass0's type is PRECISE, then classes are unrelated. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
674 unrelated_classes = xklass0; |
| 0 | 675 } else { // Neither subtypes the other |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
676 unrelated_classes = true; |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
677 } |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
678 if (unrelated_classes) { |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
679 // The oops classes are known to be unrelated. If the joined PTRs of |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
680 // two oops is not Null and not Bottom, then we are sure that one |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
681 // of the two oops is non-null, and the comparison will always fail. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
682 TypePtr::PTR jp = r0->join_ptr(r1->_ptr); |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
683 if (jp != TypePtr::Null && jp != TypePtr::BotPTR) { |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
684 return TypeInt::CC_GT; |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
685 } |
| 0 | 686 } |
| 687 } | |
| 688 } | |
| 689 | |
| 690 // Known constants can be compared exactly | |
| 691 // Null can be distinguished from any NotNull pointers | |
| 692 // Unknown inputs makes an unknown result | |
| 693 if( r0->singleton() ) { | |
| 694 intptr_t bits0 = r0->get_con(); | |
| 695 if( r1->singleton() ) | |
| 696 return bits0 == r1->get_con() ? TypeInt::CC_EQ : TypeInt::CC_GT; | |
| 697 return ( r1->_ptr == TypePtr::NotNull && bits0==0 ) ? TypeInt::CC_GT : TypeInt::CC; | |
| 698 } else if( r1->singleton() ) { | |
| 699 intptr_t bits1 = r1->get_con(); | |
| 700 return ( r0->_ptr == TypePtr::NotNull && bits1==0 ) ? TypeInt::CC_GT : TypeInt::CC; | |
| 701 } else | |
| 702 return TypeInt::CC; | |
| 703 } | |
| 704 | |
| 705 //------------------------------Ideal------------------------------------------ | |
| 706 // Check for the case of comparing an unknown klass loaded from the primary | |
| 707 // super-type array vs a known klass with no subtypes. This amounts to | |
| 708 // checking to see an unknown klass subtypes a known klass with no subtypes; | |
| 709 // this only happens on an exact match. We can shorten this test by 1 load. | |
| 710 Node *CmpPNode::Ideal( PhaseGVN *phase, bool can_reshape ) { | |
| 711 // Constant pointer on right? | |
| 712 const TypeKlassPtr* t2 = phase->type(in(2))->isa_klassptr(); | |
| 713 if (t2 == NULL || !t2->klass_is_exact()) | |
| 714 return NULL; | |
| 715 // Get the constant klass we are comparing to. | |
| 716 ciKlass* superklass = t2->klass(); | |
| 717 | |
| 718 // Now check for LoadKlass on left. | |
| 719 Node* ldk1 = in(1); | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
720 if (ldk1->is_DecodeN()) { |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
721 ldk1 = ldk1->in(1); |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
722 if (ldk1->Opcode() != Op_LoadNKlass ) |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
723 return NULL; |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
724 } else if (ldk1->Opcode() != Op_LoadKlass ) |
| 0 | 725 return NULL; |
| 726 // Take apart the address of the LoadKlass: | |
| 727 Node* adr1 = ldk1->in(MemNode::Address); | |
| 728 intptr_t con2 = 0; | |
| 729 Node* ldk2 = AddPNode::Ideal_base_and_offset(adr1, phase, con2); | |
| 730 if (ldk2 == NULL) | |
| 731 return NULL; | |
| 732 if (con2 == oopDesc::klass_offset_in_bytes()) { | |
| 733 // We are inspecting an object's concrete class. | |
| 734 // Short-circuit the check if the query is abstract. | |
| 735 if (superklass->is_interface() || | |
| 736 superklass->is_abstract()) { | |
| 737 // Make it come out always false: | |
| 738 this->set_req(2, phase->makecon(TypePtr::NULL_PTR)); | |
| 739 return this; | |
| 740 } | |
| 741 } | |
| 742 | |
| 743 // Check for a LoadKlass from primary supertype array. | |
| 744 // Any nested loadklass from loadklass+con must be from the p.s. array. | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
745 if (ldk2->is_DecodeN()) { |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
746 // Keep ldk2 as DecodeN since it could be used in CmpP below. |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
747 if (ldk2->in(1)->Opcode() != Op_LoadNKlass ) |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
748 return NULL; |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
235
diff
changeset
|
749 } else if (ldk2->Opcode() != Op_LoadKlass) |
| 0 | 750 return NULL; |
| 751 | |
| 752 // Verify that we understand the situation | |
| 753 if (con2 != (intptr_t) superklass->super_check_offset()) | |
| 754 return NULL; // Might be element-klass loading from array klass | |
| 755 | |
| 756 // If 'superklass' has no subklasses and is not an interface, then we are | |
| 757 // assured that the only input which will pass the type check is | |
| 758 // 'superklass' itself. | |
| 759 // | |
| 760 // We could be more liberal here, and allow the optimization on interfaces | |
| 761 // which have a single implementor. This would require us to increase the | |
| 762 // expressiveness of the add_dependency() mechanism. | |
| 763 // %%% Do this after we fix TypeOopPtr: Deps are expressive enough now. | |
| 764 | |
| 765 // Object arrays must have their base element have no subtypes | |
| 766 while (superklass->is_obj_array_klass()) { | |
| 767 ciType* elem = superklass->as_obj_array_klass()->element_type(); | |
| 768 superklass = elem->as_klass(); | |
| 769 } | |
| 770 if (superklass->is_instance_klass()) { | |
| 771 ciInstanceKlass* ik = superklass->as_instance_klass(); | |
| 772 if (ik->has_subklass() || ik->is_interface()) return NULL; | |
| 773 // Add a dependency if there is a chance that a subclass will be added later. | |
| 774 if (!ik->is_final()) { | |
| 775 phase->C->dependencies()->assert_leaf_type(ik); | |
| 776 } | |
| 777 } | |
| 778 | |
| 779 // Bypass the dependent load, and compare directly | |
| 780 this->set_req(1,ldk2); | |
| 781 | |
| 782 return this; | |
| 783 } | |
| 784 | |
| 785 //============================================================================= | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
786 //------------------------------sub-------------------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
787 // Simplify an CmpN (compare 2 pointers) node, based on local information. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
788 // If both inputs are constants, compare them. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
789 const Type *CmpNNode::sub( const Type *t1, const Type *t2 ) const { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
212
diff
changeset
|
790 const TypePtr *r0 = t1->make_ptr(); // Handy access |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
212
diff
changeset
|
791 const TypePtr *r1 = t2->make_ptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
792 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
793 // Undefined inputs makes for an undefined result |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
794 if( TypePtr::above_centerline(r0->_ptr) || |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
795 TypePtr::above_centerline(r1->_ptr) ) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
796 return Type::TOP; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
797 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
798 if (r0 == r1 && r0->singleton()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
799 // Equal pointer constants (klasses, nulls, etc.) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
800 return TypeInt::CC_EQ; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
801 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
802 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
803 // See if it is 2 unrelated classes. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
804 const TypeOopPtr* p0 = r0->isa_oopptr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
805 const TypeOopPtr* p1 = r1->isa_oopptr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
806 if (p0 && p1) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
807 ciKlass* klass0 = p0->klass(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
808 bool xklass0 = p0->klass_is_exact(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
809 ciKlass* klass1 = p1->klass(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
810 bool xklass1 = p1->klass_is_exact(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
811 int kps = (p0->isa_klassptr()?1:0) + (p1->isa_klassptr()?1:0); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
812 if (klass0 && klass1 && |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
813 kps != 1 && // both or neither are klass pointers |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
814 !klass0->is_interface() && // do not trust interfaces |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
815 !klass1->is_interface()) { |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
816 bool unrelated_classes = false; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
817 // See if neither subclasses the other, or if the class on top |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
818 // is precise. In either of these cases, the compare is known |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
819 // to fail if at least one of the pointers is provably not null. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
820 if (klass0->equals(klass1) || // if types are unequal but klasses are |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
821 !klass0->is_java_klass() || // types not part of Java language? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
822 !klass1->is_java_klass()) { // types not part of Java language? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
823 // Do nothing; we know nothing for imprecise types |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
824 } else if (klass0->is_subtype_of(klass1)) { |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
825 // If klass1's type is PRECISE, then classes are unrelated. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
826 unrelated_classes = xklass1; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
827 } else if (klass1->is_subtype_of(klass0)) { |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
828 // If klass0's type is PRECISE, then classes are unrelated. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
829 unrelated_classes = xklass0; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
830 } else { // Neither subtypes the other |
|
296
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
831 unrelated_classes = true; |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
832 } |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
833 if (unrelated_classes) { |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
834 // The oops classes are known to be unrelated. If the joined PTRs of |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
835 // two oops is not Null and not Bottom, then we are sure that one |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
836 // of the two oops is non-null, and the comparison will always fail. |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
837 TypePtr::PTR jp = r0->join_ptr(r1->_ptr); |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
838 if (jp != TypePtr::Null && jp != TypePtr::BotPTR) { |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
839 return TypeInt::CC_GT; |
|
ce93a51457ae
6730716: nulls from two unrelated classes compare not equal
rasbold
parents:
293
diff
changeset
|
840 } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
841 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
842 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
843 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
844 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
845 // Known constants can be compared exactly |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
846 // Null can be distinguished from any NotNull pointers |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
847 // Unknown inputs makes an unknown result |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
848 if( r0->singleton() ) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
849 intptr_t bits0 = r0->get_con(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
850 if( r1->singleton() ) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
851 return bits0 == r1->get_con() ? TypeInt::CC_EQ : TypeInt::CC_GT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
852 return ( r1->_ptr == TypePtr::NotNull && bits0==0 ) ? TypeInt::CC_GT : TypeInt::CC; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
853 } else if( r1->singleton() ) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
854 intptr_t bits1 = r1->get_con(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
855 return ( r0->_ptr == TypePtr::NotNull && bits1==0 ) ? TypeInt::CC_GT : TypeInt::CC; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
856 } else |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
857 return TypeInt::CC; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
858 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
859 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
860 //------------------------------Ideal------------------------------------------ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
861 Node *CmpNNode::Ideal( PhaseGVN *phase, bool can_reshape ) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
862 return NULL; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
863 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
864 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
33
diff
changeset
|
865 //============================================================================= |
| 0 | 866 //------------------------------Value------------------------------------------ |
| 867 // Simplify an CmpF (compare 2 floats ) node, based on local information. | |
| 868 // If both inputs are constants, compare them. | |
| 869 const Type *CmpFNode::Value( PhaseTransform *phase ) const { | |
| 870 const Node* in1 = in(1); | |
| 871 const Node* in2 = in(2); | |
| 872 // Either input is TOP ==> the result is TOP | |
| 873 const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1); | |
| 874 if( t1 == Type::TOP ) return Type::TOP; | |
| 875 const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2); | |
| 876 if( t2 == Type::TOP ) return Type::TOP; | |
| 877 | |
| 878 // Not constants? Don't know squat - even if they are the same | |
| 879 // value! If they are NaN's they compare to LT instead of EQ. | |
| 880 const TypeF *tf1 = t1->isa_float_constant(); | |
| 881 const TypeF *tf2 = t2->isa_float_constant(); | |
| 882 if( !tf1 || !tf2 ) return TypeInt::CC; | |
| 883 | |
| 884 // This implements the Java bytecode fcmpl, so unordered returns -1. | |
| 885 if( tf1->is_nan() || tf2->is_nan() ) | |
| 886 return TypeInt::CC_LT; | |
| 887 | |
| 888 if( tf1->_f < tf2->_f ) return TypeInt::CC_LT; | |
| 889 if( tf1->_f > tf2->_f ) return TypeInt::CC_GT; | |
| 890 assert( tf1->_f == tf2->_f, "do not understand FP behavior" ); | |
| 891 return TypeInt::CC_EQ; | |
| 892 } | |
| 893 | |
| 894 | |
| 895 //============================================================================= | |
| 896 //------------------------------Value------------------------------------------ | |
| 897 // Simplify an CmpD (compare 2 doubles ) node, based on local information. | |
| 898 // If both inputs are constants, compare them. | |
| 899 const Type *CmpDNode::Value( PhaseTransform *phase ) const { | |
| 900 const Node* in1 = in(1); | |
| 901 const Node* in2 = in(2); | |
| 902 // Either input is TOP ==> the result is TOP | |
| 903 const Type* t1 = (in1 == this) ? Type::TOP : phase->type(in1); | |
| 904 if( t1 == Type::TOP ) return Type::TOP; | |
| 905 const Type* t2 = (in2 == this) ? Type::TOP : phase->type(in2); | |
| 906 if( t2 == Type::TOP ) return Type::TOP; | |
| 907 | |
| 908 // Not constants? Don't know squat - even if they are the same | |
| 909 // value! If they are NaN's they compare to LT instead of EQ. | |
| 910 const TypeD *td1 = t1->isa_double_constant(); | |
| 911 const TypeD *td2 = t2->isa_double_constant(); | |
| 912 if( !td1 || !td2 ) return TypeInt::CC; | |
| 913 | |
| 914 // This implements the Java bytecode dcmpl, so unordered returns -1. | |
| 915 if( td1->is_nan() || td2->is_nan() ) | |
| 916 return TypeInt::CC_LT; | |
| 917 | |
| 918 if( td1->_d < td2->_d ) return TypeInt::CC_LT; | |
| 919 if( td1->_d > td2->_d ) return TypeInt::CC_GT; | |
| 920 assert( td1->_d == td2->_d, "do not understand FP behavior" ); | |
| 921 return TypeInt::CC_EQ; | |
| 922 } | |
| 923 | |
| 924 //------------------------------Ideal------------------------------------------ | |
| 925 Node *CmpDNode::Ideal(PhaseGVN *phase, bool can_reshape){ | |
| 926 // Check if we can change this to a CmpF and remove a ConvD2F operation. | |
| 927 // Change (CMPD (F2D (float)) (ConD value)) | |
| 928 // To (CMPF (float) (ConF value)) | |
| 929 // Valid when 'value' does not lose precision as a float. | |
| 930 // Benefits: eliminates conversion, does not require 24-bit mode | |
| 931 | |
| 932 // NaNs prevent commuting operands. This transform works regardless of the | |
| 933 // order of ConD and ConvF2D inputs by preserving the original order. | |
| 934 int idx_f2d = 1; // ConvF2D on left side? | |
| 935 if( in(idx_f2d)->Opcode() != Op_ConvF2D ) | |
| 936 idx_f2d = 2; // No, swap to check for reversed args | |
| 937 int idx_con = 3-idx_f2d; // Check for the constant on other input | |
| 938 | |
| 939 if( ConvertCmpD2CmpF && | |
| 940 in(idx_f2d)->Opcode() == Op_ConvF2D && | |
| 941 in(idx_con)->Opcode() == Op_ConD ) { | |
| 942 const TypeD *t2 = in(idx_con)->bottom_type()->is_double_constant(); | |
| 943 double t2_value_as_double = t2->_d; | |
| 944 float t2_value_as_float = (float)t2_value_as_double; | |
| 945 if( t2_value_as_double == (double)t2_value_as_float ) { | |
| 946 // Test value can be represented as a float | |
| 947 // Eliminate the conversion to double and create new comparison | |
| 948 Node *new_in1 = in(idx_f2d)->in(1); | |
| 949 Node *new_in2 = phase->makecon( TypeF::make(t2_value_as_float) ); | |
| 950 if( idx_f2d != 1 ) { // Must flip args to match original order | |
| 951 Node *tmp = new_in1; | |
| 952 new_in1 = new_in2; | |
| 953 new_in2 = tmp; | |
| 954 } | |
| 955 CmpFNode *new_cmp = (Opcode() == Op_CmpD3) | |
| 956 ? new (phase->C, 3) CmpF3Node( new_in1, new_in2 ) | |
| 957 : new (phase->C, 3) CmpFNode ( new_in1, new_in2 ) ; | |
| 958 return new_cmp; // Changed to CmpFNode | |
| 959 } | |
| 960 // Testing value required the precision of a double | |
| 961 } | |
| 962 return NULL; // No change | |
| 963 } | |
| 964 | |
| 965 | |
| 966 //============================================================================= | |
| 967 //------------------------------cc2logical------------------------------------- | |
| 968 // Convert a condition code type to a logical type | |
| 969 const Type *BoolTest::cc2logical( const Type *CC ) const { | |
| 970 if( CC == Type::TOP ) return Type::TOP; | |
| 971 if( CC->base() != Type::Int ) return TypeInt::BOOL; // Bottom or worse | |
| 972 const TypeInt *ti = CC->is_int(); | |
| 973 if( ti->is_con() ) { // Only 1 kind of condition codes set? | |
| 974 // Match low order 2 bits | |
| 975 int tmp = ((ti->get_con()&3) == (_test&3)) ? 1 : 0; | |
| 976 if( _test & 4 ) tmp = 1-tmp; // Optionally complement result | |
| 977 return TypeInt::make(tmp); // Boolean result | |
| 978 } | |
| 979 | |
| 980 if( CC == TypeInt::CC_GE ) { | |
| 981 if( _test == ge ) return TypeInt::ONE; | |
| 982 if( _test == lt ) return TypeInt::ZERO; | |
| 983 } | |
| 984 if( CC == TypeInt::CC_LE ) { | |
| 985 if( _test == le ) return TypeInt::ONE; | |
| 986 if( _test == gt ) return TypeInt::ZERO; | |
| 987 } | |
| 988 | |
| 989 return TypeInt::BOOL; | |
| 990 } | |
| 991 | |
| 992 //------------------------------dump_spec------------------------------------- | |
| 993 // Print special per-node info | |
| 994 #ifndef PRODUCT | |
| 995 void BoolTest::dump_on(outputStream *st) const { | |
| 996 const char *msg[] = {"eq","gt","??","lt","ne","le","??","ge"}; | |
| 997 st->print(msg[_test]); | |
| 998 } | |
| 999 #endif | |
| 1000 | |
| 1001 //============================================================================= | |
| 1002 uint BoolNode::hash() const { return (Node::hash() << 3)|(_test._test+1); } | |
| 1003 uint BoolNode::size_of() const { return sizeof(BoolNode); } | |
| 1004 | |
| 1005 //------------------------------operator==------------------------------------- | |
| 1006 uint BoolNode::cmp( const Node &n ) const { | |
| 1007 const BoolNode *b = (const BoolNode *)&n; // Cast up | |
| 1008 return (_test._test == b->_test._test); | |
| 1009 } | |
| 1010 | |
| 1011 //------------------------------clone_cmp-------------------------------------- | |
| 1012 // Clone a compare/bool tree | |
| 1013 static Node *clone_cmp( Node *cmp, Node *cmp1, Node *cmp2, PhaseGVN *gvn, BoolTest::mask test ) { | |
| 1014 Node *ncmp = cmp->clone(); | |
| 1015 ncmp->set_req(1,cmp1); | |
| 1016 ncmp->set_req(2,cmp2); | |
| 1017 ncmp = gvn->transform( ncmp ); | |
| 1018 return new (gvn->C, 2) BoolNode( ncmp, test ); | |
| 1019 } | |
| 1020 | |
| 1021 //-------------------------------make_predicate-------------------------------- | |
| 1022 Node* BoolNode::make_predicate(Node* test_value, PhaseGVN* phase) { | |
| 1023 if (test_value->is_Con()) return test_value; | |
| 1024 if (test_value->is_Bool()) return test_value; | |
| 1025 Compile* C = phase->C; | |
| 1026 if (test_value->is_CMove() && | |
| 1027 test_value->in(CMoveNode::Condition)->is_Bool()) { | |
| 1028 BoolNode* bol = test_value->in(CMoveNode::Condition)->as_Bool(); | |
| 1029 const Type* ftype = phase->type(test_value->in(CMoveNode::IfFalse)); | |
| 1030 const Type* ttype = phase->type(test_value->in(CMoveNode::IfTrue)); | |
| 1031 if (ftype == TypeInt::ZERO && !TypeInt::ZERO->higher_equal(ttype)) { | |
| 1032 return bol; | |
| 1033 } else if (ttype == TypeInt::ZERO && !TypeInt::ZERO->higher_equal(ftype)) { | |
| 1034 return phase->transform( bol->negate(phase) ); | |
| 1035 } | |
| 1036 // Else fall through. The CMove gets in the way of the test. | |
| 1037 // It should be the case that make_predicate(bol->as_int_value()) == bol. | |
| 1038 } | |
| 1039 Node* cmp = new (C, 3) CmpINode(test_value, phase->intcon(0)); | |
| 1040 cmp = phase->transform(cmp); | |
| 1041 Node* bol = new (C, 2) BoolNode(cmp, BoolTest::ne); | |
| 1042 return phase->transform(bol); | |
| 1043 } | |
| 1044 | |
| 1045 //--------------------------------as_int_value--------------------------------- | |
| 1046 Node* BoolNode::as_int_value(PhaseGVN* phase) { | |
| 1047 // Inverse to make_predicate. The CMove probably boils down to a Conv2B. | |
| 1048 Node* cmov = CMoveNode::make(phase->C, NULL, this, | |
| 1049 phase->intcon(0), phase->intcon(1), | |
| 1050 TypeInt::BOOL); | |
| 1051 return phase->transform(cmov); | |
| 1052 } | |
| 1053 | |
| 1054 //----------------------------------negate------------------------------------- | |
| 1055 BoolNode* BoolNode::negate(PhaseGVN* phase) { | |
| 1056 Compile* C = phase->C; | |
| 1057 return new (C, 2) BoolNode(in(1), _test.negate()); | |
| 1058 } | |
| 1059 | |
| 1060 | |
| 1061 //------------------------------Ideal------------------------------------------ | |
| 1062 Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1063 // Change "bool tst (cmp con x)" into "bool ~tst (cmp x con)". | |
| 1064 // This moves the constant to the right. Helps value-numbering. | |
| 1065 Node *cmp = in(1); | |
| 1066 if( !cmp->is_Sub() ) return NULL; | |
| 1067 int cop = cmp->Opcode(); | |
| 1068 if( cop == Op_FastLock || cop == Op_FastUnlock ) return NULL; | |
| 1069 Node *cmp1 = cmp->in(1); | |
| 1070 Node *cmp2 = cmp->in(2); | |
| 1071 if( !cmp1 ) return NULL; | |
| 1072 | |
| 1073 // Constant on left? | |
| 1074 Node *con = cmp1; | |
| 1075 uint op2 = cmp2->Opcode(); | |
| 1076 // Move constants to the right of compare's to canonicalize. | |
| 1077 // Do not muck with Opaque1 nodes, as this indicates a loop | |
| 1078 // guard that cannot change shape. | |
| 1079 if( con->is_Con() && !cmp2->is_Con() && op2 != Op_Opaque1 && | |
| 1080 // Because of NaN's, CmpD and CmpF are not commutative | |
| 1081 cop != Op_CmpD && cop != Op_CmpF && | |
| 1082 // Protect against swapping inputs to a compare when it is used by a | |
| 1083 // counted loop exit, which requires maintaining the loop-limit as in(2) | |
| 1084 !is_counted_loop_exit_test() ) { | |
| 1085 // Ok, commute the constant to the right of the cmp node. | |
| 1086 // Clone the Node, getting a new Node of the same class | |
| 1087 cmp = cmp->clone(); | |
| 1088 // Swap inputs to the clone | |
| 1089 cmp->swap_edges(1, 2); | |
| 1090 cmp = phase->transform( cmp ); | |
| 1091 return new (phase->C, 2) BoolNode( cmp, _test.commute() ); | |
| 1092 } | |
| 1093 | |
| 1094 // Change "bool eq/ne (cmp (xor X 1) 0)" into "bool ne/eq (cmp X 0)". | |
| 1095 // The XOR-1 is an idiom used to flip the sense of a bool. We flip the | |
| 1096 // test instead. | |
| 1097 int cmp1_op = cmp1->Opcode(); | |
| 1098 const TypeInt* cmp2_type = phase->type(cmp2)->isa_int(); | |
| 1099 if (cmp2_type == NULL) return NULL; | |
| 1100 Node* j_xor = cmp1; | |
| 1101 if( cmp2_type == TypeInt::ZERO && | |
| 1102 cmp1_op == Op_XorI && | |
| 1103 j_xor->in(1) != j_xor && // An xor of itself is dead | |
| 1104 phase->type( j_xor->in(2) ) == TypeInt::ONE && | |
| 1105 (_test._test == BoolTest::eq || | |
| 1106 _test._test == BoolTest::ne) ) { | |
| 1107 Node *ncmp = phase->transform(new (phase->C, 3) CmpINode(j_xor->in(1),cmp2)); | |
| 1108 return new (phase->C, 2) BoolNode( ncmp, _test.negate() ); | |
| 1109 } | |
| 1110 | |
| 1111 // Change "bool eq/ne (cmp (Conv2B X) 0)" into "bool eq/ne (cmp X 0)". | |
| 1112 // This is a standard idiom for branching on a boolean value. | |
| 1113 Node *c2b = cmp1; | |
| 1114 if( cmp2_type == TypeInt::ZERO && | |
| 1115 cmp1_op == Op_Conv2B && | |
| 1116 (_test._test == BoolTest::eq || | |
| 1117 _test._test == BoolTest::ne) ) { | |
| 1118 Node *ncmp = phase->transform(phase->type(c2b->in(1))->isa_int() | |
| 1119 ? (Node*)new (phase->C, 3) CmpINode(c2b->in(1),cmp2) | |
| 1120 : (Node*)new (phase->C, 3) CmpPNode(c2b->in(1),phase->makecon(TypePtr::NULL_PTR)) | |
| 1121 ); | |
| 1122 return new (phase->C, 2) BoolNode( ncmp, _test._test ); | |
| 1123 } | |
| 1124 | |
| 1125 // Comparing a SubI against a zero is equal to comparing the SubI | |
| 1126 // arguments directly. This only works for eq and ne comparisons | |
| 1127 // due to possible integer overflow. | |
| 1128 if ((_test._test == BoolTest::eq || _test._test == BoolTest::ne) && | |
| 1129 (cop == Op_CmpI) && | |
| 1130 (cmp1->Opcode() == Op_SubI) && | |
| 1131 ( cmp2_type == TypeInt::ZERO ) ) { | |
| 1132 Node *ncmp = phase->transform( new (phase->C, 3) CmpINode(cmp1->in(1),cmp1->in(2))); | |
| 1133 return new (phase->C, 2) BoolNode( ncmp, _test._test ); | |
| 1134 } | |
| 1135 | |
| 1136 // Change (-A vs 0) into (A vs 0) by commuting the test. Disallow in the | |
| 1137 // most general case because negating 0x80000000 does nothing. Needed for | |
| 1138 // the CmpF3/SubI/CmpI idiom. | |
| 1139 if( cop == Op_CmpI && | |
| 1140 cmp1->Opcode() == Op_SubI && | |
| 1141 cmp2_type == TypeInt::ZERO && | |
| 1142 phase->type( cmp1->in(1) ) == TypeInt::ZERO && | |
| 1143 phase->type( cmp1->in(2) )->higher_equal(TypeInt::SYMINT) ) { | |
| 1144 Node *ncmp = phase->transform( new (phase->C, 3) CmpINode(cmp1->in(2),cmp2)); | |
| 1145 return new (phase->C, 2) BoolNode( ncmp, _test.commute() ); | |
| 1146 } | |
| 1147 | |
| 1148 // The transformation below is not valid for either signed or unsigned | |
| 1149 // comparisons due to wraparound concerns at MAX_VALUE and MIN_VALUE. | |
| 1150 // This transformation can be resurrected when we are able to | |
| 1151 // make inferences about the range of values being subtracted from | |
| 1152 // (or added to) relative to the wraparound point. | |
| 1153 // | |
| 1154 // // Remove +/-1's if possible. | |
| 1155 // // "X <= Y-1" becomes "X < Y" | |
| 1156 // // "X+1 <= Y" becomes "X < Y" | |
| 1157 // // "X < Y+1" becomes "X <= Y" | |
| 1158 // // "X-1 < Y" becomes "X <= Y" | |
| 1159 // // Do not this to compares off of the counted-loop-end. These guys are | |
| 1160 // // checking the trip counter and they want to use the post-incremented | |
| 1161 // // counter. If they use the PRE-incremented counter, then the counter has | |
| 1162 // // to be incremented in a private block on a loop backedge. | |
| 1163 // if( du && du->cnt(this) && du->out(this)[0]->Opcode() == Op_CountedLoopEnd ) | |
| 1164 // return NULL; | |
| 1165 // #ifndef PRODUCT | |
| 1166 // // Do not do this in a wash GVN pass during verification. | |
| 1167 // // Gets triggered by too many simple optimizations to be bothered with | |
| 1168 // // re-trying it again and again. | |
| 1169 // if( !phase->allow_progress() ) return NULL; | |
| 1170 // #endif | |
| 1171 // // Not valid for unsigned compare because of corner cases in involving zero. | |
| 1172 // // For example, replacing "X-1 <u Y" with "X <=u Y" fails to throw an | |
| 1173 // // exception in case X is 0 (because 0-1 turns into 4billion unsigned but | |
| 1174 // // "0 <=u Y" is always true). | |
| 1175 // if( cmp->Opcode() == Op_CmpU ) return NULL; | |
| 1176 // int cmp2_op = cmp2->Opcode(); | |
| 1177 // if( _test._test == BoolTest::le ) { | |
| 1178 // if( cmp1_op == Op_AddI && | |
| 1179 // phase->type( cmp1->in(2) ) == TypeInt::ONE ) | |
| 1180 // return clone_cmp( cmp, cmp1->in(1), cmp2, phase, BoolTest::lt ); | |
| 1181 // else if( cmp2_op == Op_AddI && | |
| 1182 // phase->type( cmp2->in(2) ) == TypeInt::MINUS_1 ) | |
| 1183 // return clone_cmp( cmp, cmp1, cmp2->in(1), phase, BoolTest::lt ); | |
| 1184 // } else if( _test._test == BoolTest::lt ) { | |
| 1185 // if( cmp1_op == Op_AddI && | |
| 1186 // phase->type( cmp1->in(2) ) == TypeInt::MINUS_1 ) | |
| 1187 // return clone_cmp( cmp, cmp1->in(1), cmp2, phase, BoolTest::le ); | |
| 1188 // else if( cmp2_op == Op_AddI && | |
| 1189 // phase->type( cmp2->in(2) ) == TypeInt::ONE ) | |
| 1190 // return clone_cmp( cmp, cmp1, cmp2->in(1), phase, BoolTest::le ); | |
| 1191 // } | |
| 1192 | |
| 1193 return NULL; | |
| 1194 } | |
| 1195 | |
| 1196 //------------------------------Value------------------------------------------ | |
| 1197 // Simplify a Bool (convert condition codes to boolean (1 or 0)) node, | |
| 1198 // based on local information. If the input is constant, do it. | |
| 1199 const Type *BoolNode::Value( PhaseTransform *phase ) const { | |
| 1200 return _test.cc2logical( phase->type( in(1) ) ); | |
| 1201 } | |
| 1202 | |
| 1203 //------------------------------dump_spec-------------------------------------- | |
| 1204 // Dump special per-node info | |
| 1205 #ifndef PRODUCT | |
| 1206 void BoolNode::dump_spec(outputStream *st) const { | |
| 1207 st->print("["); | |
| 1208 _test.dump_on(st); | |
| 1209 st->print("]"); | |
| 1210 } | |
| 1211 #endif | |
| 1212 | |
| 1213 //------------------------------is_counted_loop_exit_test-------------------------------------- | |
| 1214 // Returns true if node is used by a counted loop node. | |
| 1215 bool BoolNode::is_counted_loop_exit_test() { | |
| 1216 for( DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++ ) { | |
| 1217 Node* use = fast_out(i); | |
| 1218 if (use->is_CountedLoopEnd()) { | |
| 1219 return true; | |
| 1220 } | |
| 1221 } | |
| 1222 return false; | |
| 1223 } | |
| 1224 | |
| 1225 //============================================================================= | |
| 1226 //------------------------------NegNode---------------------------------------- | |
| 1227 Node *NegFNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1228 if( in(1)->Opcode() == Op_SubF ) | |
| 1229 return new (phase->C, 3) SubFNode( in(1)->in(2), in(1)->in(1) ); | |
| 1230 return NULL; | |
| 1231 } | |
| 1232 | |
| 1233 Node *NegDNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1234 if( in(1)->Opcode() == Op_SubD ) | |
| 1235 return new (phase->C, 3) SubDNode( in(1)->in(2), in(1)->in(1) ); | |
| 1236 return NULL; | |
| 1237 } | |
| 1238 | |
| 1239 | |
| 1240 //============================================================================= | |
| 1241 //------------------------------Value------------------------------------------ | |
| 1242 // Compute sqrt | |
| 1243 const Type *SqrtDNode::Value( PhaseTransform *phase ) const { | |
| 1244 const Type *t1 = phase->type( in(1) ); | |
| 1245 if( t1 == Type::TOP ) return Type::TOP; | |
| 1246 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1247 double d = t1->getd(); | |
| 1248 if( d < 0.0 ) return Type::DOUBLE; | |
| 1249 return TypeD::make( sqrt( d ) ); | |
| 1250 } | |
| 1251 | |
| 1252 //============================================================================= | |
| 1253 //------------------------------Value------------------------------------------ | |
| 1254 // Compute cos | |
| 1255 const Type *CosDNode::Value( PhaseTransform *phase ) const { | |
| 1256 const Type *t1 = phase->type( in(1) ); | |
| 1257 if( t1 == Type::TOP ) return Type::TOP; | |
| 1258 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1259 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1260 return TypeD::make( StubRoutines::intrinsic_cos( d ) ); |
| 0 | 1261 } |
| 1262 | |
| 1263 //============================================================================= | |
| 1264 //------------------------------Value------------------------------------------ | |
| 1265 // Compute sin | |
| 1266 const Type *SinDNode::Value( PhaseTransform *phase ) const { | |
| 1267 const Type *t1 = phase->type( in(1) ); | |
| 1268 if( t1 == Type::TOP ) return Type::TOP; | |
| 1269 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1270 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1271 return TypeD::make( StubRoutines::intrinsic_sin( d ) ); |
| 0 | 1272 } |
| 1273 | |
| 1274 //============================================================================= | |
| 1275 //------------------------------Value------------------------------------------ | |
| 1276 // Compute tan | |
| 1277 const Type *TanDNode::Value( PhaseTransform *phase ) const { | |
| 1278 const Type *t1 = phase->type( in(1) ); | |
| 1279 if( t1 == Type::TOP ) return Type::TOP; | |
| 1280 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1281 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1282 return TypeD::make( StubRoutines::intrinsic_tan( d ) ); |
| 0 | 1283 } |
| 1284 | |
| 1285 //============================================================================= | |
| 1286 //------------------------------Value------------------------------------------ | |
| 1287 // Compute log | |
| 1288 const Type *LogDNode::Value( PhaseTransform *phase ) const { | |
| 1289 const Type *t1 = phase->type( in(1) ); | |
| 1290 if( t1 == Type::TOP ) return Type::TOP; | |
| 1291 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1292 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1293 return TypeD::make( StubRoutines::intrinsic_log( d ) ); |
| 0 | 1294 } |
| 1295 | |
| 1296 //============================================================================= | |
| 1297 //------------------------------Value------------------------------------------ | |
| 1298 // Compute log10 | |
| 1299 const Type *Log10DNode::Value( PhaseTransform *phase ) const { | |
| 1300 const Type *t1 = phase->type( in(1) ); | |
| 1301 if( t1 == Type::TOP ) return Type::TOP; | |
| 1302 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1303 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1304 return TypeD::make( StubRoutines::intrinsic_log10( d ) ); |
| 0 | 1305 } |
| 1306 | |
| 1307 //============================================================================= | |
| 1308 //------------------------------Value------------------------------------------ | |
| 1309 // Compute exp | |
| 1310 const Type *ExpDNode::Value( PhaseTransform *phase ) const { | |
| 1311 const Type *t1 = phase->type( in(1) ); | |
| 1312 if( t1 == Type::TOP ) return Type::TOP; | |
| 1313 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1314 double d = t1->getd(); | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1315 return TypeD::make( StubRoutines::intrinsic_exp( d ) ); |
| 0 | 1316 } |
| 1317 | |
| 1318 | |
| 1319 //============================================================================= | |
| 1320 //------------------------------Value------------------------------------------ | |
| 1321 // Compute pow | |
| 1322 const Type *PowDNode::Value( PhaseTransform *phase ) const { | |
| 1323 const Type *t1 = phase->type( in(1) ); | |
| 1324 if( t1 == Type::TOP ) return Type::TOP; | |
| 1325 if( t1->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1326 const Type *t2 = phase->type( in(2) ); | |
| 1327 if( t2 == Type::TOP ) return Type::TOP; | |
| 1328 if( t2->base() != Type::DoubleCon ) return Type::DOUBLE; | |
| 1329 double d1 = t1->getd(); | |
| 1330 double d2 = t2->getd(); | |
| 1331 if( d1 < 0.0 ) return Type::DOUBLE; | |
| 1332 if( d2 < 0.0 ) return Type::DOUBLE; | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
844
diff
changeset
|
1333 return TypeD::make( StubRoutines::intrinsic_pow( d1, d2 ) ); |
| 0 | 1334 } |