1 /* 2 * Copyright (c) 2014, 2015, 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 "opto/addnode.hpp" 27 #include "opto/connode.hpp" 28 #include "opto/convertnode.hpp" 29 #include "opto/movenode.hpp" 30 #include "opto/phaseX.hpp" 31 #include "opto/subnode.hpp" 32 33 //============================================================================= 34 /* 35 The major change is for CMoveP and StrComp. They have related but slightly 36 different problems. They both take in TWO oops which are both null-checked 37 independently before the using Node. After CCP removes the CastPP's they need 38 to pick up the guarding test edge - in this case TWO control edges. I tried 39 various solutions, all have problems: 40 41 (1) Do nothing. This leads to a bug where we hoist a Load from a CMoveP or a 42 StrComp above a guarding null check. I've seen both cases in normal -Xcomp 43 testing. 44 45 (2) Plug the control edge from 1 of the 2 oops in. Apparent problem here is 46 to figure out which test post-dominates. The real problem is that it doesn't 47 matter which one you pick. After you pick up, the dominating-test elider in 48 IGVN can remove the test and allow you to hoist up to the dominating test on 49 the chosen oop bypassing the test on the not-chosen oop. Seen in testing. 50 Oops. 51 52 (3) Leave the CastPP's in. This makes the graph more accurate in some sense; 53 we get to keep around the knowledge that an oop is not-null after some test. 54 Alas, the CastPP's interfere with GVN (some values are the regular oop, some 55 are the CastPP of the oop, all merge at Phi's which cannot collapse, etc). 56 This cost us 10% on SpecJVM, even when I removed some of the more trivial 57 cases in the optimizer. Removing more useless Phi's started allowing Loads to 58 illegally float above null checks. I gave up on this approach. 59 60 (4) Add BOTH control edges to both tests. Alas, too much code knows that 61 control edges are in slot-zero ONLY. Many quick asserts fail; no way to do 62 this one. Note that I really want to allow the CMoveP to float and add both 63 control edges to the dependent Load op - meaning I can select early but I 64 cannot Load until I pass both tests. 65 66 (5) Do not hoist CMoveP and StrComp. To this end I added the v-call 67 depends_only_on_test(). No obvious performance loss on Spec, but we are 68 clearly conservative on CMoveP (also so on StrComp but that's unlikely to 69 matter ever). 70 71 */ 72 73 74 //------------------------------Ideal------------------------------------------ 75 // Return a node which is more "ideal" than the current node. 76 // Move constants to the right. 77 Node *CMoveNode::Ideal(PhaseGVN *phase, bool can_reshape) { 78 if( in(0) && remove_dead_region(phase, can_reshape) ) return this; 79 // Don't bother trying to transform a dead node 80 if( in(0) && in(0)->is_top() ) return NULL; 81 assert( !phase->eqv(in(Condition), this) && 82 !phase->eqv(in(IfFalse), this) && 83 !phase->eqv(in(IfTrue), this), "dead loop in CMoveNode::Ideal" ); 84 if( phase->type(in(Condition)) == Type::TOP ) 85 return NULL; // return NULL when Condition is dead 86 87 if( in(IfFalse)->is_Con() && !in(IfTrue)->is_Con() ) { 88 if( in(Condition)->is_Bool() ) { 89 BoolNode* b = in(Condition)->as_Bool(); 90 BoolNode* b2 = b->negate(phase); 91 return make(in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type); 92 } 93 } 94 return NULL; 95 } 96 97 //------------------------------is_cmove_id------------------------------------ 98 // Helper function to check for CMOVE identity. Shared with PhiNode::Identity 99 Node *CMoveNode::is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ) { 100 // Check for Cmp'ing and CMove'ing same values 101 if( (phase->eqv(cmp->in(1),f) && 102 phase->eqv(cmp->in(2),t)) || 103 // Swapped Cmp is OK 104 (phase->eqv(cmp->in(2),f) && 105 phase->eqv(cmp->in(1),t)) ) { 106 // Give up this identity check for floating points because it may choose incorrect 107 // value around 0.0 and -0.0 108 if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD ) 109 return NULL; 110 // Check for "(t==f)?t:f;" and replace with "f" 111 if( b->_test._test == BoolTest::eq ) 112 return f; 113 // Allow the inverted case as well 114 // Check for "(t!=f)?t:f;" and replace with "t" 115 if( b->_test._test == BoolTest::ne ) 116 return t; 117 } 118 return NULL; 119 } 120 121 //------------------------------Identity--------------------------------------- 122 // Conditional-move is an identity if both inputs are the same, or the test 123 // true or false. 124 Node *CMoveNode::Identity( PhaseTransform *phase ) { 125 if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs? 126 return in(IfFalse); // Then it doesn't matter 127 if( phase->type(in(Condition)) == TypeInt::ZERO ) 128 return in(IfFalse); // Always pick left(false) input 129 if( phase->type(in(Condition)) == TypeInt::ONE ) 130 return in(IfTrue); // Always pick right(true) input 131 132 // Check for CMove'ing a constant after comparing against the constant. 133 // Happens all the time now, since if we compare equality vs a constant in 134 // the parser, we "know" the variable is constant on one path and we force 135 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a 136 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more 137 // general in that we don't need constants. 138 if( in(Condition)->is_Bool() ) { 139 BoolNode *b = in(Condition)->as_Bool(); 140 Node *cmp = b->in(1); 141 if( cmp->is_Cmp() ) { 142 Node *id = is_cmove_id( phase, cmp, in(IfTrue), in(IfFalse), b ); 143 if( id ) return id; 144 } 145 } 146 147 return this; 148 } 149 150 //------------------------------Value------------------------------------------ 151 // Result is the meet of inputs 152 const Type *CMoveNode::Value( PhaseTransform *phase ) const { 153 if( phase->type(in(Condition)) == Type::TOP ) 154 return Type::TOP; 155 return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue))); 156 } 157 158 //------------------------------make------------------------------------------- 159 // Make a correctly-flavored CMove. Since _type is directly determined 160 // from the inputs we do not need to specify it here. 161 CMoveNode *CMoveNode::make(Node *c, Node *bol, Node *left, Node *right, const Type *t) { 162 switch( t->basic_type() ) { 163 case T_INT: return new CMoveINode( bol, left, right, t->is_int() ); 164 case T_FLOAT: return new CMoveFNode( bol, left, right, t ); 165 case T_DOUBLE: return new CMoveDNode( bol, left, right, t ); 166 case T_LONG: return new CMoveLNode( bol, left, right, t->is_long() ); 167 case T_OBJECT: return new CMovePNode( c, bol, left, right, t->is_oopptr() ); 168 case T_ADDRESS: return new CMovePNode( c, bol, left, right, t->is_ptr() ); 169 case T_NARROWOOP: return new CMoveNNode( c, bol, left, right, t ); 170 default: 171 ShouldNotReachHere(); 172 return NULL; 173 } 174 } 175 176 //============================================================================= 177 //------------------------------Ideal------------------------------------------ 178 // Return a node which is more "ideal" than the current node. 179 // Check for conversions to boolean 180 Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) { 181 // Try generic ideal's first 182 Node *x = CMoveNode::Ideal(phase, can_reshape); 183 if( x ) return x; 184 185 // If zero is on the left (false-case, no-move-case) it must mean another 186 // constant is on the right (otherwise the shared CMove::Ideal code would 187 // have moved the constant to the right). This situation is bad for Intel 188 // and a don't-care for Sparc. It's bad for Intel because the zero has to 189 // be manifested in a register with a XOR which kills flags, which are live 190 // on input to the CMoveI, leading to a situation which causes excessive 191 // spilling on Intel. For Sparc, if the zero in on the left the Sparc will 192 // zero a register via G0 and conditionally-move the other constant. If the 193 // zero is on the right, the Sparc will load the first constant with a 194 // 13-bit set-lo and conditionally move G0. See bug 4677505. 195 if( phase->type(in(IfFalse)) == TypeInt::ZERO && !(phase->type(in(IfTrue)) == TypeInt::ZERO) ) { 196 if( in(Condition)->is_Bool() ) { 197 BoolNode* b = in(Condition)->as_Bool(); 198 BoolNode* b2 = b->negate(phase); 199 return make(in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type); 200 } 201 } 202 203 // Now check for booleans 204 int flip = 0; 205 206 // Check for picking from zero/one 207 if( phase->type(in(IfFalse)) == TypeInt::ZERO && phase->type(in(IfTrue)) == TypeInt::ONE ) { 208 flip = 1 - flip; 209 } else if( phase->type(in(IfFalse)) == TypeInt::ONE && phase->type(in(IfTrue)) == TypeInt::ZERO ) { 210 } else return NULL; 211 212 // Check for eq/ne test 213 if( !in(1)->is_Bool() ) return NULL; 214 BoolNode *bol = in(1)->as_Bool(); 215 if( bol->_test._test == BoolTest::eq ) { 216 } else if( bol->_test._test == BoolTest::ne ) { 217 flip = 1-flip; 218 } else return NULL; 219 220 // Check for vs 0 or 1 221 if( !bol->in(1)->is_Cmp() ) return NULL; 222 const CmpNode *cmp = bol->in(1)->as_Cmp(); 223 if( phase->type(cmp->in(2)) == TypeInt::ZERO ) { 224 } else if( phase->type(cmp->in(2)) == TypeInt::ONE ) { 225 // Allow cmp-vs-1 if the other input is bounded by 0-1 226 if( phase->type(cmp->in(1)) != TypeInt::BOOL ) 227 return NULL; 228 flip = 1 - flip; 229 } else return NULL; 230 231 // Convert to a bool (flipped) 232 // Build int->bool conversion 233 if (PrintOpto) { tty->print_cr("CMOV to I2B"); } 234 Node *n = new Conv2BNode( cmp->in(1) ); 235 if( flip ) 236 n = new XorINode( phase->transform(n), phase->intcon(1) ); 237 238 return n; 239 } 240 241 //============================================================================= 242 //------------------------------Ideal------------------------------------------ 243 // Return a node which is more "ideal" than the current node. 244 // Check for absolute value 245 Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) { 246 // Try generic ideal's first 247 Node *x = CMoveNode::Ideal(phase, can_reshape); 248 if( x ) return x; 249 250 int cmp_zero_idx = 0; // Index of compare input where to look for zero 251 int phi_x_idx = 0; // Index of phi input where to find naked x 252 253 // Find the Bool 254 if( !in(1)->is_Bool() ) return NULL; 255 BoolNode *bol = in(1)->as_Bool(); 256 // Check bool sense 257 switch( bol->_test._test ) { 258 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break; 259 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break; 260 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break; 261 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break; 262 default: return NULL; break; 263 } 264 265 // Find zero input of CmpF; the other input is being abs'd 266 Node *cmpf = bol->in(1); 267 if( cmpf->Opcode() != Op_CmpF ) return NULL; 268 Node *X = NULL; 269 bool flip = false; 270 if( phase->type(cmpf->in(cmp_zero_idx)) == TypeF::ZERO ) { 271 X = cmpf->in(3 - cmp_zero_idx); 272 } else if (phase->type(cmpf->in(3 - cmp_zero_idx)) == TypeF::ZERO) { 273 // The test is inverted, we should invert the result... 274 X = cmpf->in(cmp_zero_idx); 275 flip = true; 276 } else { 277 return NULL; 278 } 279 280 // If X is found on the appropriate phi input, find the subtract on the other 281 if( X != in(phi_x_idx) ) return NULL; 282 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue; 283 Node *sub = in(phi_sub_idx); 284 285 // Allow only SubF(0,X) and fail out for all others; NegF is not OK 286 if( sub->Opcode() != Op_SubF || 287 sub->in(2) != X || 288 phase->type(sub->in(1)) != TypeF::ZERO ) return NULL; 289 290 Node *abs = new AbsFNode( X ); 291 if( flip ) 292 abs = new SubFNode(sub->in(1), phase->transform(abs)); 293 294 return abs; 295 } 296 297 //============================================================================= 298 //------------------------------Ideal------------------------------------------ 299 // Return a node which is more "ideal" than the current node. 300 // Check for absolute value 301 Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) { 302 // Try generic ideal's first 303 Node *x = CMoveNode::Ideal(phase, can_reshape); 304 if( x ) return x; 305 306 int cmp_zero_idx = 0; // Index of compare input where to look for zero 307 int phi_x_idx = 0; // Index of phi input where to find naked x 308 309 // Find the Bool 310 if( !in(1)->is_Bool() ) return NULL; 311 BoolNode *bol = in(1)->as_Bool(); 312 // Check bool sense 313 switch( bol->_test._test ) { 314 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break; 315 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break; 316 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break; 317 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break; 318 default: return NULL; break; 319 } 320 321 // Find zero input of CmpD; the other input is being abs'd 322 Node *cmpd = bol->in(1); 323 if( cmpd->Opcode() != Op_CmpD ) return NULL; 324 Node *X = NULL; 325 bool flip = false; 326 if( phase->type(cmpd->in(cmp_zero_idx)) == TypeD::ZERO ) { 327 X = cmpd->in(3 - cmp_zero_idx); 328 } else if (phase->type(cmpd->in(3 - cmp_zero_idx)) == TypeD::ZERO) { 329 // The test is inverted, we should invert the result... 330 X = cmpd->in(cmp_zero_idx); 331 flip = true; 332 } else { 333 return NULL; 334 } 335 336 // If X is found on the appropriate phi input, find the subtract on the other 337 if( X != in(phi_x_idx) ) return NULL; 338 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue; 339 Node *sub = in(phi_sub_idx); 340 341 // Allow only SubD(0,X) and fail out for all others; NegD is not OK 342 if( sub->Opcode() != Op_SubD || 343 sub->in(2) != X || 344 phase->type(sub->in(1)) != TypeD::ZERO ) return NULL; 345 346 Node *abs = new AbsDNode( X ); 347 if( flip ) 348 abs = new SubDNode(sub->in(1), phase->transform(abs)); 349 350 return abs; 351 } 352 353 //------------------------------Value------------------------------------------ 354 const Type *MoveL2DNode::Value( PhaseTransform *phase ) const { 355 const Type *t = phase->type( in(1) ); 356 if( t == Type::TOP ) return Type::TOP; 357 const TypeLong *tl = t->is_long(); 358 if( !tl->is_con() ) return bottom_type(); 359 JavaValue v; 360 v.set_jlong(tl->get_con()); 361 return TypeD::make( v.get_jdouble() ); 362 } 363 364 //------------------------------Value------------------------------------------ 365 const Type *MoveI2FNode::Value( PhaseTransform *phase ) const { 366 const Type *t = phase->type( in(1) ); 367 if( t == Type::TOP ) return Type::TOP; 368 const TypeInt *ti = t->is_int(); 369 if( !ti->is_con() ) return bottom_type(); 370 JavaValue v; 371 v.set_jint(ti->get_con()); 372 return TypeF::make( v.get_jfloat() ); 373 } 374 375 //------------------------------Value------------------------------------------ 376 const Type *MoveF2INode::Value( PhaseTransform *phase ) const { 377 const Type *t = phase->type( in(1) ); 378 if( t == Type::TOP ) return Type::TOP; 379 if( t == Type::FLOAT ) return TypeInt::INT; 380 const TypeF *tf = t->is_float_constant(); 381 JavaValue v; 382 v.set_jfloat(tf->getf()); 383 return TypeInt::make( v.get_jint() ); 384 } 385 386 //------------------------------Value------------------------------------------ 387 const Type *MoveD2LNode::Value( PhaseTransform *phase ) const { 388 const Type *t = phase->type( in(1) ); 389 if( t == Type::TOP ) return Type::TOP; 390 if( t == Type::DOUBLE ) return TypeLong::LONG; 391 const TypeD *td = t->is_double_constant(); 392 JavaValue v; 393 v.set_jdouble(td->getd()); 394 return TypeLong::make( v.get_jlong() ); 395 } 396 397 #ifndef PRODUCT 398 //----------------------------BinaryNode--------------------------------------- 399 // The set of related nodes for a BinaryNode is all data inputs and all outputs 400 // till level 2 (i.e., one beyond the associated CMoveNode). In compact mode, 401 // it's the inputs till level 1 and the outputs till level 2. 402 void BinaryNode::related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const { 403 if (compact) { 404 this->collect_nodes(in_rel, 1, false, true); 405 } else { 406 this->collect_nodes_in_all_data(in_rel, false); 407 } 408 this->collect_nodes(out_rel, -2, false, false); 409 } 410 #endif