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