1 /* 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. 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 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "memory/allocation.inline.hpp" 27 #include "opto/addnode.hpp" 28 #include "opto/compile.hpp" 29 #include "opto/connode.hpp" 30 #include "opto/machnode.hpp" 31 #include "opto/matcher.hpp" 32 #include "opto/memnode.hpp" 33 #include "opto/phaseX.hpp" 34 #include "opto/subnode.hpp" 35 #include "runtime/sharedRuntime.hpp" 36 37 // Optimization - Graph Style 38 39 //============================================================================= 40 //------------------------------hash------------------------------------------- 41 uint ConNode::hash() const { 42 return (uintptr_t)in(TypeFunc::Control) + _type->hash(); 43 } 44 45 //------------------------------make------------------------------------------- 46 ConNode *ConNode::make( Compile* C, const Type *t ) { 47 switch( t->basic_type() ) { 48 case T_INT: return new (C) ConINode( t->is_int() ); 49 case T_LONG: return new (C) ConLNode( t->is_long() ); 50 case T_FLOAT: return new (C) ConFNode( t->is_float_constant() ); 51 case T_DOUBLE: return new (C) ConDNode( t->is_double_constant() ); 52 case T_VOID: return new (C) ConNode ( Type::TOP ); 53 case T_OBJECT: return new (C) ConPNode( t->is_ptr() ); 54 case T_ARRAY: return new (C) ConPNode( t->is_aryptr() ); 55 case T_ADDRESS: return new (C) ConPNode( t->is_ptr() ); 56 case T_NARROWOOP: return new (C) ConNNode( t->is_narrowoop() ); 57 case T_NARROWKLASS: return new (C) ConNKlassNode( t->is_narrowklass() ); 58 case T_METADATA: return new (C) ConPNode( t->is_ptr() ); 59 // Expected cases: TypePtr::NULL_PTR, any is_rawptr() 60 // Also seen: AnyPtr(TopPTR *+top); from command line: 61 // r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660 62 // %%%% Stop using TypePtr::NULL_PTR to represent nulls: use either TypeRawPtr::NULL_PTR 63 // or else TypeOopPtr::NULL_PTR. Then set Type::_basic_type[AnyPtr] = T_ILLEGAL 64 } 65 ShouldNotReachHere(); 66 return NULL; 67 } 68 69 //============================================================================= 70 /* 71 The major change is for CMoveP and StrComp. They have related but slightly 72 different problems. They both take in TWO oops which are both null-checked 73 independently before the using Node. After CCP removes the CastPP's they need 74 to pick up the guarding test edge - in this case TWO control edges. I tried 75 various solutions, all have problems: 76 77 (1) Do nothing. This leads to a bug where we hoist a Load from a CMoveP or a 78 StrComp above a guarding null check. I've seen both cases in normal -Xcomp 79 testing. 80 81 (2) Plug the control edge from 1 of the 2 oops in. Apparent problem here is 82 to figure out which test post-dominates. The real problem is that it doesn't 83 matter which one you pick. After you pick up, the dominating-test elider in 84 IGVN can remove the test and allow you to hoist up to the dominating test on 85 the chosen oop bypassing the test on the not-chosen oop. Seen in testing. 86 Oops. 87 88 (3) Leave the CastPP's in. This makes the graph more accurate in some sense; 89 we get to keep around the knowledge that an oop is not-null after some test. 90 Alas, the CastPP's interfere with GVN (some values are the regular oop, some 91 are the CastPP of the oop, all merge at Phi's which cannot collapse, etc). 92 This cost us 10% on SpecJVM, even when I removed some of the more trivial 93 cases in the optimizer. Removing more useless Phi's started allowing Loads to 94 illegally float above null checks. I gave up on this approach. 95 96 (4) Add BOTH control edges to both tests. Alas, too much code knows that 97 control edges are in slot-zero ONLY. Many quick asserts fail; no way to do 98 this one. Note that I really want to allow the CMoveP to float and add both 99 control edges to the dependent Load op - meaning I can select early but I 100 cannot Load until I pass both tests. 101 102 (5) Do not hoist CMoveP and StrComp. To this end I added the v-call 103 depends_only_on_test(). No obvious performance loss on Spec, but we are 104 clearly conservative on CMoveP (also so on StrComp but that's unlikely to 105 matter ever). 106 107 */ 108 109 110 //------------------------------Ideal------------------------------------------ 111 // Return a node which is more "ideal" than the current node. 112 // Move constants to the right. 113 Node *CMoveNode::Ideal(PhaseGVN *phase, bool can_reshape) { 114 if( in(0) && remove_dead_region(phase, can_reshape) ) return this; 115 // Don't bother trying to transform a dead node 116 if( in(0) && in(0)->is_top() ) return NULL; 117 assert( !phase->eqv(in(Condition), this) && 118 !phase->eqv(in(IfFalse), this) && 119 !phase->eqv(in(IfTrue), this), "dead loop in CMoveNode::Ideal" ); 120 if( phase->type(in(Condition)) == Type::TOP ) 121 return NULL; // return NULL when Condition is dead 122 123 if( in(IfFalse)->is_Con() && !in(IfTrue)->is_Con() ) { 124 if( in(Condition)->is_Bool() ) { 125 BoolNode* b = in(Condition)->as_Bool(); 126 BoolNode* b2 = b->negate(phase); 127 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type ); 128 } 129 } 130 return NULL; 131 } 132 133 //------------------------------is_cmove_id------------------------------------ 134 // Helper function to check for CMOVE identity. Shared with PhiNode::Identity 135 Node *CMoveNode::is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ) { 136 // Check for Cmp'ing and CMove'ing same values 137 if( (phase->eqv(cmp->in(1),f) && 138 phase->eqv(cmp->in(2),t)) || 139 // Swapped Cmp is OK 140 (phase->eqv(cmp->in(2),f) && 141 phase->eqv(cmp->in(1),t)) ) { 142 // Give up this identity check for floating points because it may choose incorrect 143 // value around 0.0 and -0.0 144 if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD ) 145 return NULL; 146 // Check for "(t==f)?t:f;" and replace with "f" 147 if( b->_test._test == BoolTest::eq ) 148 return f; 149 // Allow the inverted case as well 150 // Check for "(t!=f)?t:f;" and replace with "t" 151 if( b->_test._test == BoolTest::ne ) 152 return t; 153 } 154 return NULL; 155 } 156 157 //------------------------------Identity--------------------------------------- 158 // Conditional-move is an identity if both inputs are the same, or the test 159 // true or false. 160 Node *CMoveNode::Identity( PhaseTransform *phase ) { 161 if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs? 162 return in(IfFalse); // Then it doesn't matter 163 if( phase->type(in(Condition)) == TypeInt::ZERO ) 164 return in(IfFalse); // Always pick left(false) input 165 if( phase->type(in(Condition)) == TypeInt::ONE ) 166 return in(IfTrue); // Always pick right(true) input 167 168 // Check for CMove'ing a constant after comparing against the constant. 169 // Happens all the time now, since if we compare equality vs a constant in 170 // the parser, we "know" the variable is constant on one path and we force 171 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a 172 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more 173 // general in that we don't need constants. 174 if( in(Condition)->is_Bool() ) { 175 BoolNode *b = in(Condition)->as_Bool(); 176 Node *cmp = b->in(1); 177 if( cmp->is_Cmp() ) { 178 Node *id = is_cmove_id( phase, cmp, in(IfTrue), in(IfFalse), b ); 179 if( id ) return id; 180 } 181 } 182 183 return this; 184 } 185 186 //------------------------------Value------------------------------------------ 187 // Result is the meet of inputs 188 const Type *CMoveNode::Value( PhaseTransform *phase ) const { 189 if( phase->type(in(Condition)) == Type::TOP ) 190 return Type::TOP; 191 return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue))); 192 } 193 194 //------------------------------make------------------------------------------- 195 // Make a correctly-flavored CMove. Since _type is directly determined 196 // from the inputs we do not need to specify it here. 197 CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) { 198 switch( t->basic_type() ) { 199 case T_INT: return new (C) CMoveINode( bol, left, right, t->is_int() ); 200 case T_FLOAT: return new (C) CMoveFNode( bol, left, right, t ); 201 case T_DOUBLE: return new (C) CMoveDNode( bol, left, right, t ); 202 case T_LONG: return new (C) CMoveLNode( bol, left, right, t->is_long() ); 203 case T_OBJECT: return new (C) CMovePNode( c, bol, left, right, t->is_oopptr() ); 204 case T_ADDRESS: return new (C) CMovePNode( c, bol, left, right, t->is_ptr() ); 205 case T_NARROWOOP: return new (C) CMoveNNode( c, bol, left, right, t ); 206 default: 207 ShouldNotReachHere(); 208 return NULL; 209 } 210 } 211 212 //============================================================================= 213 //------------------------------Ideal------------------------------------------ 214 // Return a node which is more "ideal" than the current node. 215 // Check for conversions to boolean 216 Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) { 217 // Try generic ideal's first 218 Node *x = CMoveNode::Ideal(phase, can_reshape); 219 if( x ) return x; 220 221 // If zero is on the left (false-case, no-move-case) it must mean another 222 // constant is on the right (otherwise the shared CMove::Ideal code would 223 // have moved the constant to the right). This situation is bad for Intel 224 // and a don't-care for Sparc. It's bad for Intel because the zero has to 225 // be manifested in a register with a XOR which kills flags, which are live 226 // on input to the CMoveI, leading to a situation which causes excessive 227 // spilling on Intel. For Sparc, if the zero in on the left the Sparc will 228 // zero a register via G0 and conditionally-move the other constant. If the 229 // zero is on the right, the Sparc will load the first constant with a 230 // 13-bit set-lo and conditionally move G0. See bug 4677505. 231 if( phase->type(in(IfFalse)) == TypeInt::ZERO && !(phase->type(in(IfTrue)) == TypeInt::ZERO) ) { 232 if( in(Condition)->is_Bool() ) { 233 BoolNode* b = in(Condition)->as_Bool(); 234 BoolNode* b2 = b->negate(phase); 235 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type ); 236 } 237 } 238 239 // Now check for booleans 240 int flip = 0; 241 242 // Check for picking from zero/one 243 if( phase->type(in(IfFalse)) == TypeInt::ZERO && phase->type(in(IfTrue)) == TypeInt::ONE ) { 244 flip = 1 - flip; 245 } else if( phase->type(in(IfFalse)) == TypeInt::ONE && phase->type(in(IfTrue)) == TypeInt::ZERO ) { 246 } else return NULL; 247 248 // Check for eq/ne test 249 if( !in(1)->is_Bool() ) return NULL; 250 BoolNode *bol = in(1)->as_Bool(); 251 if( bol->_test._test == BoolTest::eq ) { 252 } else if( bol->_test._test == BoolTest::ne ) { 253 flip = 1-flip; 254 } else return NULL; 255 256 // Check for vs 0 or 1 257 if( !bol->in(1)->is_Cmp() ) return NULL; 258 const CmpNode *cmp = bol->in(1)->as_Cmp(); 259 if( phase->type(cmp->in(2)) == TypeInt::ZERO ) { 260 } else if( phase->type(cmp->in(2)) == TypeInt::ONE ) { 261 // Allow cmp-vs-1 if the other input is bounded by 0-1 262 if( phase->type(cmp->in(1)) != TypeInt::BOOL ) 263 return NULL; 264 flip = 1 - flip; 265 } else return NULL; 266 267 // Convert to a bool (flipped) 268 // Build int->bool conversion 269 #ifndef PRODUCT 270 if( PrintOpto ) tty->print_cr("CMOV to I2B"); 271 #endif 272 Node *n = new (phase->C) Conv2BNode( cmp->in(1) ); 273 if( flip ) 274 n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) ); 275 276 return n; 277 } 278 279 //============================================================================= 280 //------------------------------Ideal------------------------------------------ 281 // Return a node which is more "ideal" than the current node. 282 // Check for absolute value 283 Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) { 284 // Try generic ideal's first 285 Node *x = CMoveNode::Ideal(phase, can_reshape); 286 if( x ) return x; 287 288 int cmp_zero_idx = 0; // Index of compare input where to look for zero 289 int phi_x_idx = 0; // Index of phi input where to find naked x 290 291 // Find the Bool 292 if( !in(1)->is_Bool() ) return NULL; 293 BoolNode *bol = in(1)->as_Bool(); 294 // Check bool sense 295 switch( bol->_test._test ) { 296 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break; 297 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break; 298 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break; 299 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break; 300 default: return NULL; break; 301 } 302 303 // Find zero input of CmpF; the other input is being abs'd 304 Node *cmpf = bol->in(1); 305 if( cmpf->Opcode() != Op_CmpF ) return NULL; 306 Node *X = NULL; 307 bool flip = false; 308 if( phase->type(cmpf->in(cmp_zero_idx)) == TypeF::ZERO ) { 309 X = cmpf->in(3 - cmp_zero_idx); 310 } else if (phase->type(cmpf->in(3 - cmp_zero_idx)) == TypeF::ZERO) { 311 // The test is inverted, we should invert the result... 312 X = cmpf->in(cmp_zero_idx); 313 flip = true; 314 } else { 315 return NULL; 316 } 317 318 // If X is found on the appropriate phi input, find the subtract on the other 319 if( X != in(phi_x_idx) ) return NULL; 320 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue; 321 Node *sub = in(phi_sub_idx); 322 323 // Allow only SubF(0,X) and fail out for all others; NegF is not OK 324 if( sub->Opcode() != Op_SubF || 325 sub->in(2) != X || 326 phase->type(sub->in(1)) != TypeF::ZERO ) return NULL; 327 328 Node *abs = new (phase->C) AbsFNode( X ); 329 if( flip ) 330 abs = new (phase->C) SubFNode(sub->in(1), phase->transform(abs)); 331 332 return abs; 333 } 334 335 //============================================================================= 336 //------------------------------Ideal------------------------------------------ 337 // Return a node which is more "ideal" than the current node. 338 // Check for absolute value 339 Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) { 340 // Try generic ideal's first 341 Node *x = CMoveNode::Ideal(phase, can_reshape); 342 if( x ) return x; 343 344 int cmp_zero_idx = 0; // Index of compare input where to look for zero 345 int phi_x_idx = 0; // Index of phi input where to find naked x 346 347 // Find the Bool 348 if( !in(1)->is_Bool() ) return NULL; 349 BoolNode *bol = in(1)->as_Bool(); 350 // Check bool sense 351 switch( bol->_test._test ) { 352 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break; 353 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break; 354 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break; 355 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break; 356 default: return NULL; break; 357 } 358 359 // Find zero input of CmpD; the other input is being abs'd 360 Node *cmpd = bol->in(1); 361 if( cmpd->Opcode() != Op_CmpD ) return NULL; 362 Node *X = NULL; 363 bool flip = false; 364 if( phase->type(cmpd->in(cmp_zero_idx)) == TypeD::ZERO ) { 365 X = cmpd->in(3 - cmp_zero_idx); 366 } else if (phase->type(cmpd->in(3 - cmp_zero_idx)) == TypeD::ZERO) { 367 // The test is inverted, we should invert the result... 368 X = cmpd->in(cmp_zero_idx); 369 flip = true; 370 } else { 371 return NULL; 372 } 373 374 // If X is found on the appropriate phi input, find the subtract on the other 375 if( X != in(phi_x_idx) ) return NULL; 376 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue; 377 Node *sub = in(phi_sub_idx); 378 379 // Allow only SubD(0,X) and fail out for all others; NegD is not OK 380 if( sub->Opcode() != Op_SubD || 381 sub->in(2) != X || 382 phase->type(sub->in(1)) != TypeD::ZERO ) return NULL; 383 384 Node *abs = new (phase->C) AbsDNode( X ); 385 if( flip ) 386 abs = new (phase->C) SubDNode(sub->in(1), phase->transform(abs)); 387 388 return abs; 389 } 390 391 392 //============================================================================= 393 // If input is already higher or equal to cast type, then this is an identity. 394 Node *ConstraintCastNode::Identity( PhaseTransform *phase ) { 395 return phase->type(in(1))->higher_equal_speculative(_type) ? in(1) : this; 396 } 397 398 //------------------------------Value------------------------------------------ 399 // Take 'join' of input and cast-up type 400 const Type *ConstraintCastNode::Value( PhaseTransform *phase ) const { 401 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP; 402 const Type* ft = phase->type(in(1))->filter_speculative(_type); 403 404 #ifdef ASSERT 405 // Previous versions of this function had some special case logic, 406 // which is no longer necessary. Make sure of the required effects. 407 switch (Opcode()) { 408 case Op_CastII: 409 { 410 const Type* t1 = phase->type(in(1)); 411 if( t1 == Type::TOP ) assert(ft == Type::TOP, "special case #1"); 412 const Type* rt = t1->join_speculative(_type); 413 if (rt->empty()) assert(ft == Type::TOP, "special case #2"); 414 break; 415 } 416 case Op_CastPP: 417 if (phase->type(in(1)) == TypePtr::NULL_PTR && 418 _type->isa_ptr() && _type->is_ptr()->_ptr == TypePtr::NotNull) 419 assert(ft == Type::TOP, "special case #3"); 420 break; 421 } 422 #endif //ASSERT 423 424 return ft; 425 } 426 427 //------------------------------Ideal------------------------------------------ 428 // Return a node which is more "ideal" than the current node. Strip out 429 // control copies 430 Node *ConstraintCastNode::Ideal(PhaseGVN *phase, bool can_reshape){ 431 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL; 432 } 433 434 //------------------------------Ideal_DU_postCCP------------------------------- 435 // Throw away cast after constant propagation 436 Node *ConstraintCastNode::Ideal_DU_postCCP( PhaseCCP *ccp ) { 437 const Type *t = ccp->type(in(1)); 438 ccp->hash_delete(this); 439 set_type(t); // Turn into ID function 440 ccp->hash_insert(this); 441 return this; 442 } 443 444 uint CastIINode::size_of() const { 445 return sizeof(*this); 446 } 447 448 uint CastIINode::cmp(const Node &n) const { 449 return TypeNode::cmp(n) && ((CastIINode&)n)._carry_dependency == _carry_dependency; 450 } 451 452 Node *CastIINode::Identity(PhaseTransform *phase) { 453 if (_carry_dependency) { 454 return this; 455 } 456 return ConstraintCastNode::Identity(phase); 457 } 458 459 const Type *CastIINode::Value(PhaseTransform *phase) const { 460 const Type *res = ConstraintCastNode::Value(phase); 461 462 // Try to improve the type of the CastII if we recognize a CmpI/If 463 // pattern. 464 if (_carry_dependency) { 465 if (in(0) != NULL && in(0)->in(0) != NULL && in(0)->in(0)->is_If()) { 466 assert(in(0)->is_IfFalse() || in(0)->is_IfTrue(), "should be If proj"); 467 Node* proj = in(0); 468 if (proj->in(0)->in(1)->is_Bool()) { 469 Node* b = proj->in(0)->in(1); 470 if (b->in(1)->Opcode() == Op_CmpI) { 471 Node* cmp = b->in(1); 472 if (cmp->in(1) == in(1) && phase->type(cmp->in(2))->isa_int()) { 473 const TypeInt* in2_t = phase->type(cmp->in(2))->is_int(); 474 const Type* t = TypeInt::INT; 475 BoolTest test = b->as_Bool()->_test; 476 if (proj->is_IfFalse()) { 477 test = test.negate(); 478 } 479 BoolTest::mask m = test._test; 480 jlong lo_long = min_jint; 481 jlong hi_long = max_jint; 482 if (m == BoolTest::le || m == BoolTest::lt) { 483 hi_long = in2_t->_hi; 484 if (m == BoolTest::lt) { 485 hi_long -= 1; 486 } 487 } else if (m == BoolTest::ge || m == BoolTest::gt) { 488 lo_long = in2_t->_lo; 489 if (m == BoolTest::gt) { 490 lo_long += 1; 491 } 492 } else if (m == BoolTest::eq) { 493 lo_long = in2_t->_lo; 494 hi_long = in2_t->_hi; 495 } else if (m == BoolTest::ne) { 496 // can't do any better 497 } else { 498 stringStream ss; 499 test.dump_on(&ss); 500 fatal(err_msg_res("unexpected comparison %s", ss.as_string())); 501 } 502 int lo_int = (int)lo_long; 503 int hi_int = (int)hi_long; 504 505 if (lo_long != (jlong)lo_int) { 506 lo_int = min_jint; 507 } 508 if (hi_long != (jlong)hi_int) { 509 hi_int = max_jint; 510 } 511 512 t = TypeInt::make(lo_int, hi_int, Type::WidenMax); 513 514 res = res->filter_speculative(t); 515 516 return res; 517 } 518 } 519 } 520 } 521 } 522 return res; 523 } 524 525 Node *CastIINode::Ideal_DU_postCCP(PhaseCCP *ccp) { 526 if (_carry_dependency) { 527 return NULL; 528 } 529 return ConstraintCastNode::Ideal_DU_postCCP(ccp); 530 } 531 532 #ifndef PRODUCT 533 void CastIINode::dump_spec(outputStream *st) const { 534 TypeNode::dump_spec(st); 535 if (_carry_dependency) { 536 st->print(" carry dependency"); 537 } 538 if (_range_check_dependency) { 539 st->print(" range check dependency"); 540 } 541 } 542 #endif 543 544 //============================================================================= 545 546 //------------------------------Ideal_DU_postCCP------------------------------- 547 // If not converting int->oop, throw away cast after constant propagation 548 Node *CastPPNode::Ideal_DU_postCCP( PhaseCCP *ccp ) { 549 const Type *t = ccp->type(in(1)); 550 if (!t->isa_oop_ptr() || ((in(1)->is_DecodeN()) && Matcher::gen_narrow_oop_implicit_null_checks())) { 551 return NULL; // do not transform raw pointers or narrow oops 552 } 553 return ConstraintCastNode::Ideal_DU_postCCP(ccp); 554 } 555 556 557 558 //============================================================================= 559 //------------------------------Identity--------------------------------------- 560 // If input is already higher or equal to cast type, then this is an identity. 561 Node *CheckCastPPNode::Identity( PhaseTransform *phase ) { 562 // Toned down to rescue meeting at a Phi 3 different oops all implementing 563 // the same interface. CompileTheWorld starting at 502, kd12rc1.zip. 564 return (phase->type(in(1)) == phase->type(this)) ? in(1) : this; 565 } 566 567 //------------------------------Value------------------------------------------ 568 // Take 'join' of input and cast-up type, unless working with an Interface 569 const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const { 570 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP; 571 572 const Type *inn = phase->type(in(1)); 573 if( inn == Type::TOP ) return Type::TOP; // No information yet 574 575 const TypePtr *in_type = inn->isa_ptr(); 576 const TypePtr *my_type = _type->isa_ptr(); 577 const Type *result = _type; 578 if( in_type != NULL && my_type != NULL ) { 579 TypePtr::PTR in_ptr = in_type->ptr(); 580 if( in_ptr == TypePtr::Null ) { 581 result = in_type; 582 } else if( in_ptr == TypePtr::Constant ) { 583 // Casting a constant oop to an interface? 584 // (i.e., a String to a Comparable?) 585 // Then return the interface. 586 const TypeOopPtr *jptr = my_type->isa_oopptr(); 587 assert( jptr, "" ); 588 result = (jptr->klass()->is_interface() || !in_type->higher_equal(_type)) 589 ? my_type->cast_to_ptr_type( TypePtr::NotNull ) 590 : in_type; 591 } else { 592 result = my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) ); 593 } 594 } 595 return result; 596 597 // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES. 598 // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR! 599 600 // 601 // Remove this code after overnight run indicates no performance 602 // loss from not performing JOIN at CheckCastPPNode 603 // 604 // const TypeInstPtr *in_oop = in->isa_instptr(); 605 // const TypeInstPtr *my_oop = _type->isa_instptr(); 606 // // If either input is an 'interface', return destination type 607 // assert (in_oop == NULL || in_oop->klass() != NULL, ""); 608 // assert (my_oop == NULL || my_oop->klass() != NULL, ""); 609 // if( (in_oop && in_oop->klass()->is_interface()) 610 // ||(my_oop && my_oop->klass()->is_interface()) ) { 611 // TypePtr::PTR in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR; 612 // // Preserve cast away nullness for interfaces 613 // if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) { 614 // return my_oop->cast_to_ptr_type(TypePtr::NotNull); 615 // } 616 // return _type; 617 // } 618 // 619 // // Neither the input nor the destination type is an interface, 620 // 621 // // history: JOIN used to cause weird corner case bugs 622 // // return (in == TypeOopPtr::NULL_PTR) ? in : _type; 623 // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops. 624 // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr 625 // const Type *join = in->join(_type); 626 // // Check if join preserved NotNull'ness for pointers 627 // if( join->isa_ptr() && _type->isa_ptr() ) { 628 // TypePtr::PTR join_ptr = join->is_ptr()->_ptr; 629 // TypePtr::PTR type_ptr = _type->is_ptr()->_ptr; 630 // // If there isn't any NotNull'ness to preserve 631 // // OR if join preserved NotNull'ness then return it 632 // if( type_ptr == TypePtr::BotPTR || type_ptr == TypePtr::Null || 633 // join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) { 634 // return join; 635 // } 636 // // ELSE return same old type as before 637 // return _type; 638 // } 639 // // Not joining two pointers 640 // return join; 641 } 642 643 //------------------------------Ideal------------------------------------------ 644 // Return a node which is more "ideal" than the current node. Strip out 645 // control copies 646 Node *CheckCastPPNode::Ideal(PhaseGVN *phase, bool can_reshape){ 647 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL; 648 } 649 650 651 Node* DecodeNNode::Identity(PhaseTransform* phase) { 652 const Type *t = phase->type( in(1) ); 653 if( t == Type::TOP ) return in(1); 654 655 if (in(1)->is_EncodeP()) { 656 // (DecodeN (EncodeP p)) -> p 657 return in(1)->in(1); 658 } 659 return this; 660 } 661 662 const Type *DecodeNNode::Value( PhaseTransform *phase ) const { 663 const Type *t = phase->type( in(1) ); 664 if (t == Type::TOP) return Type::TOP; 665 if (t == TypeNarrowOop::NULL_PTR) return TypePtr::NULL_PTR; 666 667 assert(t->isa_narrowoop(), "only narrowoop here"); 668 return t->make_ptr(); 669 } 670 671 Node* EncodePNode::Identity(PhaseTransform* phase) { 672 const Type *t = phase->type( in(1) ); 673 if( t == Type::TOP ) return in(1); 674 675 if (in(1)->is_DecodeN()) { 676 // (EncodeP (DecodeN p)) -> p 677 return in(1)->in(1); 678 } 679 return this; 680 } 681 682 const Type *EncodePNode::Value( PhaseTransform *phase ) const { 683 const Type *t = phase->type( in(1) ); 684 if (t == Type::TOP) return Type::TOP; 685 if (t == TypePtr::NULL_PTR) return TypeNarrowOop::NULL_PTR; 686 687 assert(t->isa_oop_ptr(), "only oopptr here"); 688 return t->make_narrowoop(); 689 } 690 691 692 Node *EncodeNarrowPtrNode::Ideal_DU_postCCP( PhaseCCP *ccp ) { 693 return MemNode::Ideal_common_DU_postCCP(ccp, this, in(1)); 694 } 695 696 Node* DecodeNKlassNode::Identity(PhaseTransform* phase) { 697 const Type *t = phase->type( in(1) ); 698 if( t == Type::TOP ) return in(1); 699 700 if (in(1)->is_EncodePKlass()) { 701 // (DecodeNKlass (EncodePKlass p)) -> p 702 return in(1)->in(1); 703 } 704 return this; 705 } 706 707 const Type *DecodeNKlassNode::Value( PhaseTransform *phase ) const { 708 const Type *t = phase->type( in(1) ); 709 if (t == Type::TOP) return Type::TOP; 710 assert(t != TypeNarrowKlass::NULL_PTR, "null klass?"); 711 712 assert(t->isa_narrowklass(), "only narrow klass ptr here"); 713 return t->make_ptr(); 714 } 715 716 Node* EncodePKlassNode::Identity(PhaseTransform* phase) { 717 const Type *t = phase->type( in(1) ); 718 if( t == Type::TOP ) return in(1); 719 720 if (in(1)->is_DecodeNKlass()) { 721 // (EncodePKlass (DecodeNKlass p)) -> p 722 return in(1)->in(1); 723 } 724 return this; 725 } 726 727 const Type *EncodePKlassNode::Value( PhaseTransform *phase ) const { 728 const Type *t = phase->type( in(1) ); 729 if (t == Type::TOP) return Type::TOP; 730 assert (t != TypePtr::NULL_PTR, "null klass?"); 731 732 assert(UseCompressedClassPointers && t->isa_klassptr(), "only klass ptr here"); 733 return t->make_narrowklass(); 734 } 735 736 737 //============================================================================= 738 //------------------------------Identity--------------------------------------- 739 Node *Conv2BNode::Identity( PhaseTransform *phase ) { 740 const Type *t = phase->type( in(1) ); 741 if( t == Type::TOP ) return in(1); 742 if( t == TypeInt::ZERO ) return in(1); 743 if( t == TypeInt::ONE ) return in(1); 744 if( t == TypeInt::BOOL ) return in(1); 745 return this; 746 } 747 748 //------------------------------Value------------------------------------------ 749 const Type *Conv2BNode::Value( PhaseTransform *phase ) const { 750 const Type *t = phase->type( in(1) ); 751 if( t == Type::TOP ) return Type::TOP; 752 if( t == TypeInt::ZERO ) return TypeInt::ZERO; 753 if( t == TypePtr::NULL_PTR ) return TypeInt::ZERO; 754 const TypePtr *tp = t->isa_ptr(); 755 if( tp != NULL ) { 756 if( tp->ptr() == TypePtr::AnyNull ) return Type::TOP; 757 if( tp->ptr() == TypePtr::Constant) return TypeInt::ONE; 758 if (tp->ptr() == TypePtr::NotNull) return TypeInt::ONE; 759 return TypeInt::BOOL; 760 } 761 if (t->base() != Type::Int) return TypeInt::BOOL; 762 const TypeInt *ti = t->is_int(); 763 if( ti->_hi < 0 || ti->_lo > 0 ) return TypeInt::ONE; 764 return TypeInt::BOOL; 765 } 766 767 768 // The conversions operations are all Alpha sorted. Please keep it that way! 769 //============================================================================= 770 //------------------------------Value------------------------------------------ 771 const Type *ConvD2FNode::Value( PhaseTransform *phase ) const { 772 const Type *t = phase->type( in(1) ); 773 if( t == Type::TOP ) return Type::TOP; 774 if( t == Type::DOUBLE ) return Type::FLOAT; 775 const TypeD *td = t->is_double_constant(); 776 return TypeF::make( (float)td->getd() ); 777 } 778 779 //------------------------------Identity--------------------------------------- 780 // Float's can be converted to doubles with no loss of bits. Hence 781 // converting a float to a double and back to a float is a NOP. 782 Node *ConvD2FNode::Identity(PhaseTransform *phase) { 783 return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this; 784 } 785 786 //============================================================================= 787 //------------------------------Value------------------------------------------ 788 const Type *ConvD2INode::Value( PhaseTransform *phase ) const { 789 const Type *t = phase->type( in(1) ); 790 if( t == Type::TOP ) return Type::TOP; 791 if( t == Type::DOUBLE ) return TypeInt::INT; 792 const TypeD *td = t->is_double_constant(); 793 return TypeInt::make( SharedRuntime::d2i( td->getd() ) ); 794 } 795 796 //------------------------------Ideal------------------------------------------ 797 // If converting to an int type, skip any rounding nodes 798 Node *ConvD2INode::Ideal(PhaseGVN *phase, bool can_reshape) { 799 if( in(1)->Opcode() == Op_RoundDouble ) 800 set_req(1,in(1)->in(1)); 801 return NULL; 802 } 803 804 //------------------------------Identity--------------------------------------- 805 // Int's can be converted to doubles with no loss of bits. Hence 806 // converting an integer to a double and back to an integer is a NOP. 807 Node *ConvD2INode::Identity(PhaseTransform *phase) { 808 return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this; 809 } 810 811 //============================================================================= 812 //------------------------------Value------------------------------------------ 813 const Type *ConvD2LNode::Value( PhaseTransform *phase ) const { 814 const Type *t = phase->type( in(1) ); 815 if( t == Type::TOP ) return Type::TOP; 816 if( t == Type::DOUBLE ) return TypeLong::LONG; 817 const TypeD *td = t->is_double_constant(); 818 return TypeLong::make( SharedRuntime::d2l( td->getd() ) ); 819 } 820 821 //------------------------------Identity--------------------------------------- 822 Node *ConvD2LNode::Identity(PhaseTransform *phase) { 823 // Remove ConvD2L->ConvL2D->ConvD2L sequences. 824 if( in(1) ->Opcode() == Op_ConvL2D && 825 in(1)->in(1)->Opcode() == Op_ConvD2L ) 826 return in(1)->in(1); 827 return this; 828 } 829 830 //------------------------------Ideal------------------------------------------ 831 // If converting to an int type, skip any rounding nodes 832 Node *ConvD2LNode::Ideal(PhaseGVN *phase, bool can_reshape) { 833 if( in(1)->Opcode() == Op_RoundDouble ) 834 set_req(1,in(1)->in(1)); 835 return NULL; 836 } 837 838 //============================================================================= 839 //------------------------------Value------------------------------------------ 840 const Type *ConvF2DNode::Value( PhaseTransform *phase ) const { 841 const Type *t = phase->type( in(1) ); 842 if( t == Type::TOP ) return Type::TOP; 843 if( t == Type::FLOAT ) return Type::DOUBLE; 844 const TypeF *tf = t->is_float_constant(); 845 return TypeD::make( (double)tf->getf() ); 846 } 847 848 //============================================================================= 849 //------------------------------Value------------------------------------------ 850 const Type *ConvF2INode::Value( PhaseTransform *phase ) const { 851 const Type *t = phase->type( in(1) ); 852 if( t == Type::TOP ) return Type::TOP; 853 if( t == Type::FLOAT ) return TypeInt::INT; 854 const TypeF *tf = t->is_float_constant(); 855 return TypeInt::make( SharedRuntime::f2i( tf->getf() ) ); 856 } 857 858 //------------------------------Identity--------------------------------------- 859 Node *ConvF2INode::Identity(PhaseTransform *phase) { 860 // Remove ConvF2I->ConvI2F->ConvF2I sequences. 861 if( in(1) ->Opcode() == Op_ConvI2F && 862 in(1)->in(1)->Opcode() == Op_ConvF2I ) 863 return in(1)->in(1); 864 return this; 865 } 866 867 //------------------------------Ideal------------------------------------------ 868 // If converting to an int type, skip any rounding nodes 869 Node *ConvF2INode::Ideal(PhaseGVN *phase, bool can_reshape) { 870 if( in(1)->Opcode() == Op_RoundFloat ) 871 set_req(1,in(1)->in(1)); 872 return NULL; 873 } 874 875 //============================================================================= 876 //------------------------------Value------------------------------------------ 877 const Type *ConvF2LNode::Value( PhaseTransform *phase ) const { 878 const Type *t = phase->type( in(1) ); 879 if( t == Type::TOP ) return Type::TOP; 880 if( t == Type::FLOAT ) return TypeLong::LONG; 881 const TypeF *tf = t->is_float_constant(); 882 return TypeLong::make( SharedRuntime::f2l( tf->getf() ) ); 883 } 884 885 //------------------------------Identity--------------------------------------- 886 Node *ConvF2LNode::Identity(PhaseTransform *phase) { 887 // Remove ConvF2L->ConvL2F->ConvF2L sequences. 888 if( in(1) ->Opcode() == Op_ConvL2F && 889 in(1)->in(1)->Opcode() == Op_ConvF2L ) 890 return in(1)->in(1); 891 return this; 892 } 893 894 //------------------------------Ideal------------------------------------------ 895 // If converting to an int type, skip any rounding nodes 896 Node *ConvF2LNode::Ideal(PhaseGVN *phase, bool can_reshape) { 897 if( in(1)->Opcode() == Op_RoundFloat ) 898 set_req(1,in(1)->in(1)); 899 return NULL; 900 } 901 902 //============================================================================= 903 //------------------------------Value------------------------------------------ 904 const Type *ConvI2DNode::Value( PhaseTransform *phase ) const { 905 const Type *t = phase->type( in(1) ); 906 if( t == Type::TOP ) return Type::TOP; 907 const TypeInt *ti = t->is_int(); 908 if( ti->is_con() ) return TypeD::make( (double)ti->get_con() ); 909 return bottom_type(); 910 } 911 912 //============================================================================= 913 //------------------------------Value------------------------------------------ 914 const Type *ConvI2FNode::Value( PhaseTransform *phase ) const { 915 const Type *t = phase->type( in(1) ); 916 if( t == Type::TOP ) return Type::TOP; 917 const TypeInt *ti = t->is_int(); 918 if( ti->is_con() ) return TypeF::make( (float)ti->get_con() ); 919 return bottom_type(); 920 } 921 922 //------------------------------Identity--------------------------------------- 923 Node *ConvI2FNode::Identity(PhaseTransform *phase) { 924 // Remove ConvI2F->ConvF2I->ConvI2F sequences. 925 if( in(1) ->Opcode() == Op_ConvF2I && 926 in(1)->in(1)->Opcode() == Op_ConvI2F ) 927 return in(1)->in(1); 928 return this; 929 } 930 931 //============================================================================= 932 //------------------------------Value------------------------------------------ 933 const Type *ConvI2LNode::Value( PhaseTransform *phase ) const { 934 const Type *t = phase->type( in(1) ); 935 if( t == Type::TOP ) return Type::TOP; 936 const TypeInt *ti = t->is_int(); 937 const Type* tl = TypeLong::make(ti->_lo, ti->_hi, ti->_widen); 938 // Join my declared type against my incoming type. 939 tl = tl->filter(_type); 940 return tl; 941 } 942 943 #ifdef _LP64 944 static inline bool long_ranges_overlap(jlong lo1, jlong hi1, 945 jlong lo2, jlong hi2) { 946 // Two ranges overlap iff one range's low point falls in the other range. 947 return (lo2 <= lo1 && lo1 <= hi2) || (lo1 <= lo2 && lo2 <= hi1); 948 } 949 #endif 950 951 //------------------------------Ideal------------------------------------------ 952 Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) { 953 const TypeLong* this_type = this->type()->is_long(); 954 Node* this_changed = NULL; 955 956 // If _major_progress, then more loop optimizations follow. Do NOT 957 // remove this node's type assertion until no more loop ops can happen. 958 // The progress bit is set in the major loop optimizations THEN comes the 959 // call to IterGVN and any chance of hitting this code. Cf. Opaque1Node. 960 if (can_reshape && !phase->C->major_progress()) { 961 const TypeInt* in_type = phase->type(in(1))->isa_int(); 962 if (in_type != NULL && this_type != NULL && 963 (in_type->_lo != this_type->_lo || 964 in_type->_hi != this_type->_hi)) { 965 // Although this WORSENS the type, it increases GVN opportunities, 966 // because I2L nodes with the same input will common up, regardless 967 // of slightly differing type assertions. Such slight differences 968 // arise routinely as a result of loop unrolling, so this is a 969 // post-unrolling graph cleanup. Choose a type which depends only 970 // on my input. (Exception: Keep a range assertion of >=0 or <0.) 971 jlong lo1 = this_type->_lo; 972 jlong hi1 = this_type->_hi; 973 int w1 = this_type->_widen; 974 if (lo1 != (jint)lo1 || 975 hi1 != (jint)hi1 || 976 lo1 > hi1) { 977 // Overflow leads to wraparound, wraparound leads to range saturation. 978 lo1 = min_jint; hi1 = max_jint; 979 } else if (lo1 >= 0) { 980 // Keep a range assertion of >=0. 981 lo1 = 0; hi1 = max_jint; 982 } else if (hi1 < 0) { 983 // Keep a range assertion of <0. 984 lo1 = min_jint; hi1 = -1; 985 } else { 986 lo1 = min_jint; hi1 = max_jint; 987 } 988 const TypeLong* wtype = TypeLong::make(MAX2((jlong)in_type->_lo, lo1), 989 MIN2((jlong)in_type->_hi, hi1), 990 MAX2((int)in_type->_widen, w1)); 991 if (wtype != type()) { 992 set_type(wtype); 993 // Note: this_type still has old type value, for the logic below. 994 this_changed = this; 995 } 996 } 997 } 998 999 #ifdef _LP64 1000 // Convert ConvI2L(AddI(x, y)) to AddL(ConvI2L(x), ConvI2L(y)) or 1001 // ConvI2L(CastII(AddI(x, y))) to AddL(ConvI2L(CastII(x)), ConvI2L(CastII(y))), 1002 // but only if x and y have subranges that cannot cause 32-bit overflow, 1003 // under the assumption that x+y is in my own subrange this->type(). 1004 1005 // This assumption is based on a constraint (i.e., type assertion) 1006 // established in Parse::array_addressing or perhaps elsewhere. 1007 // This constraint has been adjoined to the "natural" type of 1008 // the incoming argument in(0). We know (because of runtime 1009 // checks) - that the result value I2L(x+y) is in the joined range. 1010 // Hence we can restrict the incoming terms (x, y) to values such 1011 // that their sum also lands in that range. 1012 1013 // This optimization is useful only on 64-bit systems, where we hope 1014 // the addition will end up subsumed in an addressing mode. 1015 // It is necessary to do this when optimizing an unrolled array 1016 // copy loop such as x[i++] = y[i++]. 1017 1018 // On 32-bit systems, it's better to perform as much 32-bit math as 1019 // possible before the I2L conversion, because 32-bit math is cheaper. 1020 // There's no common reason to "leak" a constant offset through the I2L. 1021 // Addressing arithmetic will not absorb it as part of a 64-bit AddL. 1022 1023 Node* z = in(1); 1024 int op = z->Opcode(); 1025 Node* ctrl = NULL; 1026 if (op == Op_CastII && z->as_CastII()->has_range_check()) { 1027 // Skip CastII node but save control dependency 1028 ctrl = z->in(0); 1029 z = z->in(1); 1030 op = z->Opcode(); 1031 } 1032 if (op == Op_AddI || op == Op_SubI) { 1033 Node* x = z->in(1); 1034 Node* y = z->in(2); 1035 assert (x != z && y != z, "dead loop in ConvI2LNode::Ideal"); 1036 if (phase->type(x) == Type::TOP) return this_changed; 1037 if (phase->type(y) == Type::TOP) return this_changed; 1038 const TypeInt* tx = phase->type(x)->is_int(); 1039 const TypeInt* ty = phase->type(y)->is_int(); 1040 const TypeLong* tz = this_type; 1041 jlong xlo = tx->_lo; 1042 jlong xhi = tx->_hi; 1043 jlong ylo = ty->_lo; 1044 jlong yhi = ty->_hi; 1045 jlong zlo = tz->_lo; 1046 jlong zhi = tz->_hi; 1047 jlong vbit = CONST64(1) << BitsPerInt; 1048 int widen = MAX2(tx->_widen, ty->_widen); 1049 if (op == Op_SubI) { 1050 jlong ylo0 = ylo; 1051 ylo = -yhi; 1052 yhi = -ylo0; 1053 } 1054 // See if x+y can cause positive overflow into z+2**32 1055 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo+vbit, zhi+vbit)) { 1056 return this_changed; 1057 } 1058 // See if x+y can cause negative overflow into z-2**32 1059 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo-vbit, zhi-vbit)) { 1060 return this_changed; 1061 } 1062 // Now it's always safe to assume x+y does not overflow. 1063 // This is true even if some pairs x,y might cause overflow, as long 1064 // as that overflow value cannot fall into [zlo,zhi]. 1065 1066 // Confident that the arithmetic is "as if infinite precision", 1067 // we can now use z's range to put constraints on those of x and y. 1068 // The "natural" range of x [xlo,xhi] can perhaps be narrowed to a 1069 // more "restricted" range by intersecting [xlo,xhi] with the 1070 // range obtained by subtracting y's range from the asserted range 1071 // of the I2L conversion. Here's the interval arithmetic algebra: 1072 // x == z-y == [zlo,zhi]-[ylo,yhi] == [zlo,zhi]+[-yhi,-ylo] 1073 // => x in [zlo-yhi, zhi-ylo] 1074 // => x in [zlo-yhi, zhi-ylo] INTERSECT [xlo,xhi] 1075 // => x in [xlo MAX zlo-yhi, xhi MIN zhi-ylo] 1076 jlong rxlo = MAX2(xlo, zlo - yhi); 1077 jlong rxhi = MIN2(xhi, zhi - ylo); 1078 // And similarly, x changing place with y: 1079 jlong rylo = MAX2(ylo, zlo - xhi); 1080 jlong ryhi = MIN2(yhi, zhi - xlo); 1081 if (rxlo > rxhi || rylo > ryhi) { 1082 return this_changed; // x or y is dying; don't mess w/ it 1083 } 1084 if (op == Op_SubI) { 1085 jlong rylo0 = rylo; 1086 rylo = -ryhi; 1087 ryhi = -rylo0; 1088 } 1089 assert(rxlo == (int)rxlo && rxhi == (int)rxhi, "x should not overflow"); 1090 assert(rylo == (int)rylo && ryhi == (int)ryhi, "y should not overflow"); 1091 Node* cx = phase->C->constrained_convI2L(phase, x, TypeInt::make(rxlo, rxhi, widen), ctrl); 1092 Node* cy = phase->C->constrained_convI2L(phase, y, TypeInt::make(rylo, ryhi, widen), ctrl); 1093 switch (op) { 1094 case Op_AddI: return new (phase->C) AddLNode(cx, cy); 1095 case Op_SubI: return new (phase->C) SubLNode(cx, cy); 1096 default: ShouldNotReachHere(); 1097 } 1098 } 1099 #endif //_LP64 1100 1101 return this_changed; 1102 } 1103 1104 //============================================================================= 1105 //------------------------------Value------------------------------------------ 1106 const Type *ConvL2DNode::Value( PhaseTransform *phase ) const { 1107 const Type *t = phase->type( in(1) ); 1108 if( t == Type::TOP ) return Type::TOP; 1109 const TypeLong *tl = t->is_long(); 1110 if( tl->is_con() ) return TypeD::make( (double)tl->get_con() ); 1111 return bottom_type(); 1112 } 1113 1114 //============================================================================= 1115 //------------------------------Value------------------------------------------ 1116 const Type *ConvL2FNode::Value( PhaseTransform *phase ) const { 1117 const Type *t = phase->type( in(1) ); 1118 if( t == Type::TOP ) return Type::TOP; 1119 const TypeLong *tl = t->is_long(); 1120 if( tl->is_con() ) return TypeF::make( (float)tl->get_con() ); 1121 return bottom_type(); 1122 } 1123 1124 //============================================================================= 1125 //----------------------------Identity----------------------------------------- 1126 Node *ConvL2INode::Identity( PhaseTransform *phase ) { 1127 // Convert L2I(I2L(x)) => x 1128 if (in(1)->Opcode() == Op_ConvI2L) return in(1)->in(1); 1129 return this; 1130 } 1131 1132 //------------------------------Value------------------------------------------ 1133 const Type *ConvL2INode::Value( PhaseTransform *phase ) const { 1134 const Type *t = phase->type( in(1) ); 1135 if( t == Type::TOP ) return Type::TOP; 1136 const TypeLong *tl = t->is_long(); 1137 if (tl->is_con()) 1138 // Easy case. 1139 return TypeInt::make((jint)tl->get_con()); 1140 return bottom_type(); 1141 } 1142 1143 //------------------------------Ideal------------------------------------------ 1144 // Return a node which is more "ideal" than the current node. 1145 // Blow off prior masking to int 1146 Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) { 1147 Node *andl = in(1); 1148 uint andl_op = andl->Opcode(); 1149 if( andl_op == Op_AndL ) { 1150 // Blow off prior masking to int 1151 if( phase->type(andl->in(2)) == TypeLong::make( 0xFFFFFFFF ) ) { 1152 set_req(1,andl->in(1)); 1153 return this; 1154 } 1155 } 1156 1157 // Swap with a prior add: convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y)) 1158 // This replaces an 'AddL' with an 'AddI'. 1159 if( andl_op == Op_AddL ) { 1160 // Don't do this for nodes which have more than one user since 1161 // we'll end up computing the long add anyway. 1162 if (andl->outcnt() > 1) return NULL; 1163 1164 Node* x = andl->in(1); 1165 Node* y = andl->in(2); 1166 assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" ); 1167 if (phase->type(x) == Type::TOP) return NULL; 1168 if (phase->type(y) == Type::TOP) return NULL; 1169 Node *add1 = phase->transform(new (phase->C) ConvL2INode(x)); 1170 Node *add2 = phase->transform(new (phase->C) ConvL2INode(y)); 1171 return new (phase->C) AddINode(add1,add2); 1172 } 1173 1174 // Disable optimization: LoadL->ConvL2I ==> LoadI. 1175 // It causes problems (sizes of Load and Store nodes do not match) 1176 // in objects initialization code and Escape Analysis. 1177 return NULL; 1178 } 1179 1180 //============================================================================= 1181 //------------------------------Value------------------------------------------ 1182 const Type *CastX2PNode::Value( PhaseTransform *phase ) const { 1183 const Type* t = phase->type(in(1)); 1184 if (t == Type::TOP) return Type::TOP; 1185 if (t->base() == Type_X && t->singleton()) { 1186 uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con(); 1187 if (bits == 0) return TypePtr::NULL_PTR; 1188 return TypeRawPtr::make((address) bits); 1189 } 1190 return CastX2PNode::bottom_type(); 1191 } 1192 1193 //------------------------------Idealize--------------------------------------- 1194 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) { 1195 if (t == Type::TOP) return false; 1196 const TypeX* tl = t->is_intptr_t(); 1197 jint lo = min_jint; 1198 jint hi = max_jint; 1199 if (but_not_min_int) ++lo; // caller wants to negate the value w/o overflow 1200 return (tl->_lo >= lo) && (tl->_hi <= hi); 1201 } 1202 1203 static inline Node* addP_of_X2P(PhaseGVN *phase, 1204 Node* base, 1205 Node* dispX, 1206 bool negate = false) { 1207 if (negate) { 1208 dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX)); 1209 } 1210 return new (phase->C) AddPNode(phase->C->top(), 1211 phase->transform(new (phase->C) CastX2PNode(base)), 1212 phase->transform(dispX)); 1213 } 1214 1215 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1216 // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int 1217 int op = in(1)->Opcode(); 1218 Node* x; 1219 Node* y; 1220 switch (op) { 1221 case Op_SubX: 1222 x = in(1)->in(1); 1223 // Avoid ideal transformations ping-pong between this and AddP for raw pointers. 1224 if (phase->find_intptr_t_con(x, -1) == 0) 1225 break; 1226 y = in(1)->in(2); 1227 if (fits_in_int(phase->type(y), true)) { 1228 return addP_of_X2P(phase, x, y, true); 1229 } 1230 break; 1231 case Op_AddX: 1232 x = in(1)->in(1); 1233 y = in(1)->in(2); 1234 if (fits_in_int(phase->type(y))) { 1235 return addP_of_X2P(phase, x, y); 1236 } 1237 if (fits_in_int(phase->type(x))) { 1238 return addP_of_X2P(phase, y, x); 1239 } 1240 break; 1241 } 1242 return NULL; 1243 } 1244 1245 //------------------------------Identity--------------------------------------- 1246 Node *CastX2PNode::Identity( PhaseTransform *phase ) { 1247 if (in(1)->Opcode() == Op_CastP2X) return in(1)->in(1); 1248 return this; 1249 } 1250 1251 //============================================================================= 1252 //------------------------------Value------------------------------------------ 1253 const Type *CastP2XNode::Value( PhaseTransform *phase ) const { 1254 const Type* t = phase->type(in(1)); 1255 if (t == Type::TOP) return Type::TOP; 1256 if (t->base() == Type::RawPtr && t->singleton()) { 1257 uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con(); 1258 return TypeX::make(bits); 1259 } 1260 return CastP2XNode::bottom_type(); 1261 } 1262 1263 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1264 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL; 1265 } 1266 1267 //------------------------------Identity--------------------------------------- 1268 Node *CastP2XNode::Identity( PhaseTransform *phase ) { 1269 if (in(1)->Opcode() == Op_CastX2P) return in(1)->in(1); 1270 return this; 1271 } 1272 1273 1274 //============================================================================= 1275 //------------------------------Identity--------------------------------------- 1276 // Remove redundant roundings 1277 Node *RoundFloatNode::Identity( PhaseTransform *phase ) { 1278 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel"); 1279 // Do not round constants 1280 if (phase->type(in(1))->base() == Type::FloatCon) return in(1); 1281 int op = in(1)->Opcode(); 1282 // Redundant rounding 1283 if( op == Op_RoundFloat ) return in(1); 1284 // Already rounded 1285 if( op == Op_Parm ) return in(1); 1286 if( op == Op_LoadF ) return in(1); 1287 return this; 1288 } 1289 1290 //------------------------------Value------------------------------------------ 1291 const Type *RoundFloatNode::Value( PhaseTransform *phase ) const { 1292 return phase->type( in(1) ); 1293 } 1294 1295 //============================================================================= 1296 //------------------------------Identity--------------------------------------- 1297 // Remove redundant roundings. Incoming arguments are already rounded. 1298 Node *RoundDoubleNode::Identity( PhaseTransform *phase ) { 1299 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel"); 1300 // Do not round constants 1301 if (phase->type(in(1))->base() == Type::DoubleCon) return in(1); 1302 int op = in(1)->Opcode(); 1303 // Redundant rounding 1304 if( op == Op_RoundDouble ) return in(1); 1305 // Already rounded 1306 if( op == Op_Parm ) return in(1); 1307 if( op == Op_LoadD ) return in(1); 1308 if( op == Op_ConvF2D ) return in(1); 1309 if( op == Op_ConvI2D ) return in(1); 1310 return this; 1311 } 1312 1313 //------------------------------Value------------------------------------------ 1314 const Type *RoundDoubleNode::Value( PhaseTransform *phase ) const { 1315 return phase->type( in(1) ); 1316 } 1317 1318 1319 //============================================================================= 1320 // Do not allow value-numbering 1321 uint Opaque1Node::hash() const { return NO_HASH; } 1322 uint Opaque1Node::cmp( const Node &n ) const { 1323 return (&n == this); // Always fail except on self 1324 } 1325 1326 //------------------------------Identity--------------------------------------- 1327 // If _major_progress, then more loop optimizations follow. Do NOT remove 1328 // the opaque Node until no more loop ops can happen. Note the timing of 1329 // _major_progress; it's set in the major loop optimizations THEN comes the 1330 // call to IterGVN and any chance of hitting this code. Hence there's no 1331 // phase-ordering problem with stripping Opaque1 in IGVN followed by some 1332 // more loop optimizations that require it. 1333 Node *Opaque1Node::Identity( PhaseTransform *phase ) { 1334 return phase->C->major_progress() ? this : in(1); 1335 } 1336 1337 //============================================================================= 1338 // A node to prevent unwanted optimizations. Allows constant folding. Stops 1339 // value-numbering, most Ideal calls or Identity functions. This Node is 1340 // specifically designed to prevent the pre-increment value of a loop trip 1341 // counter from being live out of the bottom of the loop (hence causing the 1342 // pre- and post-increment values both being live and thus requiring an extra 1343 // temp register and an extra move). If we "accidentally" optimize through 1344 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus 1345 // it's OK to be slightly sloppy on optimizations here. 1346 1347 // Do not allow value-numbering 1348 uint Opaque2Node::hash() const { return NO_HASH; } 1349 uint Opaque2Node::cmp( const Node &n ) const { 1350 return (&n == this); // Always fail except on self 1351 } 1352 1353 //============================================================================= 1354 1355 uint ProfileBooleanNode::hash() const { return NO_HASH; } 1356 uint ProfileBooleanNode::cmp( const Node &n ) const { 1357 return (&n == this); 1358 } 1359 1360 Node *ProfileBooleanNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1361 if (can_reshape && _delay_removal) { 1362 _delay_removal = false; 1363 return this; 1364 } else { 1365 return NULL; 1366 } 1367 } 1368 1369 Node *ProfileBooleanNode::Identity( PhaseTransform *phase ) { 1370 if (_delay_removal) { 1371 return this; 1372 } else { 1373 assert(_consumed, "profile should be consumed before elimination"); 1374 return in(1); 1375 } 1376 } 1377 1378 //------------------------------Value------------------------------------------ 1379 const Type *MoveL2DNode::Value( PhaseTransform *phase ) const { 1380 const Type *t = phase->type( in(1) ); 1381 if( t == Type::TOP ) return Type::TOP; 1382 const TypeLong *tl = t->is_long(); 1383 if( !tl->is_con() ) return bottom_type(); 1384 JavaValue v; 1385 v.set_jlong(tl->get_con()); 1386 return TypeD::make( v.get_jdouble() ); 1387 } 1388 1389 //------------------------------Value------------------------------------------ 1390 const Type *MoveI2FNode::Value( PhaseTransform *phase ) const { 1391 const Type *t = phase->type( in(1) ); 1392 if( t == Type::TOP ) return Type::TOP; 1393 const TypeInt *ti = t->is_int(); 1394 if( !ti->is_con() ) return bottom_type(); 1395 JavaValue v; 1396 v.set_jint(ti->get_con()); 1397 return TypeF::make( v.get_jfloat() ); 1398 } 1399 1400 //------------------------------Value------------------------------------------ 1401 const Type *MoveF2INode::Value( PhaseTransform *phase ) const { 1402 const Type *t = phase->type( in(1) ); 1403 if( t == Type::TOP ) return Type::TOP; 1404 if( t == Type::FLOAT ) return TypeInt::INT; 1405 const TypeF *tf = t->is_float_constant(); 1406 JavaValue v; 1407 v.set_jfloat(tf->getf()); 1408 return TypeInt::make( v.get_jint() ); 1409 } 1410 1411 //------------------------------Value------------------------------------------ 1412 const Type *MoveD2LNode::Value( PhaseTransform *phase ) const { 1413 const Type *t = phase->type( in(1) ); 1414 if( t == Type::TOP ) return Type::TOP; 1415 if( t == Type::DOUBLE ) return TypeLong::LONG; 1416 const TypeD *td = t->is_double_constant(); 1417 JavaValue v; 1418 v.set_jdouble(td->getd()); 1419 return TypeLong::make( v.get_jlong() ); 1420 } 1421 1422 //------------------------------Value------------------------------------------ 1423 const Type* CountLeadingZerosINode::Value(PhaseTransform* phase) const { 1424 const Type* t = phase->type(in(1)); 1425 if (t == Type::TOP) return Type::TOP; 1426 const TypeInt* ti = t->isa_int(); 1427 if (ti && ti->is_con()) { 1428 jint i = ti->get_con(); 1429 // HD, Figure 5-6 1430 if (i == 0) 1431 return TypeInt::make(BitsPerInt); 1432 int n = 1; 1433 unsigned int x = i; 1434 if (x >> 16 == 0) { n += 16; x <<= 16; } 1435 if (x >> 24 == 0) { n += 8; x <<= 8; } 1436 if (x >> 28 == 0) { n += 4; x <<= 4; } 1437 if (x >> 30 == 0) { n += 2; x <<= 2; } 1438 n -= x >> 31; 1439 return TypeInt::make(n); 1440 } 1441 return TypeInt::INT; 1442 } 1443 1444 //------------------------------Value------------------------------------------ 1445 const Type* CountLeadingZerosLNode::Value(PhaseTransform* phase) const { 1446 const Type* t = phase->type(in(1)); 1447 if (t == Type::TOP) return Type::TOP; 1448 const TypeLong* tl = t->isa_long(); 1449 if (tl && tl->is_con()) { 1450 jlong l = tl->get_con(); 1451 // HD, Figure 5-6 1452 if (l == 0) 1453 return TypeInt::make(BitsPerLong); 1454 int n = 1; 1455 unsigned int x = (((julong) l) >> 32); 1456 if (x == 0) { n += 32; x = (int) l; } 1457 if (x >> 16 == 0) { n += 16; x <<= 16; } 1458 if (x >> 24 == 0) { n += 8; x <<= 8; } 1459 if (x >> 28 == 0) { n += 4; x <<= 4; } 1460 if (x >> 30 == 0) { n += 2; x <<= 2; } 1461 n -= x >> 31; 1462 return TypeInt::make(n); 1463 } 1464 return TypeInt::INT; 1465 } 1466 1467 //------------------------------Value------------------------------------------ 1468 const Type* CountTrailingZerosINode::Value(PhaseTransform* phase) const { 1469 const Type* t = phase->type(in(1)); 1470 if (t == Type::TOP) return Type::TOP; 1471 const TypeInt* ti = t->isa_int(); 1472 if (ti && ti->is_con()) { 1473 jint i = ti->get_con(); 1474 // HD, Figure 5-14 1475 int y; 1476 if (i == 0) 1477 return TypeInt::make(BitsPerInt); 1478 int n = 31; 1479 y = i << 16; if (y != 0) { n = n - 16; i = y; } 1480 y = i << 8; if (y != 0) { n = n - 8; i = y; } 1481 y = i << 4; if (y != 0) { n = n - 4; i = y; } 1482 y = i << 2; if (y != 0) { n = n - 2; i = y; } 1483 y = i << 1; if (y != 0) { n = n - 1; } 1484 return TypeInt::make(n); 1485 } 1486 return TypeInt::INT; 1487 } 1488 1489 //------------------------------Value------------------------------------------ 1490 const Type* CountTrailingZerosLNode::Value(PhaseTransform* phase) const { 1491 const Type* t = phase->type(in(1)); 1492 if (t == Type::TOP) return Type::TOP; 1493 const TypeLong* tl = t->isa_long(); 1494 if (tl && tl->is_con()) { 1495 jlong l = tl->get_con(); 1496 // HD, Figure 5-14 1497 int x, y; 1498 if (l == 0) 1499 return TypeInt::make(BitsPerLong); 1500 int n = 63; 1501 y = (int) l; if (y != 0) { n = n - 32; x = y; } else x = (((julong) l) >> 32); 1502 y = x << 16; if (y != 0) { n = n - 16; x = y; } 1503 y = x << 8; if (y != 0) { n = n - 8; x = y; } 1504 y = x << 4; if (y != 0) { n = n - 4; x = y; } 1505 y = x << 2; if (y != 0) { n = n - 2; x = y; } 1506 y = x << 1; if (y != 0) { n = n - 1; } 1507 return TypeInt::make(n); 1508 } 1509 return TypeInt::INT; 1510 }