Mercurial > hg > truffle
annotate src/share/vm/opto/cfgnode.cpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | 8c57262447d3 |
| children | 35acf8f0a2e4 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1543
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1543
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1543
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "memory/allocation.inline.hpp" | |
| 28 #include "oops/objArrayKlass.hpp" | |
| 29 #include "opto/addnode.hpp" | |
| 30 #include "opto/cfgnode.hpp" | |
| 31 #include "opto/connode.hpp" | |
| 32 #include "opto/loopnode.hpp" | |
| 33 #include "opto/machnode.hpp" | |
| 34 #include "opto/mulnode.hpp" | |
| 35 #include "opto/phaseX.hpp" | |
| 36 #include "opto/regmask.hpp" | |
| 37 #include "opto/runtime.hpp" | |
| 38 #include "opto/subnode.hpp" | |
| 39 | |
| 0 | 40 // Portions of code courtesy of Clifford Click |
| 41 | |
| 42 // Optimization - Graph Style | |
| 43 | |
| 44 //============================================================================= | |
| 45 //------------------------------Value------------------------------------------ | |
| 46 // Compute the type of the RegionNode. | |
| 47 const Type *RegionNode::Value( PhaseTransform *phase ) const { | |
| 48 for( uint i=1; i<req(); ++i ) { // For all paths in | |
| 49 Node *n = in(i); // Get Control source | |
| 50 if( !n ) continue; // Missing inputs are TOP | |
| 51 if( phase->type(n) == Type::CONTROL ) | |
| 52 return Type::CONTROL; | |
| 53 } | |
| 54 return Type::TOP; // All paths dead? Then so are we | |
| 55 } | |
| 56 | |
| 57 //------------------------------Identity--------------------------------------- | |
| 58 // Check for Region being Identity. | |
| 59 Node *RegionNode::Identity( PhaseTransform *phase ) { | |
| 60 // Cannot have Region be an identity, even if it has only 1 input. | |
| 61 // Phi users cannot have their Region input folded away for them, | |
| 62 // since they need to select the proper data input | |
| 63 return this; | |
| 64 } | |
| 65 | |
| 66 //------------------------------merge_region----------------------------------- | |
| 67 // If a Region flows into a Region, merge into one big happy merge. This is | |
| 68 // hard to do if there is stuff that has to happen | |
| 69 static Node *merge_region(RegionNode *region, PhaseGVN *phase) { | |
| 70 if( region->Opcode() != Op_Region ) // Do not do to LoopNodes | |
| 71 return NULL; | |
| 72 Node *progress = NULL; // Progress flag | |
| 73 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 74 | |
| 75 uint rreq = region->req(); | |
| 76 for( uint i = 1; i < rreq; i++ ) { | |
| 77 Node *r = region->in(i); | |
| 78 if( r && r->Opcode() == Op_Region && // Found a region? | |
| 79 r->in(0) == r && // Not already collapsed? | |
| 80 r != region && // Avoid stupid situations | |
| 81 r->outcnt() == 2 ) { // Self user and 'region' user only? | |
| 82 assert(!r->as_Region()->has_phi(), "no phi users"); | |
| 83 if( !progress ) { // No progress | |
| 84 if (region->has_phi()) { | |
| 85 return NULL; // Only flatten if no Phi users | |
| 86 // igvn->hash_delete( phi ); | |
| 87 } | |
| 88 igvn->hash_delete( region ); | |
| 89 progress = region; // Making progress | |
| 90 } | |
| 91 igvn->hash_delete( r ); | |
| 92 | |
| 93 // Append inputs to 'r' onto 'region' | |
| 94 for( uint j = 1; j < r->req(); j++ ) { | |
| 95 // Move an input from 'r' to 'region' | |
| 96 region->add_req(r->in(j)); | |
| 97 r->set_req(j, phase->C->top()); | |
| 98 // Update phis of 'region' | |
| 99 //for( uint k = 0; k < max; k++ ) { | |
| 100 // Node *phi = region->out(k); | |
| 101 // if( phi->is_Phi() ) { | |
| 102 // phi->add_req(phi->in(i)); | |
| 103 // } | |
| 104 //} | |
| 105 | |
| 106 rreq++; // One more input to Region | |
| 107 } // Found a region to merge into Region | |
| 108 // Clobber pointer to the now dead 'r' | |
| 109 region->set_req(i, phase->C->top()); | |
| 110 } | |
| 111 } | |
| 112 | |
| 113 return progress; | |
| 114 } | |
| 115 | |
| 116 | |
| 117 | |
| 118 //--------------------------------has_phi-------------------------------------- | |
| 119 // Helper function: Return any PhiNode that uses this region or NULL | |
| 120 PhiNode* RegionNode::has_phi() const { | |
| 121 for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { | |
| 122 Node* phi = fast_out(i); | |
| 123 if (phi->is_Phi()) { // Check for Phi users | |
| 124 assert(phi->in(0) == (Node*)this, "phi uses region only via in(0)"); | |
| 125 return phi->as_Phi(); // this one is good enough | |
| 126 } | |
| 127 } | |
| 128 | |
| 129 return NULL; | |
| 130 } | |
| 131 | |
| 132 | |
| 133 //-----------------------------has_unique_phi---------------------------------- | |
| 134 // Helper function: Return the only PhiNode that uses this region or NULL | |
| 135 PhiNode* RegionNode::has_unique_phi() const { | |
| 136 // Check that only one use is a Phi | |
| 137 PhiNode* only_phi = NULL; | |
| 138 for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { | |
| 139 Node* phi = fast_out(i); | |
| 140 if (phi->is_Phi()) { // Check for Phi users | |
| 141 assert(phi->in(0) == (Node*)this, "phi uses region only via in(0)"); | |
| 142 if (only_phi == NULL) { | |
| 143 only_phi = phi->as_Phi(); | |
| 144 } else { | |
| 145 return NULL; // multiple phis | |
| 146 } | |
| 147 } | |
| 148 } | |
| 149 | |
| 150 return only_phi; | |
| 151 } | |
| 152 | |
| 153 | |
| 154 //------------------------------check_phi_clipping----------------------------- | |
| 155 // Helper function for RegionNode's identification of FP clipping | |
| 156 // Check inputs to the Phi | |
| 157 static bool check_phi_clipping( PhiNode *phi, ConNode * &min, uint &min_idx, ConNode * &max, uint &max_idx, Node * &val, uint &val_idx ) { | |
| 158 min = NULL; | |
| 159 max = NULL; | |
| 160 val = NULL; | |
| 161 min_idx = 0; | |
| 162 max_idx = 0; | |
| 163 val_idx = 0; | |
| 164 uint phi_max = phi->req(); | |
| 165 if( phi_max == 4 ) { | |
| 166 for( uint j = 1; j < phi_max; ++j ) { | |
| 167 Node *n = phi->in(j); | |
| 168 int opcode = n->Opcode(); | |
| 169 switch( opcode ) { | |
| 170 case Op_ConI: | |
| 171 { | |
| 172 if( min == NULL ) { | |
| 173 min = n->Opcode() == Op_ConI ? (ConNode*)n : NULL; | |
| 174 min_idx = j; | |
| 175 } else { | |
| 176 max = n->Opcode() == Op_ConI ? (ConNode*)n : NULL; | |
| 177 max_idx = j; | |
| 178 if( min->get_int() > max->get_int() ) { | |
| 179 // Swap min and max | |
| 180 ConNode *temp; | |
| 181 uint temp_idx; | |
| 182 temp = min; min = max; max = temp; | |
| 183 temp_idx = min_idx; min_idx = max_idx; max_idx = temp_idx; | |
| 184 } | |
| 185 } | |
| 186 } | |
| 187 break; | |
| 188 default: | |
| 189 { | |
| 190 val = n; | |
| 191 val_idx = j; | |
| 192 } | |
| 193 break; | |
| 194 } | |
| 195 } | |
| 196 } | |
| 197 return ( min && max && val && (min->get_int() <= 0) && (max->get_int() >=0) ); | |
| 198 } | |
| 199 | |
| 200 | |
| 201 //------------------------------check_if_clipping------------------------------ | |
| 202 // Helper function for RegionNode's identification of FP clipping | |
| 203 // Check that inputs to Region come from two IfNodes, | |
| 204 // | |
| 205 // If | |
| 206 // False True | |
| 207 // If | | |
| 208 // False True | | |
| 209 // | | | | |
| 210 // RegionNode_inputs | |
| 211 // | |
| 212 static bool check_if_clipping( const RegionNode *region, IfNode * &bot_if, IfNode * &top_if ) { | |
| 213 top_if = NULL; | |
| 214 bot_if = NULL; | |
| 215 | |
| 216 // Check control structure above RegionNode for (if ( if ) ) | |
| 217 Node *in1 = region->in(1); | |
| 218 Node *in2 = region->in(2); | |
| 219 Node *in3 = region->in(3); | |
| 220 // Check that all inputs are projections | |
| 221 if( in1->is_Proj() && in2->is_Proj() && in3->is_Proj() ) { | |
| 222 Node *in10 = in1->in(0); | |
| 223 Node *in20 = in2->in(0); | |
| 224 Node *in30 = in3->in(0); | |
| 225 // Check that #1 and #2 are ifTrue and ifFalse from same If | |
| 226 if( in10 != NULL && in10->is_If() && | |
| 227 in20 != NULL && in20->is_If() && | |
| 228 in30 != NULL && in30->is_If() && in10 == in20 && | |
| 229 (in1->Opcode() != in2->Opcode()) ) { | |
| 230 Node *in100 = in10->in(0); | |
| 231 Node *in1000 = (in100 != NULL && in100->is_Proj()) ? in100->in(0) : NULL; | |
| 232 // Check that control for in10 comes from other branch of IF from in3 | |
| 233 if( in1000 != NULL && in1000->is_If() && | |
| 234 in30 == in1000 && (in3->Opcode() != in100->Opcode()) ) { | |
| 235 // Control pattern checks | |
| 236 top_if = (IfNode*)in1000; | |
| 237 bot_if = (IfNode*)in10; | |
| 238 } | |
| 239 } | |
| 240 } | |
| 241 | |
| 242 return (top_if != NULL); | |
| 243 } | |
| 244 | |
| 245 | |
| 246 //------------------------------check_convf2i_clipping------------------------- | |
| 247 // Helper function for RegionNode's identification of FP clipping | |
| 248 // Verify that the value input to the phi comes from "ConvF2I; LShift; RShift" | |
| 249 static bool check_convf2i_clipping( PhiNode *phi, uint idx, ConvF2INode * &convf2i, Node *min, Node *max) { | |
| 250 convf2i = NULL; | |
| 251 | |
| 252 // Check for the RShiftNode | |
| 253 Node *rshift = phi->in(idx); | |
| 254 assert( rshift, "Previous checks ensure phi input is present"); | |
| 255 if( rshift->Opcode() != Op_RShiftI ) { return false; } | |
| 256 | |
| 257 // Check for the LShiftNode | |
| 258 Node *lshift = rshift->in(1); | |
| 259 assert( lshift, "Previous checks ensure phi input is present"); | |
| 260 if( lshift->Opcode() != Op_LShiftI ) { return false; } | |
| 261 | |
| 262 // Check for the ConvF2INode | |
| 263 Node *conv = lshift->in(1); | |
| 264 if( conv->Opcode() != Op_ConvF2I ) { return false; } | |
| 265 | |
| 266 // Check that shift amounts are only to get sign bits set after F2I | |
| 267 jint max_cutoff = max->get_int(); | |
| 268 jint min_cutoff = min->get_int(); | |
| 269 jint left_shift = lshift->in(2)->get_int(); | |
| 270 jint right_shift = rshift->in(2)->get_int(); | |
| 271 jint max_post_shift = nth_bit(BitsPerJavaInteger - left_shift - 1); | |
| 272 if( left_shift != right_shift || | |
| 273 0 > left_shift || left_shift >= BitsPerJavaInteger || | |
| 274 max_post_shift < max_cutoff || | |
| 275 max_post_shift < -min_cutoff ) { | |
| 276 // Shifts are necessary but current transformation eliminates them | |
| 277 return false; | |
| 278 } | |
| 279 | |
| 280 // OK to return the result of ConvF2I without shifting | |
| 281 convf2i = (ConvF2INode*)conv; | |
| 282 return true; | |
| 283 } | |
| 284 | |
| 285 | |
| 286 //------------------------------check_compare_clipping------------------------- | |
| 287 // Helper function for RegionNode's identification of FP clipping | |
| 288 static bool check_compare_clipping( bool less_than, IfNode *iff, ConNode *limit, Node * & input ) { | |
| 289 Node *i1 = iff->in(1); | |
| 290 if ( !i1->is_Bool() ) { return false; } | |
| 291 BoolNode *bool1 = i1->as_Bool(); | |
| 292 if( less_than && bool1->_test._test != BoolTest::le ) { return false; } | |
| 293 else if( !less_than && bool1->_test._test != BoolTest::lt ) { return false; } | |
| 294 const Node *cmpF = bool1->in(1); | |
| 295 if( cmpF->Opcode() != Op_CmpF ) { return false; } | |
| 296 // Test that the float value being compared against | |
| 297 // is equivalent to the int value used as a limit | |
| 298 Node *nodef = cmpF->in(2); | |
| 299 if( nodef->Opcode() != Op_ConF ) { return false; } | |
| 300 jfloat conf = nodef->getf(); | |
| 301 jint coni = limit->get_int(); | |
| 302 if( ((int)conf) != coni ) { return false; } | |
| 303 input = cmpF->in(1); | |
| 304 return true; | |
| 305 } | |
| 306 | |
| 307 //------------------------------is_unreachable_region-------------------------- | |
| 308 // Find if the Region node is reachable from the root. | |
| 309 bool RegionNode::is_unreachable_region(PhaseGVN *phase) const { | |
| 310 assert(req() == 2, ""); | |
| 311 | |
| 312 // First, cut the simple case of fallthrough region when NONE of | |
| 313 // region's phis references itself directly or through a data node. | |
| 314 uint max = outcnt(); | |
| 315 uint i; | |
| 316 for (i = 0; i < max; i++) { | |
| 317 Node* phi = raw_out(i); | |
| 318 if (phi != NULL && phi->is_Phi()) { | |
| 319 assert(phase->eqv(phi->in(0), this) && phi->req() == 2, ""); | |
| 320 if (phi->outcnt() == 0) | |
| 321 continue; // Safe case - no loops | |
| 322 if (phi->outcnt() == 1) { | |
| 323 Node* u = phi->raw_out(0); | |
| 324 // Skip if only one use is an other Phi or Call or Uncommon trap. | |
| 325 // It is safe to consider this case as fallthrough. | |
| 326 if (u != NULL && (u->is_Phi() || u->is_CFG())) | |
| 327 continue; | |
| 328 } | |
| 329 // Check when phi references itself directly or through an other node. | |
| 330 if (phi->as_Phi()->simple_data_loop_check(phi->in(1)) >= PhiNode::Unsafe) | |
| 331 break; // Found possible unsafe data loop. | |
| 332 } | |
| 333 } | |
| 334 if (i >= max) | |
| 335 return false; // An unsafe case was NOT found - don't need graph walk. | |
| 336 | |
| 337 // Unsafe case - check if the Region node is reachable from root. | |
| 338 ResourceMark rm; | |
| 339 | |
| 340 Arena *a = Thread::current()->resource_area(); | |
| 341 Node_List nstack(a); | |
| 342 VectorSet visited(a); | |
| 343 | |
| 344 // Mark all control nodes reachable from root outputs | |
| 345 Node *n = (Node*)phase->C->root(); | |
| 346 nstack.push(n); | |
| 347 visited.set(n->_idx); | |
| 348 while (nstack.size() != 0) { | |
| 349 n = nstack.pop(); | |
| 350 uint max = n->outcnt(); | |
| 351 for (uint i = 0; i < max; i++) { | |
| 352 Node* m = n->raw_out(i); | |
| 353 if (m != NULL && m->is_CFG()) { | |
| 354 if (phase->eqv(m, this)) { | |
| 355 return false; // We reached the Region node - it is not dead. | |
| 356 } | |
| 357 if (!visited.test_set(m->_idx)) | |
| 358 nstack.push(m); | |
| 359 } | |
| 360 } | |
| 361 } | |
| 362 | |
| 363 return true; // The Region node is unreachable - it is dead. | |
| 364 } | |
| 365 | |
| 366 //------------------------------Ideal------------------------------------------ | |
| 367 // Return a node which is more "ideal" than the current node. Must preserve | |
| 368 // the CFG, but we can still strip out dead paths. | |
| 369 Node *RegionNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 370 if( !can_reshape && !in(0) ) return NULL; // Already degraded to a Copy | |
| 371 assert(!in(0) || !in(0)->is_Root(), "not a specially hidden merge"); | |
| 372 | |
| 373 // Check for RegionNode with no Phi users and both inputs come from either | |
| 374 // arm of the same IF. If found, then the control-flow split is useless. | |
| 375 bool has_phis = false; | |
| 376 if (can_reshape) { // Need DU info to check for Phi users | |
| 377 has_phis = (has_phi() != NULL); // Cache result | |
| 378 if (!has_phis) { // No Phi users? Nothing merging? | |
| 379 for (uint i = 1; i < req()-1; i++) { | |
| 380 Node *if1 = in(i); | |
| 381 if( !if1 ) continue; | |
| 382 Node *iff = if1->in(0); | |
| 383 if( !iff || !iff->is_If() ) continue; | |
| 384 for( uint j=i+1; j<req(); j++ ) { | |
| 385 if( in(j) && in(j)->in(0) == iff && | |
| 386 if1->Opcode() != in(j)->Opcode() ) { | |
| 387 // Add the IF Projections to the worklist. They (and the IF itself) | |
| 388 // will be eliminated if dead. | |
| 389 phase->is_IterGVN()->add_users_to_worklist(iff); | |
| 390 set_req(i, iff->in(0));// Skip around the useless IF diamond | |
| 391 set_req(j, NULL); | |
| 392 return this; // Record progress | |
| 393 } | |
| 394 } | |
| 395 } | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 // Remove TOP or NULL input paths. If only 1 input path remains, this Region | |
| 400 // degrades to a copy. | |
| 401 bool add_to_worklist = false; | |
| 402 int cnt = 0; // Count of values merging | |
| 403 DEBUG_ONLY( int cnt_orig = req(); ) // Save original inputs count | |
| 404 int del_it = 0; // The last input path we delete | |
| 405 // For all inputs... | |
| 406 for( uint i=1; i<req(); ++i ){// For all paths in | |
| 407 Node *n = in(i); // Get the input | |
| 408 if( n != NULL ) { | |
| 409 // Remove useless control copy inputs | |
| 410 if( n->is_Region() && n->as_Region()->is_copy() ) { | |
| 411 set_req(i, n->nonnull_req()); | |
| 412 i--; | |
| 413 continue; | |
| 414 } | |
| 415 if( n->is_Proj() ) { // Remove useless rethrows | |
| 416 Node *call = n->in(0); | |
| 417 if (call->is_Call() && call->as_Call()->entry_point() == OptoRuntime::rethrow_stub()) { | |
| 418 set_req(i, call->in(0)); | |
| 419 i--; | |
| 420 continue; | |
| 421 } | |
| 422 } | |
| 423 if( phase->type(n) == Type::TOP ) { | |
| 424 set_req(i, NULL); // Ignore TOP inputs | |
| 425 i--; | |
| 426 continue; | |
| 427 } | |
| 428 cnt++; // One more value merging | |
| 429 | |
| 430 } else if (can_reshape) { // Else found dead path with DU info | |
| 431 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 432 del_req(i); // Yank path from self | |
| 433 del_it = i; | |
| 434 uint max = outcnt(); | |
| 435 DUIterator j; | |
| 436 bool progress = true; | |
| 437 while(progress) { // Need to establish property over all users | |
| 438 progress = false; | |
| 439 for (j = outs(); has_out(j); j++) { | |
| 440 Node *n = out(j); | |
| 441 if( n->req() != req() && n->is_Phi() ) { | |
| 442 assert( n->in(0) == this, "" ); | |
| 443 igvn->hash_delete(n); // Yank from hash before hacking edges | |
| 444 n->set_req_X(i,NULL,igvn);// Correct DU info | |
| 445 n->del_req(i); // Yank path from Phis | |
| 446 if( max != outcnt() ) { | |
| 447 progress = true; | |
| 448 j = refresh_out_pos(j); | |
| 449 max = outcnt(); | |
| 450 } | |
| 451 } | |
| 452 } | |
| 453 } | |
| 454 add_to_worklist = true; | |
| 455 i--; | |
| 456 } | |
| 457 } | |
| 458 | |
| 459 if (can_reshape && cnt == 1) { | |
| 460 // Is it dead loop? | |
| 461 // If it is LoopNopde it had 2 (+1 itself) inputs and | |
| 462 // one of them was cut. The loop is dead if it was EntryContol. | |
| 4113 | 463 // Loop node may have only one input because entry path |
| 464 // is removed in PhaseIdealLoop::Dominators(). | |
| 465 assert(!this->is_Loop() || cnt_orig <= 3, "Loop node should have 3 or less inputs"); | |
| 466 if (this->is_Loop() && (del_it == LoopNode::EntryControl || | |
| 467 del_it == 0 && is_unreachable_region(phase)) || | |
| 0 | 468 !this->is_Loop() && has_phis && is_unreachable_region(phase)) { |
| 469 // Yes, the region will be removed during the next step below. | |
| 470 // Cut the backedge input and remove phis since no data paths left. | |
| 471 // We don't cut outputs to other nodes here since we need to put them | |
| 472 // on the worklist. | |
| 473 del_req(1); | |
| 474 cnt = 0; | |
| 475 assert( req() == 1, "no more inputs expected" ); | |
| 476 uint max = outcnt(); | |
| 477 bool progress = true; | |
| 478 Node *top = phase->C->top(); | |
| 479 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 480 DUIterator j; | |
| 481 while(progress) { | |
| 482 progress = false; | |
| 483 for (j = outs(); has_out(j); j++) { | |
| 484 Node *n = out(j); | |
| 485 if( n->is_Phi() ) { | |
| 486 assert( igvn->eqv(n->in(0), this), "" ); | |
| 487 assert( n->req() == 2 && n->in(1) != NULL, "Only one data input expected" ); | |
| 488 // Break dead loop data path. | |
| 489 // Eagerly replace phis with top to avoid phis copies generation. | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
490 igvn->replace_node(n, top); |
| 0 | 491 if( max != outcnt() ) { |
| 492 progress = true; | |
| 493 j = refresh_out_pos(j); | |
| 494 max = outcnt(); | |
| 495 } | |
| 496 } | |
| 497 } | |
| 498 } | |
| 499 add_to_worklist = true; | |
| 500 } | |
| 501 } | |
| 502 if (add_to_worklist) { | |
| 503 phase->is_IterGVN()->add_users_to_worklist(this); // Revisit collapsed Phis | |
| 504 } | |
| 505 | |
| 506 if( cnt <= 1 ) { // Only 1 path in? | |
| 507 set_req(0, NULL); // Null control input for region copy | |
| 508 if( cnt == 0 && !can_reshape) { // Parse phase - leave the node as it is. | |
| 509 // No inputs or all inputs are NULL. | |
| 510 return NULL; | |
| 511 } else if (can_reshape) { // Optimization phase - remove the node | |
| 512 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 513 Node *parent_ctrl; | |
| 514 if( cnt == 0 ) { | |
| 515 assert( req() == 1, "no inputs expected" ); | |
| 516 // During IGVN phase such region will be subsumed by TOP node | |
| 517 // so region's phis will have TOP as control node. | |
| 518 // Kill phis here to avoid it. PhiNode::is_copy() will be always false. | |
| 519 // Also set other user's input to top. | |
| 520 parent_ctrl = phase->C->top(); | |
| 521 } else { | |
| 522 // The fallthrough case since we already checked dead loops above. | |
| 523 parent_ctrl = in(1); | |
| 524 assert(parent_ctrl != NULL, "Region is a copy of some non-null control"); | |
| 525 assert(!igvn->eqv(parent_ctrl, this), "Close dead loop"); | |
| 526 } | |
| 527 if (!add_to_worklist) | |
| 528 igvn->add_users_to_worklist(this); // Check for further allowed opts | |
| 529 for (DUIterator_Last imin, i = last_outs(imin); i >= imin; --i) { | |
| 530 Node* n = last_out(i); | |
| 531 igvn->hash_delete(n); // Remove from worklist before modifying edges | |
| 532 if( n->is_Phi() ) { // Collapse all Phis | |
| 533 // Eagerly replace phis to avoid copies generation. | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
534 Node* in; |
| 0 | 535 if( cnt == 0 ) { |
| 536 assert( n->req() == 1, "No data inputs expected" ); | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
537 in = parent_ctrl; // replaced by top |
| 0 | 538 } else { |
| 539 assert( n->req() == 2 && n->in(1) != NULL, "Only one data input expected" ); | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
540 in = n->in(1); // replaced by unique input |
|
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
541 if( n->as_Phi()->is_unsafe_data_reference(in) ) |
|
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
542 in = phase->C->top(); // replaced by top |
| 0 | 543 } |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
544 igvn->replace_node(n, in); |
| 0 | 545 } |
| 546 else if( n->is_Region() ) { // Update all incoming edges | |
| 547 assert( !igvn->eqv(n, this), "Must be removed from DefUse edges"); | |
| 548 uint uses_found = 0; | |
| 549 for( uint k=1; k < n->req(); k++ ) { | |
| 550 if( n->in(k) == this ) { | |
| 551 n->set_req(k, parent_ctrl); | |
| 552 uses_found++; | |
| 553 } | |
| 554 } | |
| 555 if( uses_found > 1 ) { // (--i) done at the end of the loop. | |
| 556 i -= (uses_found - 1); | |
| 557 } | |
| 558 } | |
| 559 else { | |
| 560 assert( igvn->eqv(n->in(0), this), "Expect RegionNode to be control parent"); | |
| 561 n->set_req(0, parent_ctrl); | |
| 562 } | |
| 563 #ifdef ASSERT | |
| 564 for( uint k=0; k < n->req(); k++ ) { | |
| 565 assert( !igvn->eqv(n->in(k), this), "All uses of RegionNode should be gone"); | |
| 566 } | |
| 567 #endif | |
| 568 } | |
| 569 // Remove the RegionNode itself from DefUse info | |
| 570 igvn->remove_dead_node(this); | |
| 571 return NULL; | |
| 572 } | |
| 573 return this; // Record progress | |
| 574 } | |
| 575 | |
| 576 | |
| 577 // If a Region flows into a Region, merge into one big happy merge. | |
| 578 if (can_reshape) { | |
| 579 Node *m = merge_region(this, phase); | |
| 580 if (m != NULL) return m; | |
| 581 } | |
| 582 | |
| 583 // Check if this region is the root of a clipping idiom on floats | |
| 584 if( ConvertFloat2IntClipping && can_reshape && req() == 4 ) { | |
| 585 // Check that only one use is a Phi and that it simplifies to two constants + | |
| 586 PhiNode* phi = has_unique_phi(); | |
| 587 if (phi != NULL) { // One Phi user | |
| 588 // Check inputs to the Phi | |
| 589 ConNode *min; | |
| 590 ConNode *max; | |
| 591 Node *val; | |
| 592 uint min_idx; | |
| 593 uint max_idx; | |
| 594 uint val_idx; | |
| 595 if( check_phi_clipping( phi, min, min_idx, max, max_idx, val, val_idx ) ) { | |
| 596 IfNode *top_if; | |
| 597 IfNode *bot_if; | |
| 598 if( check_if_clipping( this, bot_if, top_if ) ) { | |
| 599 // Control pattern checks, now verify compares | |
| 600 Node *top_in = NULL; // value being compared against | |
| 601 Node *bot_in = NULL; | |
| 602 if( check_compare_clipping( true, bot_if, min, bot_in ) && | |
| 603 check_compare_clipping( false, top_if, max, top_in ) ) { | |
| 604 if( bot_in == top_in ) { | |
| 605 PhaseIterGVN *gvn = phase->is_IterGVN(); | |
| 606 assert( gvn != NULL, "Only had DefUse info in IterGVN"); | |
| 607 // Only remaining check is that bot_in == top_in == (Phi's val + mods) | |
| 608 | |
| 609 // Check for the ConvF2INode | |
| 610 ConvF2INode *convf2i; | |
| 611 if( check_convf2i_clipping( phi, val_idx, convf2i, min, max ) && | |
| 612 convf2i->in(1) == bot_in ) { | |
| 613 // Matched pattern, including LShiftI; RShiftI, replace with integer compares | |
| 614 // max test | |
| 615 Node *cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, min )); | |
| 616 Node *boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::lt )); | |
| 617 IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C, 2) IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt )); | |
| 618 Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); | |
| 619 Node *ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); | |
| 620 // min test | |
| 621 cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, max )); | |
| 622 boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::gt )); | |
| 623 iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C, 2) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt )); | |
| 624 Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); | |
| 625 ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); | |
| 626 // update input edges to region node | |
| 627 set_req_X( min_idx, if_min, gvn ); | |
| 628 set_req_X( max_idx, if_max, gvn ); | |
| 629 set_req_X( val_idx, ifF, gvn ); | |
| 630 // remove unnecessary 'LShiftI; RShiftI' idiom | |
| 631 gvn->hash_delete(phi); | |
| 632 phi->set_req_X( val_idx, convf2i, gvn ); | |
| 633 gvn->hash_find_insert(phi); | |
| 634 // Return transformed region node | |
| 635 return this; | |
| 636 } | |
| 637 } | |
| 638 } | |
| 639 } | |
| 640 } | |
| 641 } | |
| 642 } | |
| 643 | |
| 644 return NULL; | |
| 645 } | |
| 646 | |
| 647 | |
| 648 | |
| 649 const RegMask &RegionNode::out_RegMask() const { | |
| 650 return RegMask::Empty; | |
| 651 } | |
| 652 | |
| 653 // Find the one non-null required input. RegionNode only | |
| 654 Node *Node::nonnull_req() const { | |
| 655 assert( is_Region(), "" ); | |
| 656 for( uint i = 1; i < _cnt; i++ ) | |
| 657 if( in(i) ) | |
| 658 return in(i); | |
| 659 ShouldNotReachHere(); | |
| 660 return NULL; | |
| 661 } | |
| 662 | |
| 663 | |
| 664 //============================================================================= | |
| 665 // note that these functions assume that the _adr_type field is flattened | |
| 666 uint PhiNode::hash() const { | |
| 667 const Type* at = _adr_type; | |
| 668 return TypeNode::hash() + (at ? at->hash() : 0); | |
| 669 } | |
| 670 uint PhiNode::cmp( const Node &n ) const { | |
| 671 return TypeNode::cmp(n) && _adr_type == ((PhiNode&)n)._adr_type; | |
| 672 } | |
| 673 static inline | |
| 674 const TypePtr* flatten_phi_adr_type(const TypePtr* at) { | |
| 675 if (at == NULL || at == TypePtr::BOTTOM) return at; | |
| 676 return Compile::current()->alias_type(at)->adr_type(); | |
| 677 } | |
| 678 | |
| 679 //----------------------------make--------------------------------------------- | |
| 680 // create a new phi with edges matching r and set (initially) to x | |
| 681 PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) { | |
| 682 uint preds = r->req(); // Number of predecessor paths | |
| 683 assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at"); | |
| 684 PhiNode* p = new (Compile::current(), preds) PhiNode(r, t, at); | |
| 685 for (uint j = 1; j < preds; j++) { | |
| 686 // Fill in all inputs, except those which the region does not yet have | |
| 687 if (r->in(j) != NULL) | |
| 688 p->init_req(j, x); | |
| 689 } | |
| 690 return p; | |
| 691 } | |
| 692 PhiNode* PhiNode::make(Node* r, Node* x) { | |
| 693 const Type* t = x->bottom_type(); | |
| 694 const TypePtr* at = NULL; | |
| 695 if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); | |
| 696 return make(r, x, t, at); | |
| 697 } | |
| 698 PhiNode* PhiNode::make_blank(Node* r, Node* x) { | |
| 699 const Type* t = x->bottom_type(); | |
| 700 const TypePtr* at = NULL; | |
| 701 if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); | |
| 702 return new (Compile::current(), r->req()) PhiNode(r, t, at); | |
| 703 } | |
| 704 | |
| 705 | |
| 706 //------------------------slice_memory----------------------------------------- | |
| 707 // create a new phi with narrowed memory type | |
| 708 PhiNode* PhiNode::slice_memory(const TypePtr* adr_type) const { | |
| 709 PhiNode* mem = (PhiNode*) clone(); | |
| 710 *(const TypePtr**)&mem->_adr_type = adr_type; | |
| 711 // convert self-loops, or else we get a bad graph | |
| 712 for (uint i = 1; i < req(); i++) { | |
| 713 if ((const Node*)in(i) == this) mem->set_req(i, mem); | |
| 714 } | |
| 715 mem->verify_adr_type(); | |
| 716 return mem; | |
| 717 } | |
| 718 | |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
719 //------------------------split_out_instance----------------------------------- |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
720 // Split out an instance type from a bottom phi. |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
721 PhiNode* PhiNode::split_out_instance(const TypePtr* at, PhaseIterGVN *igvn) const { |
| 163 | 722 const TypeOopPtr *t_oop = at->isa_oopptr(); |
| 223 | 723 assert(t_oop != NULL && t_oop->is_known_instance(), "expecting instance oopptr"); |
| 163 | 724 const TypePtr *t = adr_type(); |
| 725 assert(type() == Type::MEMORY && | |
| 726 (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM || | |
| 223 | 727 t->isa_oopptr() && !t->is_oopptr()->is_known_instance() && |
| 247 | 728 t->is_oopptr()->cast_to_exactness(true) |
| 729 ->is_oopptr()->cast_to_ptr_type(t_oop->ptr()) | |
| 730 ->is_oopptr()->cast_to_instance_id(t_oop->instance_id()) == t_oop), | |
| 163 | 731 "bottom or raw memory required"); |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
732 |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
733 // Check if an appropriate node already exists. |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
734 Node *region = in(0); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
735 for (DUIterator_Fast kmax, k = region->fast_outs(kmax); k < kmax; k++) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
736 Node* use = region->fast_out(k); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
737 if( use->is_Phi()) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
738 PhiNode *phi2 = use->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
739 if (phi2->type() == Type::MEMORY && phi2->adr_type() == at) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
740 return phi2; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
741 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
742 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
743 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
744 Compile *C = igvn->C; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
745 Arena *a = Thread::current()->resource_area(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
746 Node_Array node_map = new Node_Array(a); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
747 Node_Stack stack(a, C->unique() >> 4); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
748 PhiNode *nphi = slice_memory(at); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
749 igvn->register_new_node_with_optimizer( nphi ); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
750 node_map.map(_idx, nphi); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
751 stack.push((Node *)this, 1); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
752 while(!stack.is_empty()) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
753 PhiNode *ophi = stack.node()->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
754 uint i = stack.index(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
755 assert(i >= 1, "not control edge"); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
756 stack.pop(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
757 nphi = node_map[ophi->_idx]->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
758 for (; i < ophi->req(); i++) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
759 Node *in = ophi->in(i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
760 if (in == NULL || igvn->type(in) == Type::TOP) |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
761 continue; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
762 Node *opt = MemNode::optimize_simple_memory_chain(in, at, igvn); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
763 PhiNode *optphi = opt->is_Phi() ? opt->as_Phi() : NULL; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
764 if (optphi != NULL && optphi->adr_type() == TypePtr::BOTTOM) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
765 opt = node_map[optphi->_idx]; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
766 if (opt == NULL) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
767 stack.push(ophi, i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
768 nphi = optphi->slice_memory(at); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
769 igvn->register_new_node_with_optimizer( nphi ); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
770 node_map.map(optphi->_idx, nphi); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
771 ophi = optphi; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
772 i = 0; // will get incremented at top of loop |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
773 continue; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
774 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
775 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
776 nphi->set_req(i, opt); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
777 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
778 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
779 return nphi; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
780 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
781 |
| 0 | 782 //------------------------verify_adr_type-------------------------------------- |
| 783 #ifdef ASSERT | |
| 784 void PhiNode::verify_adr_type(VectorSet& visited, const TypePtr* at) const { | |
| 785 if (visited.test_set(_idx)) return; //already visited | |
| 786 | |
| 787 // recheck constructor invariants: | |
| 788 verify_adr_type(false); | |
| 789 | |
| 790 // recheck local phi/phi consistency: | |
| 791 assert(_adr_type == at || _adr_type == TypePtr::BOTTOM, | |
| 792 "adr_type must be consistent across phi nest"); | |
| 793 | |
| 794 // walk around | |
| 795 for (uint i = 1; i < req(); i++) { | |
| 796 Node* n = in(i); | |
| 797 if (n == NULL) continue; | |
| 798 const Node* np = in(i); | |
| 799 if (np->is_Phi()) { | |
| 800 np->as_Phi()->verify_adr_type(visited, at); | |
| 801 } else if (n->bottom_type() == Type::TOP | |
| 802 || (n->is_Mem() && n->in(MemNode::Address)->bottom_type() == Type::TOP)) { | |
| 803 // ignore top inputs | |
| 804 } else { | |
| 805 const TypePtr* nat = flatten_phi_adr_type(n->adr_type()); | |
| 806 // recheck phi/non-phi consistency at leaves: | |
| 807 assert((nat != NULL) == (at != NULL), ""); | |
| 808 assert(nat == at || nat == TypePtr::BOTTOM, | |
| 809 "adr_type must be consistent at leaves of phi nest"); | |
| 810 } | |
| 811 } | |
| 812 } | |
| 813 | |
| 814 // Verify a whole nest of phis rooted at this one. | |
| 815 void PhiNode::verify_adr_type(bool recursive) const { | |
| 816 if (is_error_reported()) return; // muzzle asserts when debugging an error | |
| 817 if (Node::in_dump()) return; // muzzle asserts when printing | |
| 818 | |
| 819 assert((_type == Type::MEMORY) == (_adr_type != NULL), "adr_type for memory phis only"); | |
| 820 | |
| 821 if (!VerifyAliases) return; // verify thoroughly only if requested | |
| 822 | |
| 823 assert(_adr_type == flatten_phi_adr_type(_adr_type), | |
| 824 "Phi::adr_type must be pre-normalized"); | |
| 825 | |
| 826 if (recursive) { | |
| 827 VectorSet visited(Thread::current()->resource_area()); | |
| 828 verify_adr_type(visited, _adr_type); | |
| 829 } | |
| 830 } | |
| 831 #endif | |
| 832 | |
| 833 | |
| 834 //------------------------------Value------------------------------------------ | |
| 835 // Compute the type of the PhiNode | |
| 836 const Type *PhiNode::Value( PhaseTransform *phase ) const { | |
| 837 Node *r = in(0); // RegionNode | |
| 838 if( !r ) // Copy or dead | |
| 839 return in(1) ? phase->type(in(1)) : Type::TOP; | |
| 840 | |
| 841 // Note: During parsing, phis are often transformed before their regions. | |
| 842 // This means we have to use type_or_null to defend against untyped regions. | |
| 843 if( phase->type_or_null(r) == Type::TOP ) // Dead code? | |
| 844 return Type::TOP; | |
| 845 | |
| 846 // Check for trip-counted loop. If so, be smarter. | |
| 847 CountedLoopNode *l = r->is_CountedLoop() ? r->as_CountedLoop() : NULL; | |
| 848 if( l && l->can_be_counted_loop(phase) && | |
| 849 ((const Node*)l->phi() == this) ) { // Trip counted loop! | |
| 850 // protect against init_trip() or limit() returning NULL | |
| 851 const Node *init = l->init_trip(); | |
| 852 const Node *limit = l->limit(); | |
| 853 if( init != NULL && limit != NULL && l->stride_is_con() ) { | |
| 854 const TypeInt *lo = init ->bottom_type()->isa_int(); | |
| 855 const TypeInt *hi = limit->bottom_type()->isa_int(); | |
| 856 if( lo && hi ) { // Dying loops might have TOP here | |
| 857 int stride = l->stride_con(); | |
| 858 if( stride < 0 ) { // Down-counter loop | |
| 859 const TypeInt *tmp = lo; lo = hi; hi = tmp; | |
| 860 stride = -stride; | |
| 861 } | |
| 862 if( lo->_hi < hi->_lo ) // Reversed endpoints are well defined :-( | |
| 863 return TypeInt::make(lo->_lo,hi->_hi,3); | |
| 864 } | |
| 865 } | |
| 866 } | |
| 867 | |
| 868 // Until we have harmony between classes and interfaces in the type | |
| 869 // lattice, we must tread carefully around phis which implicitly | |
| 870 // convert the one to the other. | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
871 const TypePtr* ttp = _type->make_ptr(); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
872 const TypeInstPtr* ttip = (ttp != NULL) ? ttp->isa_instptr() : NULL; |
| 555 | 873 const TypeKlassPtr* ttkp = (ttp != NULL) ? ttp->isa_klassptr() : NULL; |
| 0 | 874 bool is_intf = false; |
| 875 if (ttip != NULL) { | |
| 876 ciKlass* k = ttip->klass(); | |
| 877 if (k->is_loaded() && k->is_interface()) | |
| 878 is_intf = true; | |
| 879 } | |
| 555 | 880 if (ttkp != NULL) { |
| 881 ciKlass* k = ttkp->klass(); | |
| 882 if (k->is_loaded() && k->is_interface()) | |
| 883 is_intf = true; | |
| 884 } | |
| 0 | 885 |
| 886 // Default case: merge all inputs | |
| 887 const Type *t = Type::TOP; // Merged type starting value | |
| 888 for (uint i = 1; i < req(); ++i) {// For all paths in | |
| 889 // Reachable control path? | |
| 890 if (r->in(i) && phase->type(r->in(i)) == Type::CONTROL) { | |
| 891 const Type* ti = phase->type(in(i)); | |
| 892 // We assume that each input of an interface-valued Phi is a true | |
| 893 // subtype of that interface. This might not be true of the meet | |
| 894 // of all the input types. The lattice is not distributive in | |
| 895 // such cases. Ward off asserts in type.cpp by refusing to do | |
| 896 // meets between interfaces and proper classes. | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
897 const TypePtr* tip = ti->make_ptr(); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
898 const TypeInstPtr* tiip = (tip != NULL) ? tip->isa_instptr() : NULL; |
| 0 | 899 if (tiip) { |
| 900 bool ti_is_intf = false; | |
| 901 ciKlass* k = tiip->klass(); | |
| 902 if (k->is_loaded() && k->is_interface()) | |
| 903 ti_is_intf = true; | |
| 904 if (is_intf != ti_is_intf) | |
| 905 { t = _type; break; } | |
| 906 } | |
| 907 t = t->meet(ti); | |
| 908 } | |
| 909 } | |
| 910 | |
| 911 // The worst-case type (from ciTypeFlow) should be consistent with "t". | |
| 912 // That is, we expect that "t->higher_equal(_type)" holds true. | |
| 913 // There are various exceptions: | |
| 914 // - Inputs which are phis might in fact be widened unnecessarily. | |
| 915 // For example, an input might be a widened int while the phi is a short. | |
| 916 // - Inputs might be BotPtrs but this phi is dependent on a null check, | |
| 917 // and postCCP has removed the cast which encodes the result of the check. | |
| 918 // - The type of this phi is an interface, and the inputs are classes. | |
| 919 // - Value calls on inputs might produce fuzzy results. | |
| 920 // (Occurrences of this case suggest improvements to Value methods.) | |
| 921 // | |
| 922 // It is not possible to see Type::BOTTOM values as phi inputs, | |
| 923 // because the ciTypeFlow pre-pass produces verifier-quality types. | |
| 924 const Type* ft = t->filter(_type); // Worst case type | |
| 925 | |
| 926 #ifdef ASSERT | |
| 927 // The following logic has been moved into TypeOopPtr::filter. | |
| 928 const Type* jt = t->join(_type); | |
| 929 if( jt->empty() ) { // Emptied out??? | |
| 930 | |
| 931 // Check for evil case of 't' being a class and '_type' expecting an | |
| 932 // interface. This can happen because the bytecodes do not contain | |
| 933 // enough type info to distinguish a Java-level interface variable | |
| 934 // from a Java-level object variable. If we meet 2 classes which | |
| 935 // both implement interface I, but their meet is at 'j/l/O' which | |
| 936 // doesn't implement I, we have no way to tell if the result should | |
| 937 // be 'I' or 'j/l/O'. Thus we'll pick 'j/l/O'. If this then flows | |
| 938 // into a Phi which "knows" it's an Interface type we'll have to | |
| 939 // uplift the type. | |
| 940 if( !t->empty() && ttip && ttip->is_loaded() && ttip->klass()->is_interface() ) | |
| 941 { assert(ft == _type, ""); } // Uplift to interface | |
| 555 | 942 else if( !t->empty() && ttkp && ttkp->is_loaded() && ttkp->klass()->is_interface() ) |
| 943 { assert(ft == _type, ""); } // Uplift to interface | |
| 0 | 944 // Otherwise it's something stupid like non-overlapping int ranges |
| 945 // found on dying counted loops. | |
| 946 else | |
| 947 { assert(ft == Type::TOP, ""); } // Canonical empty value | |
| 948 } | |
| 949 | |
| 950 else { | |
| 951 | |
| 952 // If we have an interface-typed Phi and we narrow to a class type, the join | |
| 953 // should report back the class. However, if we have a J/L/Object | |
| 954 // class-typed Phi and an interface flows in, it's possible that the meet & | |
| 955 // join report an interface back out. This isn't possible but happens | |
| 956 // because the type system doesn't interact well with interfaces. | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
957 const TypePtr *jtp = jt->make_ptr(); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
958 const TypeInstPtr *jtip = (jtp != NULL) ? jtp->isa_instptr() : NULL; |
| 555 | 959 const TypeKlassPtr *jtkp = (jtp != NULL) ? jtp->isa_klassptr() : NULL; |
| 0 | 960 if( jtip && ttip ) { |
| 961 if( jtip->is_loaded() && jtip->klass()->is_interface() && | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
962 ttip->is_loaded() && !ttip->klass()->is_interface() ) { |
| 0 | 963 // Happens in a CTW of rt.jar, 320-341, no extra flags |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
964 assert(ft == ttip->cast_to_ptr_type(jtip->ptr()) || |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
184
diff
changeset
|
965 ft->isa_narrowoop() && ft->make_ptr() == ttip->cast_to_ptr_type(jtip->ptr()), ""); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
966 jt = ft; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
967 } |
| 0 | 968 } |
| 555 | 969 if( jtkp && ttkp ) { |
| 970 if( jtkp->is_loaded() && jtkp->klass()->is_interface() && | |
|
1335
ae4032fb0a5b
6894807: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
kvn
parents:
1013
diff
changeset
|
971 !jtkp->klass_is_exact() && // Keep exact interface klass (6894807) |
| 555 | 972 ttkp->is_loaded() && !ttkp->klass()->is_interface() ) { |
| 973 assert(ft == ttkp->cast_to_ptr_type(jtkp->ptr()) || | |
| 974 ft->isa_narrowoop() && ft->make_ptr() == ttkp->cast_to_ptr_type(jtkp->ptr()), ""); | |
| 975 jt = ft; | |
| 976 } | |
| 977 } | |
| 0 | 978 if (jt != ft && jt->base() == ft->base()) { |
| 979 if (jt->isa_int() && | |
| 980 jt->is_int()->_lo == ft->is_int()->_lo && | |
| 981 jt->is_int()->_hi == ft->is_int()->_hi) | |
| 982 jt = ft; | |
| 983 if (jt->isa_long() && | |
| 984 jt->is_long()->_lo == ft->is_long()->_lo && | |
| 985 jt->is_long()->_hi == ft->is_long()->_hi) | |
| 986 jt = ft; | |
| 987 } | |
| 988 if (jt != ft) { | |
| 989 tty->print("merge type: "); t->dump(); tty->cr(); | |
| 990 tty->print("kill type: "); _type->dump(); tty->cr(); | |
| 991 tty->print("join type: "); jt->dump(); tty->cr(); | |
| 992 tty->print("filter type: "); ft->dump(); tty->cr(); | |
| 993 } | |
| 994 assert(jt == ft, ""); | |
| 995 } | |
| 996 #endif //ASSERT | |
| 997 | |
| 998 // Deal with conversion problems found in data loops. | |
| 999 ft = phase->saturate(ft, phase->type_or_null(this), _type); | |
| 1000 | |
| 1001 return ft; | |
| 1002 } | |
| 1003 | |
| 1004 | |
| 1005 //------------------------------is_diamond_phi--------------------------------- | |
| 1006 // Does this Phi represent a simple well-shaped diamond merge? Return the | |
| 1007 // index of the true path or 0 otherwise. | |
| 1008 int PhiNode::is_diamond_phi() const { | |
| 1009 // Check for a 2-path merge | |
| 1010 Node *region = in(0); | |
| 1011 if( !region ) return 0; | |
| 1012 if( region->req() != 3 ) return 0; | |
| 1013 if( req() != 3 ) return 0; | |
| 1014 // Check that both paths come from the same If | |
| 1015 Node *ifp1 = region->in(1); | |
| 1016 Node *ifp2 = region->in(2); | |
| 1017 if( !ifp1 || !ifp2 ) return 0; | |
| 1018 Node *iff = ifp1->in(0); | |
| 1019 if( !iff || !iff->is_If() ) return 0; | |
| 1020 if( iff != ifp2->in(0) ) return 0; | |
| 1021 // Check for a proper bool/cmp | |
| 1022 const Node *b = iff->in(1); | |
| 1023 if( !b->is_Bool() ) return 0; | |
| 1024 const Node *cmp = b->in(1); | |
| 1025 if( !cmp->is_Cmp() ) return 0; | |
| 1026 | |
| 1027 // Check for branching opposite expected | |
| 1028 if( ifp2->Opcode() == Op_IfTrue ) { | |
| 1029 assert( ifp1->Opcode() == Op_IfFalse, "" ); | |
| 1030 return 2; | |
| 1031 } else { | |
| 1032 assert( ifp1->Opcode() == Op_IfTrue, "" ); | |
| 1033 return 1; | |
| 1034 } | |
| 1035 } | |
| 1036 | |
| 1037 //----------------------------check_cmove_id----------------------------------- | |
| 1038 // Check for CMove'ing a constant after comparing against the constant. | |
| 1039 // Happens all the time now, since if we compare equality vs a constant in | |
| 1040 // the parser, we "know" the variable is constant on one path and we force | |
| 1041 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a | |
| 1042 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more | |
| 1043 // general in that we don't need constants. Since CMove's are only inserted | |
| 1044 // in very special circumstances, we do it here on generic Phi's. | |
| 1045 Node* PhiNode::is_cmove_id(PhaseTransform* phase, int true_path) { | |
| 1046 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1047 | |
| 1048 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1049 // phi->region->if_proj->ifnode->bool->cmp | |
| 1050 Node* region = in(0); | |
| 1051 Node* iff = region->in(1)->in(0); | |
| 1052 BoolNode* b = iff->in(1)->as_Bool(); | |
| 1053 Node* cmp = b->in(1); | |
| 1054 Node* tval = in(true_path); | |
| 1055 Node* fval = in(3-true_path); | |
| 1056 Node* id = CMoveNode::is_cmove_id(phase, cmp, tval, fval, b); | |
| 1057 if (id == NULL) | |
| 1058 return NULL; | |
| 1059 | |
| 1060 // Either value might be a cast that depends on a branch of 'iff'. | |
| 1061 // Since the 'id' value will float free of the diamond, either | |
| 1062 // decast or return failure. | |
| 1063 Node* ctl = id->in(0); | |
| 1064 if (ctl != NULL && ctl->in(0) == iff) { | |
| 1065 if (id->is_ConstraintCast()) { | |
| 1066 return id->in(1); | |
| 1067 } else { | |
| 1068 // Don't know how to disentangle this value. | |
| 1069 return NULL; | |
| 1070 } | |
| 1071 } | |
| 1072 | |
| 1073 return id; | |
| 1074 } | |
| 1075 | |
| 1076 //------------------------------Identity--------------------------------------- | |
| 1077 // Check for Region being Identity. | |
| 1078 Node *PhiNode::Identity( PhaseTransform *phase ) { | |
| 1079 // Check for no merging going on | |
| 1080 // (There used to be special-case code here when this->region->is_Loop. | |
| 1081 // It would check for a tributary phi on the backedge that the main phi | |
| 1082 // trivially, perhaps with a single cast. The unique_input method | |
| 1083 // does all this and more, by reducing such tributaries to 'this'.) | |
| 1084 Node* uin = unique_input(phase); | |
| 1085 if (uin != NULL) { | |
| 1086 return uin; | |
| 1087 } | |
| 1088 | |
| 1089 int true_path = is_diamond_phi(); | |
| 1090 if (true_path != 0) { | |
| 1091 Node* id = is_cmove_id(phase, true_path); | |
| 1092 if (id != NULL) return id; | |
| 1093 } | |
| 1094 | |
| 1095 return this; // No identity | |
| 1096 } | |
| 1097 | |
| 1098 //-----------------------------unique_input------------------------------------ | |
| 1099 // Find the unique value, discounting top, self-loops, and casts. | |
| 1100 // Return top if there are no inputs, and self if there are multiple. | |
| 1101 Node* PhiNode::unique_input(PhaseTransform* phase) { | |
| 1102 // 1) One unique direct input, or | |
| 1103 // 2) some of the inputs have an intervening ConstraintCast and | |
| 1104 // the type of input is the same or sharper (more specific) | |
| 1105 // than the phi's type. | |
| 1106 // 3) an input is a self loop | |
| 1107 // | |
| 1108 // 1) input or 2) input or 3) input __ | |
| 1109 // / \ / \ \ / \ | |
| 1110 // \ / | cast phi cast | |
| 1111 // phi \ / / \ / | |
| 1112 // phi / -- | |
| 1113 | |
| 1114 Node* r = in(0); // RegionNode | |
| 1115 if (r == NULL) return in(1); // Already degraded to a Copy | |
| 1116 Node* uncasted_input = NULL; // The unique uncasted input (ConstraintCasts removed) | |
| 1117 Node* direct_input = NULL; // The unique direct input | |
| 1118 | |
| 1119 for (uint i = 1, cnt = req(); i < cnt; ++i) { | |
| 1120 Node* rc = r->in(i); | |
| 1121 if (rc == NULL || phase->type(rc) == Type::TOP) | |
| 1122 continue; // ignore unreachable control path | |
| 1123 Node* n = in(i); | |
| 247 | 1124 if (n == NULL) |
| 1125 continue; | |
| 0 | 1126 Node* un = n->uncast(); |
| 1127 if (un == NULL || un == this || phase->type(un) == Type::TOP) { | |
| 1128 continue; // ignore if top, or in(i) and "this" are in a data cycle | |
| 1129 } | |
| 1130 // Check for a unique uncasted input | |
| 1131 if (uncasted_input == NULL) { | |
| 1132 uncasted_input = un; | |
| 1133 } else if (uncasted_input != un) { | |
| 1134 uncasted_input = NodeSentinel; // no unique uncasted input | |
| 1135 } | |
| 1136 // Check for a unique direct input | |
| 1137 if (direct_input == NULL) { | |
| 1138 direct_input = n; | |
| 1139 } else if (direct_input != n) { | |
| 1140 direct_input = NodeSentinel; // no unique direct input | |
| 1141 } | |
| 1142 } | |
| 1143 if (direct_input == NULL) { | |
| 1144 return phase->C->top(); // no inputs | |
| 1145 } | |
| 1146 assert(uncasted_input != NULL,""); | |
| 1147 | |
| 1148 if (direct_input != NodeSentinel) { | |
| 1149 return direct_input; // one unique direct input | |
| 1150 } | |
| 1151 if (uncasted_input != NodeSentinel && | |
| 1152 phase->type(uncasted_input)->higher_equal(type())) { | |
| 1153 return uncasted_input; // one unique uncasted input | |
| 1154 } | |
| 1155 | |
| 1156 // Nothing. | |
| 1157 return NULL; | |
| 1158 } | |
| 1159 | |
| 1160 //------------------------------is_x2logic------------------------------------- | |
| 1161 // Check for simple convert-to-boolean pattern | |
| 1162 // If:(C Bool) Region:(IfF IfT) Phi:(Region 0 1) | |
| 1163 // Convert Phi to an ConvIB. | |
| 1164 static Node *is_x2logic( PhaseGVN *phase, PhiNode *phi, int true_path ) { | |
| 1165 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1166 // Convert the true/false index into an expected 0/1 return. | |
| 1167 // Map 2->0 and 1->1. | |
| 1168 int flipped = 2-true_path; | |
| 1169 | |
| 1170 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1171 // phi->region->if_proj->ifnode->bool->cmp | |
| 1172 Node *region = phi->in(0); | |
| 1173 Node *iff = region->in(1)->in(0); | |
| 1174 BoolNode *b = (BoolNode*)iff->in(1); | |
| 1175 const CmpNode *cmp = (CmpNode*)b->in(1); | |
| 1176 | |
| 1177 Node *zero = phi->in(1); | |
| 1178 Node *one = phi->in(2); | |
| 1179 const Type *tzero = phase->type( zero ); | |
| 1180 const Type *tone = phase->type( one ); | |
| 1181 | |
| 1182 // Check for compare vs 0 | |
| 1183 const Type *tcmp = phase->type(cmp->in(2)); | |
| 1184 if( tcmp != TypeInt::ZERO && tcmp != TypePtr::NULL_PTR ) { | |
| 1185 // Allow cmp-vs-1 if the other input is bounded by 0-1 | |
| 1186 if( !(tcmp == TypeInt::ONE && phase->type(cmp->in(1)) == TypeInt::BOOL) ) | |
| 1187 return NULL; | |
| 1188 flipped = 1-flipped; // Test is vs 1 instead of 0! | |
| 1189 } | |
| 1190 | |
| 1191 // Check for setting zero/one opposite expected | |
| 1192 if( tzero == TypeInt::ZERO ) { | |
| 1193 if( tone == TypeInt::ONE ) { | |
| 1194 } else return NULL; | |
| 1195 } else if( tzero == TypeInt::ONE ) { | |
| 1196 if( tone == TypeInt::ZERO ) { | |
| 1197 flipped = 1-flipped; | |
| 1198 } else return NULL; | |
| 1199 } else return NULL; | |
| 1200 | |
| 1201 // Check for boolean test backwards | |
| 1202 if( b->_test._test == BoolTest::ne ) { | |
| 1203 } else if( b->_test._test == BoolTest::eq ) { | |
| 1204 flipped = 1-flipped; | |
| 1205 } else return NULL; | |
| 1206 | |
| 1207 // Build int->bool conversion | |
| 1208 Node *n = new (phase->C, 2) Conv2BNode( cmp->in(1) ); | |
| 1209 if( flipped ) | |
| 1210 n = new (phase->C, 3) XorINode( phase->transform(n), phase->intcon(1) ); | |
| 1211 | |
| 1212 return n; | |
| 1213 } | |
| 1214 | |
| 1215 //------------------------------is_cond_add------------------------------------ | |
| 1216 // Check for simple conditional add pattern: "(P < Q) ? X+Y : X;" | |
| 1217 // To be profitable the control flow has to disappear; there can be no other | |
| 1218 // values merging here. We replace the test-and-branch with: | |
| 1219 // "(sgn(P-Q))&Y) + X". Basically, convert "(P < Q)" into 0 or -1 by | |
| 1220 // moving the carry bit from (P-Q) into a register with 'sbb EAX,EAX'. | |
| 1221 // Then convert Y to 0-or-Y and finally add. | |
| 1222 // This is a key transform for SpecJava _201_compress. | |
| 1223 static Node* is_cond_add(PhaseGVN *phase, PhiNode *phi, int true_path) { | |
| 1224 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1225 | |
| 1226 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1227 // phi->region->if_proj->ifnode->bool->cmp | |
| 1228 RegionNode *region = (RegionNode*)phi->in(0); | |
| 1229 Node *iff = region->in(1)->in(0); | |
| 1230 BoolNode* b = iff->in(1)->as_Bool(); | |
| 1231 const CmpNode *cmp = (CmpNode*)b->in(1); | |
| 1232 | |
| 1233 // Make sure only merging this one phi here | |
| 1234 if (region->has_unique_phi() != phi) return NULL; | |
| 1235 | |
| 1236 // Make sure each arm of the diamond has exactly one output, which we assume | |
| 1237 // is the region. Otherwise, the control flow won't disappear. | |
| 1238 if (region->in(1)->outcnt() != 1) return NULL; | |
| 1239 if (region->in(2)->outcnt() != 1) return NULL; | |
| 1240 | |
| 1241 // Check for "(P < Q)" of type signed int | |
| 1242 if (b->_test._test != BoolTest::lt) return NULL; | |
| 1243 if (cmp->Opcode() != Op_CmpI) return NULL; | |
| 1244 | |
| 1245 Node *p = cmp->in(1); | |
| 1246 Node *q = cmp->in(2); | |
| 1247 Node *n1 = phi->in( true_path); | |
| 1248 Node *n2 = phi->in(3-true_path); | |
| 1249 | |
| 1250 int op = n1->Opcode(); | |
| 1251 if( op != Op_AddI // Need zero as additive identity | |
| 1252 /*&&op != Op_SubI && | |
| 1253 op != Op_AddP && | |
| 1254 op != Op_XorI && | |
| 1255 op != Op_OrI*/ ) | |
| 1256 return NULL; | |
| 1257 | |
| 1258 Node *x = n2; | |
| 1259 Node *y = n1->in(1); | |
| 1260 if( n2 == n1->in(1) ) { | |
| 1261 y = n1->in(2); | |
| 1262 } else if( n2 == n1->in(1) ) { | |
| 1263 } else return NULL; | |
| 1264 | |
| 1265 // Not so profitable if compare and add are constants | |
| 1266 if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() ) | |
| 1267 return NULL; | |
| 1268 | |
| 1269 Node *cmplt = phase->transform( new (phase->C, 3) CmpLTMaskNode(p,q) ); | |
| 1270 Node *j_and = phase->transform( new (phase->C, 3) AndINode(cmplt,y) ); | |
| 1271 return new (phase->C, 3) AddINode(j_and,x); | |
| 1272 } | |
| 1273 | |
| 1274 //------------------------------is_absolute------------------------------------ | |
| 1275 // Check for absolute value. | |
| 1276 static Node* is_absolute( PhaseGVN *phase, PhiNode *phi_root, int true_path) { | |
| 1277 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1278 | |
| 1279 int cmp_zero_idx = 0; // Index of compare input where to look for zero | |
| 1280 int phi_x_idx = 0; // Index of phi input where to find naked x | |
| 1281 | |
| 1282 // ABS ends with the merge of 2 control flow paths. | |
| 1283 // Find the false path from the true path. With only 2 inputs, 3 - x works nicely. | |
| 1284 int false_path = 3 - true_path; | |
| 1285 | |
| 1286 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1287 // phi->region->if_proj->ifnode->bool->cmp | |
| 1288 BoolNode *bol = phi_root->in(0)->in(1)->in(0)->in(1)->as_Bool(); | |
| 1289 | |
| 1290 // Check bool sense | |
| 1291 switch( bol->_test._test ) { | |
| 1292 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = true_path; break; | |
| 1293 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = false_path; break; | |
| 1294 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = true_path; break; | |
| 1295 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = false_path; break; | |
| 1296 default: return NULL; break; | |
| 1297 } | |
| 1298 | |
| 1299 // Test is next | |
| 1300 Node *cmp = bol->in(1); | |
| 1301 const Type *tzero = NULL; | |
| 1302 switch( cmp->Opcode() ) { | |
| 1303 case Op_CmpF: tzero = TypeF::ZERO; break; // Float ABS | |
| 1304 case Op_CmpD: tzero = TypeD::ZERO; break; // Double ABS | |
| 1305 default: return NULL; | |
| 1306 } | |
| 1307 | |
| 1308 // Find zero input of compare; the other input is being abs'd | |
| 1309 Node *x = NULL; | |
| 1310 bool flip = false; | |
| 1311 if( phase->type(cmp->in(cmp_zero_idx)) == tzero ) { | |
| 1312 x = cmp->in(3 - cmp_zero_idx); | |
| 1313 } else if( phase->type(cmp->in(3 - cmp_zero_idx)) == tzero ) { | |
| 1314 // The test is inverted, we should invert the result... | |
| 1315 x = cmp->in(cmp_zero_idx); | |
| 1316 flip = true; | |
| 1317 } else { | |
| 1318 return NULL; | |
| 1319 } | |
| 1320 | |
| 1321 // Next get the 2 pieces being selected, one is the original value | |
| 1322 // and the other is the negated value. | |
| 1323 if( phi_root->in(phi_x_idx) != x ) return NULL; | |
| 1324 | |
| 1325 // Check other phi input for subtract node | |
| 1326 Node *sub = phi_root->in(3 - phi_x_idx); | |
| 1327 | |
| 1328 // Allow only Sub(0,X) and fail out for all others; Neg is not OK | |
| 1329 if( tzero == TypeF::ZERO ) { | |
| 1330 if( sub->Opcode() != Op_SubF || | |
| 1331 sub->in(2) != x || | |
| 1332 phase->type(sub->in(1)) != tzero ) return NULL; | |
| 1333 x = new (phase->C, 2) AbsFNode(x); | |
| 1334 if (flip) { | |
| 1335 x = new (phase->C, 3) SubFNode(sub->in(1), phase->transform(x)); | |
| 1336 } | |
| 1337 } else { | |
| 1338 if( sub->Opcode() != Op_SubD || | |
| 1339 sub->in(2) != x || | |
| 1340 phase->type(sub->in(1)) != tzero ) return NULL; | |
| 1341 x = new (phase->C, 2) AbsDNode(x); | |
| 1342 if (flip) { | |
| 1343 x = new (phase->C, 3) SubDNode(sub->in(1), phase->transform(x)); | |
| 1344 } | |
| 1345 } | |
| 1346 | |
| 1347 return x; | |
| 1348 } | |
| 1349 | |
| 1350 //------------------------------split_once------------------------------------- | |
| 1351 // Helper for split_flow_path | |
| 1352 static void split_once(PhaseIterGVN *igvn, Node *phi, Node *val, Node *n, Node *newn) { | |
| 1353 igvn->hash_delete(n); // Remove from hash before hacking edges | |
| 1354 | |
| 1355 uint j = 1; | |
| 2445 | 1356 for (uint i = phi->req()-1; i > 0; i--) { |
| 1357 if (phi->in(i) == val) { // Found a path with val? | |
| 0 | 1358 // Add to NEW Region/Phi, no DU info |
| 1359 newn->set_req( j++, n->in(i) ); | |
| 1360 // Remove from OLD Region/Phi | |
| 1361 n->del_req(i); | |
| 1362 } | |
| 1363 } | |
| 1364 | |
| 1365 // Register the new node but do not transform it. Cannot transform until the | |
| 605 | 1366 // entire Region/Phi conglomerate has been hacked as a single huge transform. |
| 0 | 1367 igvn->register_new_node_with_optimizer( newn ); |
| 2445 | 1368 |
| 0 | 1369 // Now I can point to the new node. |
| 1370 n->add_req(newn); | |
| 1371 igvn->_worklist.push(n); | |
| 1372 } | |
| 1373 | |
| 1374 //------------------------------split_flow_path-------------------------------- | |
| 1375 // Check for merging identical values and split flow paths | |
| 1376 static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) { | |
| 1377 BasicType bt = phi->type()->basic_type(); | |
| 1378 if( bt == T_ILLEGAL || type2size[bt] <= 0 ) | |
| 1379 return NULL; // Bail out on funny non-value stuff | |
| 1380 if( phi->req() <= 3 ) // Need at least 2 matched inputs and a | |
| 1381 return NULL; // third unequal input to be worth doing | |
| 1382 | |
| 1383 // Scan for a constant | |
| 1384 uint i; | |
| 1385 for( i = 1; i < phi->req()-1; i++ ) { | |
| 1386 Node *n = phi->in(i); | |
| 1387 if( !n ) return NULL; | |
| 1388 if( phase->type(n) == Type::TOP ) return NULL; | |
| 163 | 1389 if( n->Opcode() == Op_ConP || n->Opcode() == Op_ConN ) |
| 0 | 1390 break; |
| 1391 } | |
| 1392 if( i >= phi->req() ) // Only split for constants | |
| 1393 return NULL; | |
| 1394 | |
| 1395 Node *val = phi->in(i); // Constant to split for | |
| 1396 uint hit = 0; // Number of times it occurs | |
|
3845
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1397 Node *r = phi->region(); |
| 0 | 1398 |
| 605 | 1399 for( ; i < phi->req(); i++ ){ // Count occurrences of constant |
| 0 | 1400 Node *n = phi->in(i); |
| 1401 if( !n ) return NULL; | |
| 1402 if( phase->type(n) == Type::TOP ) return NULL; | |
|
3845
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1403 if( phi->in(i) == val ) { |
| 0 | 1404 hit++; |
|
3845
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1405 if (PhaseIdealLoop::find_predicate(r->in(i)) != NULL) { |
|
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1406 return NULL; // don't split loop entry path |
|
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1407 } |
|
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3399
diff
changeset
|
1408 } |
| 0 | 1409 } |
| 1410 | |
| 1411 if( hit <= 1 || // Make sure we find 2 or more | |
| 1412 hit == phi->req()-1 ) // and not ALL the same value | |
| 1413 return NULL; | |
| 1414 | |
| 1415 // Now start splitting out the flow paths that merge the same value. | |
| 1416 // Split first the RegionNode. | |
| 1417 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 1418 RegionNode *newr = new (phase->C, hit+1) RegionNode(hit+1); | |
| 1419 split_once(igvn, phi, val, r, newr); | |
| 1420 | |
| 1421 // Now split all other Phis than this one | |
| 1422 for (DUIterator_Fast kmax, k = r->fast_outs(kmax); k < kmax; k++) { | |
| 1423 Node* phi2 = r->fast_out(k); | |
| 1424 if( phi2->is_Phi() && phi2->as_Phi() != phi ) { | |
| 1425 PhiNode *newphi = PhiNode::make_blank(newr, phi2); | |
| 1426 split_once(igvn, phi, val, phi2, newphi); | |
| 1427 } | |
| 1428 } | |
| 1429 | |
| 1430 // Clean up this guy | |
| 1431 igvn->hash_delete(phi); | |
| 1432 for( i = phi->req()-1; i > 0; i-- ) { | |
| 1433 if( phi->in(i) == val ) { | |
| 1434 phi->del_req(i); | |
| 1435 } | |
| 1436 } | |
| 1437 phi->add_req(val); | |
| 1438 | |
| 1439 return phi; | |
| 1440 } | |
| 1441 | |
| 1442 //============================================================================= | |
| 1443 //------------------------------simple_data_loop_check------------------------- | |
| 605 | 1444 // Try to determining if the phi node in a simple safe/unsafe data loop. |
| 0 | 1445 // Returns: |
| 1446 // enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; | |
| 1447 // Safe - safe case when the phi and it's inputs reference only safe data | |
| 1448 // nodes; | |
| 1449 // Unsafe - the phi and it's inputs reference unsafe data nodes but there | |
| 1450 // is no reference back to the phi - need a graph walk | |
| 1451 // to determine if it is in a loop; | |
| 1452 // UnsafeLoop - unsafe case when the phi references itself directly or through | |
| 1453 // unsafe data node. | |
| 1454 // Note: a safe data node is a node which could/never reference itself during | |
| 1455 // GVN transformations. For now it is Con, Proj, Phi, CastPP, CheckCastPP. | |
| 1456 // I mark Phi nodes as safe node not only because they can reference itself | |
| 1457 // but also to prevent mistaking the fallthrough case inside an outer loop | |
| 1458 // as dead loop when the phi references itselfs through an other phi. | |
| 1459 PhiNode::LoopSafety PhiNode::simple_data_loop_check(Node *in) const { | |
| 1460 // It is unsafe loop if the phi node references itself directly. | |
| 1461 if (in == (Node*)this) | |
| 1462 return UnsafeLoop; // Unsafe loop | |
| 1463 // Unsafe loop if the phi node references itself through an unsafe data node. | |
| 1464 // Exclude cases with null inputs or data nodes which could reference | |
| 1465 // itself (safe for dead loops). | |
| 1466 if (in != NULL && !in->is_dead_loop_safe()) { | |
| 1467 // Check inputs of phi's inputs also. | |
| 1468 // It is much less expensive then full graph walk. | |
| 1469 uint cnt = in->req(); | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1470 uint i = (in->is_Proj() && !in->is_CFG()) ? 0 : 1; |
|
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1471 for (; i < cnt; ++i) { |
| 0 | 1472 Node* m = in->in(i); |
| 1473 if (m == (Node*)this) | |
| 1474 return UnsafeLoop; // Unsafe loop | |
| 1475 if (m != NULL && !m->is_dead_loop_safe()) { | |
| 1476 // Check the most common case (about 30% of all cases): | |
| 1477 // phi->Load/Store->AddP->(ConP ConP Con)/(Parm Parm Con). | |
| 1478 Node *m1 = (m->is_AddP() && m->req() > 3) ? m->in(1) : NULL; | |
| 1479 if (m1 == (Node*)this) | |
| 1480 return UnsafeLoop; // Unsafe loop | |
| 1481 if (m1 != NULL && m1 == m->in(2) && | |
| 1482 m1->is_dead_loop_safe() && m->in(3)->is_Con()) { | |
| 1483 continue; // Safe case | |
| 1484 } | |
| 1485 // The phi references an unsafe node - need full analysis. | |
| 1486 return Unsafe; | |
| 1487 } | |
| 1488 } | |
| 1489 } | |
| 1490 return Safe; // Safe case - we can optimize the phi node. | |
| 1491 } | |
| 1492 | |
| 1493 //------------------------------is_unsafe_data_reference----------------------- | |
| 1494 // If phi can be reached through the data input - it is data loop. | |
| 1495 bool PhiNode::is_unsafe_data_reference(Node *in) const { | |
| 1496 assert(req() > 1, ""); | |
| 1497 // First, check simple cases when phi references itself directly or | |
| 1498 // through an other node. | |
| 1499 LoopSafety safety = simple_data_loop_check(in); | |
| 1500 if (safety == UnsafeLoop) | |
| 1501 return true; // phi references itself - unsafe loop | |
| 1502 else if (safety == Safe) | |
| 1503 return false; // Safe case - phi could be replaced with the unique input. | |
| 1504 | |
| 1505 // Unsafe case when we should go through data graph to determine | |
| 1506 // if the phi references itself. | |
| 1507 | |
| 1508 ResourceMark rm; | |
| 1509 | |
| 1510 Arena *a = Thread::current()->resource_area(); | |
| 1511 Node_List nstack(a); | |
| 1512 VectorSet visited(a); | |
| 1513 | |
| 1514 nstack.push(in); // Start with unique input. | |
| 1515 visited.set(in->_idx); | |
| 1516 while (nstack.size() != 0) { | |
| 1517 Node* n = nstack.pop(); | |
| 1518 uint cnt = n->req(); | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1519 uint i = (n->is_Proj() && !n->is_CFG()) ? 0 : 1; |
|
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1520 for (; i < cnt; i++) { |
| 0 | 1521 Node* m = n->in(i); |
| 1522 if (m == (Node*)this) { | |
| 1523 return true; // Data loop | |
| 1524 } | |
| 1525 if (m != NULL && !m->is_dead_loop_safe()) { // Only look for unsafe cases. | |
| 1526 if (!visited.test_set(m->_idx)) | |
| 1527 nstack.push(m); | |
| 1528 } | |
| 1529 } | |
| 1530 } | |
| 1531 return false; // The phi is not reachable from its inputs | |
| 1532 } | |
| 1533 | |
| 1534 | |
| 1535 //------------------------------Ideal------------------------------------------ | |
| 1536 // Return a node which is more "ideal" than the current node. Must preserve | |
| 1537 // the CFG, but we can still strip out dead paths. | |
| 1538 Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1539 // The next should never happen after 6297035 fix. | |
| 1540 if( is_copy() ) // Already degraded to a Copy ? | |
| 1541 return NULL; // No change | |
| 1542 | |
| 1543 Node *r = in(0); // RegionNode | |
| 1544 assert(r->in(0) == NULL || !r->in(0)->is_Root(), "not a specially hidden merge"); | |
| 1545 | |
| 1546 // Note: During parsing, phis are often transformed before their regions. | |
| 1547 // This means we have to use type_or_null to defend against untyped regions. | |
| 1548 if( phase->type_or_null(r) == Type::TOP ) // Dead code? | |
| 1549 return NULL; // No change | |
| 1550 | |
| 1551 Node *top = phase->C->top(); | |
|
1013
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1552 bool new_phi = (outcnt() == 0); // transforming new Phi |
|
3399
b55f5bd7ec66
7045506: assert(!can_reshape || !new_phi) failed: for igvn new phi should be hooked
kvn
parents:
3345
diff
changeset
|
1553 // No change for igvn if new phi is not hooked |
|
b55f5bd7ec66
7045506: assert(!can_reshape || !new_phi) failed: for igvn new phi should be hooked
kvn
parents:
3345
diff
changeset
|
1554 if (new_phi && can_reshape) |
|
b55f5bd7ec66
7045506: assert(!can_reshape || !new_phi) failed: for igvn new phi should be hooked
kvn
parents:
3345
diff
changeset
|
1555 return NULL; |
| 0 | 1556 |
| 1557 // The are 2 situations when only one valid phi's input is left | |
| 1558 // (in addition to Region input). | |
| 1559 // One: region is not loop - replace phi with this input. | |
| 1560 // Two: region is loop - replace phi with top since this data path is dead | |
| 1561 // and we need to break the dead data loop. | |
| 1562 Node* progress = NULL; // Record if any progress made | |
| 1563 for( uint j = 1; j < req(); ++j ){ // For all paths in | |
| 1564 // Check unreachable control paths | |
| 1565 Node* rc = r->in(j); | |
| 1566 Node* n = in(j); // Get the input | |
| 1567 if (rc == NULL || phase->type(rc) == Type::TOP) { | |
| 1568 if (n != top) { // Not already top? | |
| 1569 set_req(j, top); // Nuke it down | |
| 1570 progress = this; // Record progress | |
| 1571 } | |
| 1572 } | |
| 1573 } | |
| 1574 | |
|
1013
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1575 if (can_reshape && outcnt() == 0) { |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1576 // set_req() above may kill outputs if Phi is referenced |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1577 // only by itself on the dead (top) control path. |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1578 return top; |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1579 } |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1580 |
| 0 | 1581 Node* uin = unique_input(phase); |
| 1582 if (uin == top) { // Simplest case: no alive inputs. | |
| 1583 if (can_reshape) // IGVN transformation | |
| 1584 return top; | |
| 1585 else | |
| 1586 return NULL; // Identity will return TOP | |
| 1587 } else if (uin != NULL) { | |
| 1588 // Only one not-NULL unique input path is left. | |
| 1589 // Determine if this input is backedge of a loop. | |
| 1590 // (Skip new phis which have no uses and dead regions). | |
| 4113 | 1591 if (outcnt() > 0 && r->in(0) != NULL) { |
| 0 | 1592 // First, take the short cut when we know it is a loop and |
| 1593 // the EntryControl data path is dead. | |
| 4113 | 1594 // Loop node may have only one input because entry path |
| 1595 // is removed in PhaseIdealLoop::Dominators(). | |
| 1596 assert(!r->is_Loop() || r->req() <= 3, "Loop node should have 3 or less inputs"); | |
| 1597 bool is_loop = (r->is_Loop() && r->req() == 3); | |
| 0 | 1598 // Then, check if there is a data loop when phi references itself directly |
| 1599 // or through other data nodes. | |
| 4113 | 1600 if (is_loop && !phase->eqv_uncast(uin, in(LoopNode::EntryControl)) || |
| 1601 !is_loop && is_unsafe_data_reference(uin)) { | |
| 0 | 1602 // Break this data loop to avoid creation of a dead loop. |
| 1603 if (can_reshape) { | |
| 1604 return top; | |
| 1605 } else { | |
| 1606 // We can't return top if we are in Parse phase - cut inputs only | |
| 1607 // let Identity to handle the case. | |
| 1608 replace_edge(uin, top); | |
| 1609 return NULL; | |
| 1610 } | |
| 1611 } | |
| 1612 } | |
| 1613 | |
| 1614 // One unique input. | |
| 1615 debug_only(Node* ident = Identity(phase)); | |
| 1616 // The unique input must eventually be detected by the Identity call. | |
| 1617 #ifdef ASSERT | |
| 1618 if (ident != uin && !ident->is_top()) { | |
| 1619 // print this output before failing assert | |
| 1620 r->dump(3); | |
| 1621 this->dump(3); | |
| 1622 ident->dump(); | |
| 1623 uin->dump(); | |
| 1624 } | |
| 1625 #endif | |
| 1626 assert(ident == uin || ident->is_top(), "Identity must clean this up"); | |
| 1627 return NULL; | |
| 1628 } | |
| 1629 | |
| 1630 | |
| 1631 Node* opt = NULL; | |
| 1632 int true_path = is_diamond_phi(); | |
| 1633 if( true_path != 0 ) { | |
| 1634 // Check for CMove'ing identity. If it would be unsafe, | |
| 1635 // handle it here. In the safe case, let Identity handle it. | |
| 1636 Node* unsafe_id = is_cmove_id(phase, true_path); | |
| 1637 if( unsafe_id != NULL && is_unsafe_data_reference(unsafe_id) ) | |
| 1638 opt = unsafe_id; | |
| 1639 | |
| 1640 // Check for simple convert-to-boolean pattern | |
| 1641 if( opt == NULL ) | |
| 1642 opt = is_x2logic(phase, this, true_path); | |
| 1643 | |
| 1644 // Check for absolute value | |
| 1645 if( opt == NULL ) | |
| 1646 opt = is_absolute(phase, this, true_path); | |
| 1647 | |
| 1648 // Check for conditional add | |
| 1649 if( opt == NULL && can_reshape ) | |
| 1650 opt = is_cond_add(phase, this, true_path); | |
| 1651 | |
| 1652 // These 4 optimizations could subsume the phi: | |
| 1653 // have to check for a dead data loop creation. | |
| 1654 if( opt != NULL ) { | |
| 1655 if( opt == unsafe_id || is_unsafe_data_reference(opt) ) { | |
| 1656 // Found dead loop. | |
| 1657 if( can_reshape ) | |
| 1658 return top; | |
| 1659 // We can't return top if we are in Parse phase - cut inputs only | |
| 1660 // to stop further optimizations for this phi. Identity will return TOP. | |
| 1661 assert(req() == 3, "only diamond merge phi here"); | |
| 1662 set_req(1, top); | |
| 1663 set_req(2, top); | |
| 1664 return NULL; | |
| 1665 } else { | |
| 1666 return opt; | |
| 1667 } | |
| 1668 } | |
| 1669 } | |
| 1670 | |
| 1671 // Check for merging identical values and split flow paths | |
| 1672 if (can_reshape) { | |
| 1673 opt = split_flow_path(phase, this); | |
| 1674 // This optimization only modifies phi - don't need to check for dead loop. | |
| 1675 assert(opt == NULL || phase->eqv(opt, this), "do not elide phi"); | |
| 1676 if (opt != NULL) return opt; | |
| 1677 } | |
| 1678 | |
|
1542
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1679 if (in(1) != NULL && in(1)->Opcode() == Op_AddP && can_reshape) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1680 // Try to undo Phi of AddP: |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1681 // (Phi (AddP base base y) (AddP base2 base2 y)) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1682 // becomes: |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1683 // newbase := (Phi base base2) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1684 // (AddP newbase newbase y) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1685 // |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1686 // This occurs as a result of unsuccessful split_thru_phi and |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1687 // interferes with taking advantage of addressing modes. See the |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1688 // clone_shift_expressions code in matcher.cpp |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1689 Node* addp = in(1); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1690 const Type* type = addp->in(AddPNode::Base)->bottom_type(); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1691 Node* y = addp->in(AddPNode::Offset); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1692 if (y != NULL && addp->in(AddPNode::Base) == addp->in(AddPNode::Address)) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1693 // make sure that all the inputs are similar to the first one, |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1694 // i.e. AddP with base == address and same offset as first AddP |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1695 bool doit = true; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1696 for (uint i = 2; i < req(); i++) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1697 if (in(i) == NULL || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1698 in(i)->Opcode() != Op_AddP || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1699 in(i)->in(AddPNode::Base) != in(i)->in(AddPNode::Address) || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1700 in(i)->in(AddPNode::Offset) != y) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1701 doit = false; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1702 break; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1703 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1704 // Accumulate type for resulting Phi |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1705 type = type->meet(in(i)->in(AddPNode::Base)->bottom_type()); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1706 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1707 Node* base = NULL; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1708 if (doit) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1709 // Check for neighboring AddP nodes in a tree. |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1710 // If they have a base, use that it. |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1711 for (DUIterator_Fast kmax, k = this->fast_outs(kmax); k < kmax; k++) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1712 Node* u = this->fast_out(k); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1713 if (u->is_AddP()) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1714 Node* base2 = u->in(AddPNode::Base); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1715 if (base2 != NULL && !base2->is_top()) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1716 if (base == NULL) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1717 base = base2; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1718 else if (base != base2) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1719 { doit = false; break; } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1720 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1721 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1722 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1723 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1724 if (doit) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1725 if (base == NULL) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1726 base = new (phase->C, in(0)->req()) PhiNode(in(0), type, NULL); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1727 for (uint i = 1; i < req(); i++) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1728 base->init_req(i, in(i)->in(AddPNode::Base)); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1729 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1730 phase->is_IterGVN()->register_new_node_with_optimizer(base); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1731 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1732 return new (phase->C, 4) AddPNode(base, base, y); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1733 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1734 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1735 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1736 |
| 0 | 1737 // Split phis through memory merges, so that the memory merges will go away. |
| 1738 // Piggy-back this transformation on the search for a unique input.... | |
| 1739 // It will be as if the merged memory is the unique value of the phi. | |
| 1740 // (Do not attempt this optimization unless parsing is complete. | |
| 1741 // It would make the parser's memory-merge logic sick.) | |
| 1742 // (MergeMemNode is not dead_loop_safe - need to check for dead loop.) | |
| 1743 if (progress == NULL && can_reshape && type() == Type::MEMORY) { | |
| 1744 // see if this phi should be sliced | |
| 1745 uint merge_width = 0; | |
| 1746 bool saw_self = false; | |
| 1747 for( uint i=1; i<req(); ++i ) {// For all paths in | |
| 1748 Node *ii = in(i); | |
| 1749 if (ii->is_MergeMem()) { | |
| 1750 MergeMemNode* n = ii->as_MergeMem(); | |
| 1751 merge_width = MAX2(merge_width, n->req()); | |
| 1752 saw_self = saw_self || phase->eqv(n->base_memory(), this); | |
| 1753 } | |
| 1754 } | |
| 1755 | |
| 1756 // This restriction is temporarily necessary to ensure termination: | |
| 1757 if (!saw_self && adr_type() == TypePtr::BOTTOM) merge_width = 0; | |
| 1758 | |
| 1759 if (merge_width > Compile::AliasIdxRaw) { | |
| 1760 // found at least one non-empty MergeMem | |
| 1761 const TypePtr* at = adr_type(); | |
| 1762 if (at != TypePtr::BOTTOM) { | |
| 1763 // Patch the existing phi to select an input from the merge: | |
| 1764 // Phi:AT1(...MergeMem(m0, m1, m2)...) into | |
| 1765 // Phi:AT1(...m1...) | |
| 1766 int alias_idx = phase->C->get_alias_index(at); | |
| 1767 for (uint i=1; i<req(); ++i) { | |
| 1768 Node *ii = in(i); | |
| 1769 if (ii->is_MergeMem()) { | |
| 1770 MergeMemNode* n = ii->as_MergeMem(); | |
| 1771 // compress paths and change unreachable cycles to TOP | |
| 1772 // If not, we can update the input infinitely along a MergeMem cycle | |
| 1773 // Equivalent code is in MemNode::Ideal_common | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
247
diff
changeset
|
1774 Node *m = phase->transform(n); |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
247
diff
changeset
|
1775 if (outcnt() == 0) { // Above transform() may kill us! |
|
1013
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1776 return top; |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
247
diff
changeset
|
1777 } |
| 605 | 1778 // If transformed to a MergeMem, get the desired slice |
| 0 | 1779 // Otherwise the returned node represents memory for every slice |
| 1780 Node *new_mem = (m->is_MergeMem()) ? | |
| 1781 m->as_MergeMem()->memory_at(alias_idx) : m; | |
| 1782 // Update input if it is progress over what we have now | |
| 1783 if (new_mem != ii) { | |
| 1784 set_req(i, new_mem); | |
| 1785 progress = this; | |
| 1786 } | |
| 1787 } | |
| 1788 } | |
| 1789 } else { | |
| 1790 // We know that at least one MergeMem->base_memory() == this | |
| 1791 // (saw_self == true). If all other inputs also references this phi | |
| 1792 // (directly or through data nodes) - it is dead loop. | |
| 1793 bool saw_safe_input = false; | |
| 1794 for (uint j = 1; j < req(); ++j) { | |
| 1795 Node *n = in(j); | |
| 1796 if (n->is_MergeMem() && n->as_MergeMem()->base_memory() == this) | |
| 1797 continue; // skip known cases | |
| 1798 if (!is_unsafe_data_reference(n)) { | |
| 1799 saw_safe_input = true; // found safe input | |
| 1800 break; | |
| 1801 } | |
| 1802 } | |
| 1803 if (!saw_safe_input) | |
| 1804 return top; // all inputs reference back to this phi - dead loop | |
| 1805 | |
| 1806 // Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into | |
| 1807 // MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...)) | |
| 1808 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 1809 Node* hook = new (phase->C, 1) Node(1); | |
| 1810 PhiNode* new_base = (PhiNode*) clone(); | |
| 1811 // Must eagerly register phis, since they participate in loops. | |
| 1812 if (igvn) { | |
| 1813 igvn->register_new_node_with_optimizer(new_base); | |
| 1814 hook->add_req(new_base); | |
| 1815 } | |
| 1816 MergeMemNode* result = MergeMemNode::make(phase->C, new_base); | |
| 1817 for (uint i = 1; i < req(); ++i) { | |
| 1818 Node *ii = in(i); | |
| 1819 if (ii->is_MergeMem()) { | |
| 1820 MergeMemNode* n = ii->as_MergeMem(); | |
| 1821 for (MergeMemStream mms(result, n); mms.next_non_empty2(); ) { | |
| 1822 // If we have not seen this slice yet, make a phi for it. | |
| 1823 bool made_new_phi = false; | |
| 1824 if (mms.is_empty()) { | |
| 1825 Node* new_phi = new_base->slice_memory(mms.adr_type(phase->C)); | |
| 1826 made_new_phi = true; | |
| 1827 if (igvn) { | |
| 1828 igvn->register_new_node_with_optimizer(new_phi); | |
| 1829 hook->add_req(new_phi); | |
| 1830 } | |
| 1831 mms.set_memory(new_phi); | |
| 1832 } | |
| 1833 Node* phi = mms.memory(); | |
| 1834 assert(made_new_phi || phi->in(i) == n, "replace the i-th merge by a slice"); | |
| 1835 phi->set_req(i, mms.memory2()); | |
| 1836 } | |
| 1837 } | |
| 1838 } | |
| 1839 // Distribute all self-loops. | |
| 1840 { // (Extra braces to hide mms.) | |
| 1841 for (MergeMemStream mms(result); mms.next_non_empty(); ) { | |
| 1842 Node* phi = mms.memory(); | |
| 1843 for (uint i = 1; i < req(); ++i) { | |
| 1844 if (phi->in(i) == this) phi->set_req(i, phi); | |
| 1845 } | |
| 1846 } | |
| 1847 } | |
| 1848 // now transform the new nodes, and return the mergemem | |
| 1849 for (MergeMemStream mms(result); mms.next_non_empty(); ) { | |
| 1850 Node* phi = mms.memory(); | |
| 1851 mms.set_memory(phase->transform(phi)); | |
| 1852 } | |
| 1853 if (igvn) { // Unhook. | |
| 1854 igvn->hash_delete(hook); | |
| 1855 for (uint i = 1; i < hook->req(); i++) { | |
| 1856 hook->set_req(i, NULL); | |
| 1857 } | |
| 1858 } | |
| 1859 // Replace self with the result. | |
| 1860 return result; | |
| 1861 } | |
| 1862 } | |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1863 // |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1864 // Other optimizations on the memory chain |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1865 // |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1866 const TypePtr* at = adr_type(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1867 for( uint i=1; i<req(); ++i ) {// For all paths in |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1868 Node *ii = in(i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1869 Node *new_in = MemNode::optimize_memory_chain(ii, at, phase); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1870 if (ii != new_in ) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1871 set_req(i, new_in); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1872 progress = this; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1873 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1874 } |
| 0 | 1875 } |
| 1876 | |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1877 #ifdef _LP64 |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1878 // Push DecodeN down through phi. |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1879 // The rest of phi graph will transform by split EncodeP node though phis up. |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1880 if (UseCompressedOops && can_reshape && progress == NULL) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1881 bool may_push = true; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1882 bool has_decodeN = false; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1883 for (uint i=1; i<req(); ++i) {// For all paths in |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1884 Node *ii = in(i); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1885 if (ii->is_DecodeN() && ii->bottom_type() == bottom_type()) { |
|
899
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1886 // Do optimization if a non dead path exist. |
|
853
64219d2a6493
6851282: JIT miscompilation results in null entry in array when using CompressedOops
kvn
parents:
628
diff
changeset
|
1887 if (ii->in(1)->bottom_type() != Type::TOP) { |
|
64219d2a6493
6851282: JIT miscompilation results in null entry in array when using CompressedOops
kvn
parents:
628
diff
changeset
|
1888 has_decodeN = true; |
|
64219d2a6493
6851282: JIT miscompilation results in null entry in array when using CompressedOops
kvn
parents:
628
diff
changeset
|
1889 } |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1890 } else if (!ii->is_Phi()) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1891 may_push = false; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1892 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1893 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1894 |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1895 if (has_decodeN && may_push) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1896 PhaseIterGVN *igvn = phase->is_IterGVN(); |
|
899
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1897 // Make narrow type for new phi. |
|
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1898 const Type* narrow_t = TypeNarrowOop::make(this->bottom_type()->is_ptr()); |
|
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1899 PhiNode* new_phi = new (phase->C, r->req()) PhiNode(r, narrow_t); |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1900 uint orig_cnt = req(); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1901 for (uint i=1; i<req(); ++i) {// For all paths in |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1902 Node *ii = in(i); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1903 Node* new_ii = NULL; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1904 if (ii->is_DecodeN()) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1905 assert(ii->bottom_type() == bottom_type(), "sanity"); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1906 new_ii = ii->in(1); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1907 } else { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1908 assert(ii->is_Phi(), "sanity"); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1909 if (ii->as_Phi() == this) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1910 new_ii = new_phi; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1911 } else { |
|
899
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1912 new_ii = new (phase->C, 2) EncodePNode(ii, narrow_t); |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1913 igvn->register_new_node_with_optimizer(new_ii); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1914 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1915 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1916 new_phi->set_req(i, new_ii); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1917 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1918 igvn->register_new_node_with_optimizer(new_phi, this); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1919 progress = new (phase->C, 2) DecodeNNode(new_phi, bottom_type()); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1920 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1921 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1922 #endif |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1923 |
| 0 | 1924 return progress; // Return any progress |
| 1925 } | |
| 1926 | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1927 //------------------------------is_tripcount----------------------------------- |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1928 bool PhiNode::is_tripcount() const { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1929 return (in(0) != NULL && in(0)->is_CountedLoop() && |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1930 in(0)->as_CountedLoop()->phi() == this); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1931 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1932 |
| 0 | 1933 //------------------------------out_RegMask------------------------------------ |
| 1934 const RegMask &PhiNode::in_RegMask(uint i) const { | |
| 1935 return i ? out_RegMask() : RegMask::Empty; | |
| 1936 } | |
| 1937 | |
| 1938 const RegMask &PhiNode::out_RegMask() const { | |
| 1939 uint ideal_reg = Matcher::base2reg[_type->base()]; | |
| 1940 assert( ideal_reg != Node::NotAMachineReg, "invalid type at Phi" ); | |
| 1941 if( ideal_reg == 0 ) return RegMask::Empty; | |
| 1942 return *(Compile::current()->matcher()->idealreg2spillmask[ideal_reg]); | |
| 1943 } | |
| 1944 | |
| 1945 #ifndef PRODUCT | |
| 1946 void PhiNode::dump_spec(outputStream *st) const { | |
| 1947 TypeNode::dump_spec(st); | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1948 if (is_tripcount()) { |
| 0 | 1949 st->print(" #tripcount"); |
| 1950 } | |
| 1951 } | |
| 1952 #endif | |
| 1953 | |
| 1954 | |
| 1955 //============================================================================= | |
| 1956 const Type *GotoNode::Value( PhaseTransform *phase ) const { | |
| 1957 // If the input is reachable, then we are executed. | |
| 1958 // If the input is not reachable, then we are not executed. | |
| 1959 return phase->type(in(0)); | |
| 1960 } | |
| 1961 | |
| 1962 Node *GotoNode::Identity( PhaseTransform *phase ) { | |
| 1963 return in(0); // Simple copy of incoming control | |
| 1964 } | |
| 1965 | |
| 1966 const RegMask &GotoNode::out_RegMask() const { | |
| 1967 return RegMask::Empty; | |
| 1968 } | |
| 1969 | |
| 1970 //============================================================================= | |
| 1971 const RegMask &JumpNode::out_RegMask() const { | |
| 1972 return RegMask::Empty; | |
| 1973 } | |
| 1974 | |
| 1975 //============================================================================= | |
| 1976 const RegMask &JProjNode::out_RegMask() const { | |
| 1977 return RegMask::Empty; | |
| 1978 } | |
| 1979 | |
| 1980 //============================================================================= | |
| 1981 const RegMask &CProjNode::out_RegMask() const { | |
| 1982 return RegMask::Empty; | |
| 1983 } | |
| 1984 | |
| 1985 | |
| 1986 | |
| 1987 //============================================================================= | |
| 1988 | |
| 1989 uint PCTableNode::hash() const { return Node::hash() + _size; } | |
| 1990 uint PCTableNode::cmp( const Node &n ) const | |
| 1991 { return _size == ((PCTableNode&)n)._size; } | |
| 1992 | |
| 1993 const Type *PCTableNode::bottom_type() const { | |
| 1994 const Type** f = TypeTuple::fields(_size); | |
| 1995 for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; | |
| 1996 return TypeTuple::make(_size, f); | |
| 1997 } | |
| 1998 | |
| 1999 //------------------------------Value------------------------------------------ | |
| 2000 // Compute the type of the PCTableNode. If reachable it is a tuple of | |
| 2001 // Control, otherwise the table targets are not reachable | |
| 2002 const Type *PCTableNode::Value( PhaseTransform *phase ) const { | |
| 2003 if( phase->type(in(0)) == Type::CONTROL ) | |
| 2004 return bottom_type(); | |
| 2005 return Type::TOP; // All paths dead? Then so are we | |
| 2006 } | |
| 2007 | |
| 2008 //------------------------------Ideal------------------------------------------ | |
| 2009 // Return a node which is more "ideal" than the current node. Strip out | |
| 2010 // control copies | |
| 2011 Node *PCTableNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 2012 return remove_dead_region(phase, can_reshape) ? this : NULL; | |
| 2013 } | |
| 2014 | |
| 2015 //============================================================================= | |
| 2016 uint JumpProjNode::hash() const { | |
| 2017 return Node::hash() + _dest_bci; | |
| 2018 } | |
| 2019 | |
| 2020 uint JumpProjNode::cmp( const Node &n ) const { | |
| 2021 return ProjNode::cmp(n) && | |
| 2022 _dest_bci == ((JumpProjNode&)n)._dest_bci; | |
| 2023 } | |
| 2024 | |
| 2025 #ifndef PRODUCT | |
| 2026 void JumpProjNode::dump_spec(outputStream *st) const { | |
| 2027 ProjNode::dump_spec(st); | |
| 2028 st->print("@bci %d ",_dest_bci); | |
| 2029 } | |
| 2030 #endif | |
| 2031 | |
| 2032 //============================================================================= | |
| 2033 //------------------------------Value------------------------------------------ | |
| 2034 // Check for being unreachable, or for coming from a Rethrow. Rethrow's cannot | |
| 2035 // have the default "fall_through_index" path. | |
| 2036 const Type *CatchNode::Value( PhaseTransform *phase ) const { | |
| 2037 // Unreachable? Then so are all paths from here. | |
| 2038 if( phase->type(in(0)) == Type::TOP ) return Type::TOP; | |
| 2039 // First assume all paths are reachable | |
| 2040 const Type** f = TypeTuple::fields(_size); | |
| 2041 for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; | |
| 2042 // Identify cases that will always throw an exception | |
| 2043 // () rethrow call | |
| 2044 // () virtual or interface call with NULL receiver | |
| 2045 // () call is a check cast with incompatible arguments | |
| 2046 if( in(1)->is_Proj() ) { | |
| 2047 Node *i10 = in(1)->in(0); | |
| 2048 if( i10->is_Call() ) { | |
| 2049 CallNode *call = i10->as_Call(); | |
| 2050 // Rethrows always throw exceptions, never return | |
| 2051 if (call->entry_point() == OptoRuntime::rethrow_stub()) { | |
| 2052 f[CatchProjNode::fall_through_index] = Type::TOP; | |
| 2053 } else if( call->req() > TypeFunc::Parms ) { | |
| 2054 const Type *arg0 = phase->type( call->in(TypeFunc::Parms) ); | |
| 605 | 2055 // Check for null receiver to virtual or interface calls |
| 0 | 2056 if( call->is_CallDynamicJava() && |
| 2057 arg0->higher_equal(TypePtr::NULL_PTR) ) { | |
| 2058 f[CatchProjNode::fall_through_index] = Type::TOP; | |
| 2059 } | |
| 2060 } // End of if not a runtime stub | |
| 2061 } // End of if have call above me | |
| 2062 } // End of slot 1 is not a projection | |
| 2063 return TypeTuple::make(_size, f); | |
| 2064 } | |
| 2065 | |
| 2066 //============================================================================= | |
| 2067 uint CatchProjNode::hash() const { | |
| 2068 return Node::hash() + _handler_bci; | |
| 2069 } | |
| 2070 | |
| 2071 | |
| 2072 uint CatchProjNode::cmp( const Node &n ) const { | |
| 2073 return ProjNode::cmp(n) && | |
| 2074 _handler_bci == ((CatchProjNode&)n)._handler_bci; | |
| 2075 } | |
| 2076 | |
| 2077 | |
| 2078 //------------------------------Identity--------------------------------------- | |
| 2079 // If only 1 target is possible, choose it if it is the main control | |
| 2080 Node *CatchProjNode::Identity( PhaseTransform *phase ) { | |
| 2081 // If my value is control and no other value is, then treat as ID | |
| 2082 const TypeTuple *t = phase->type(in(0))->is_tuple(); | |
| 2083 if (t->field_at(_con) != Type::CONTROL) return this; | |
| 2084 // If we remove the last CatchProj and elide the Catch/CatchProj, then we | |
| 2085 // also remove any exception table entry. Thus we must know the call | |
| 2086 // feeding the Catch will not really throw an exception. This is ok for | |
| 2087 // the main fall-thru control (happens when we know a call can never throw | |
| 605 | 2088 // an exception) or for "rethrow", because a further optimization will |
| 0 | 2089 // yank the rethrow (happens when we inline a function that can throw an |
| 2090 // exception and the caller has no handler). Not legal, e.g., for passing | |
| 2091 // a NULL receiver to a v-call, or passing bad types to a slow-check-cast. | |
| 2092 // These cases MUST throw an exception via the runtime system, so the VM | |
| 2093 // will be looking for a table entry. | |
| 2094 Node *proj = in(0)->in(1); // Expect a proj feeding CatchNode | |
| 2095 CallNode *call; | |
| 2096 if (_con != TypeFunc::Control && // Bail out if not the main control. | |
| 2097 !(proj->is_Proj() && // AND NOT a rethrow | |
| 2098 proj->in(0)->is_Call() && | |
| 2099 (call = proj->in(0)->as_Call()) && | |
| 2100 call->entry_point() == OptoRuntime::rethrow_stub())) | |
| 2101 return this; | |
| 2102 | |
| 2103 // Search for any other path being control | |
| 2104 for (uint i = 0; i < t->cnt(); i++) { | |
| 2105 if (i != _con && t->field_at(i) == Type::CONTROL) | |
| 2106 return this; | |
| 2107 } | |
| 2108 // Only my path is possible; I am identity on control to the jump | |
| 2109 return in(0)->in(0); | |
| 2110 } | |
| 2111 | |
| 2112 | |
| 2113 #ifndef PRODUCT | |
| 2114 void CatchProjNode::dump_spec(outputStream *st) const { | |
| 2115 ProjNode::dump_spec(st); | |
| 2116 st->print("@bci %d ",_handler_bci); | |
| 2117 } | |
| 2118 #endif | |
| 2119 | |
| 2120 //============================================================================= | |
| 2121 //------------------------------Identity--------------------------------------- | |
| 2122 // Check for CreateEx being Identity. | |
| 2123 Node *CreateExNode::Identity( PhaseTransform *phase ) { | |
| 2124 if( phase->type(in(1)) == Type::TOP ) return in(1); | |
| 2125 if( phase->type(in(0)) == Type::TOP ) return in(0); | |
| 2126 // We only come from CatchProj, unless the CatchProj goes away. | |
| 2127 // If the CatchProj is optimized away, then we just carry the | |
| 2128 // exception oop through. | |
| 2129 CallNode *call = in(1)->in(0)->as_Call(); | |
| 2130 | |
| 2131 return ( in(0)->is_CatchProj() && in(0)->in(0)->in(1) == in(1) ) | |
| 2132 ? this | |
| 2133 : call->in(TypeFunc::Parms); | |
| 2134 } | |
| 2135 | |
| 2136 //============================================================================= | |
| 127 | 2137 //------------------------------Value------------------------------------------ |
| 2138 // Check for being unreachable. | |
| 2139 const Type *NeverBranchNode::Value( PhaseTransform *phase ) const { | |
| 2140 if (!in(0) || in(0)->is_top()) return Type::TOP; | |
| 2141 return bottom_type(); | |
| 2142 } | |
| 2143 | |
| 2144 //------------------------------Ideal------------------------------------------ | |
| 2145 // Check for no longer being part of a loop | |
| 2146 Node *NeverBranchNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 2147 if (can_reshape && !in(0)->is_Loop()) { | |
| 2148 // Dead code elimination can sometimes delete this projection so | |
| 2149 // if it's not there, there's nothing to do. | |
| 2150 Node* fallthru = proj_out(0); | |
| 2151 if (fallthru != NULL) { | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
2152 phase->is_IterGVN()->replace_node(fallthru, in(0)); |
| 127 | 2153 } |
| 2154 return phase->C->top(); | |
| 2155 } | |
| 2156 return NULL; | |
| 2157 } | |
| 2158 | |
| 0 | 2159 #ifndef PRODUCT |
| 2160 void NeverBranchNode::format( PhaseRegAlloc *ra_, outputStream *st) const { | |
| 2161 st->print("%s", Name()); | |
| 2162 } | |
| 2163 #endif |