Mercurial > hg > truffle
annotate src/share/vm/opto/cfgnode.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 08eb13460b3a |
| 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. | |
| 463 assert(!this->is_Loop() || cnt_orig == 3, "Loop node should have 3 inputs"); | |
| 464 if (this->is_Loop() && del_it == LoopNode::EntryControl || | |
| 465 !this->is_Loop() && has_phis && is_unreachable_region(phase)) { | |
| 466 // Yes, the region will be removed during the next step below. | |
| 467 // Cut the backedge input and remove phis since no data paths left. | |
| 468 // We don't cut outputs to other nodes here since we need to put them | |
| 469 // on the worklist. | |
| 470 del_req(1); | |
| 471 cnt = 0; | |
| 472 assert( req() == 1, "no more inputs expected" ); | |
| 473 uint max = outcnt(); | |
| 474 bool progress = true; | |
| 475 Node *top = phase->C->top(); | |
| 476 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 477 DUIterator j; | |
| 478 while(progress) { | |
| 479 progress = false; | |
| 480 for (j = outs(); has_out(j); j++) { | |
| 481 Node *n = out(j); | |
| 482 if( n->is_Phi() ) { | |
| 483 assert( igvn->eqv(n->in(0), this), "" ); | |
| 484 assert( n->req() == 2 && n->in(1) != NULL, "Only one data input expected" ); | |
| 485 // Break dead loop data path. | |
| 486 // 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
|
487 igvn->replace_node(n, top); |
| 0 | 488 if( max != outcnt() ) { |
| 489 progress = true; | |
| 490 j = refresh_out_pos(j); | |
| 491 max = outcnt(); | |
| 492 } | |
| 493 } | |
| 494 } | |
| 495 } | |
| 496 add_to_worklist = true; | |
| 497 } | |
| 498 } | |
| 499 if (add_to_worklist) { | |
| 500 phase->is_IterGVN()->add_users_to_worklist(this); // Revisit collapsed Phis | |
| 501 } | |
| 502 | |
| 503 if( cnt <= 1 ) { // Only 1 path in? | |
| 504 set_req(0, NULL); // Null control input for region copy | |
| 505 if( cnt == 0 && !can_reshape) { // Parse phase - leave the node as it is. | |
| 506 // No inputs or all inputs are NULL. | |
| 507 return NULL; | |
| 508 } else if (can_reshape) { // Optimization phase - remove the node | |
| 509 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 510 Node *parent_ctrl; | |
| 511 if( cnt == 0 ) { | |
| 512 assert( req() == 1, "no inputs expected" ); | |
| 513 // During IGVN phase such region will be subsumed by TOP node | |
| 514 // so region's phis will have TOP as control node. | |
| 515 // Kill phis here to avoid it. PhiNode::is_copy() will be always false. | |
| 516 // Also set other user's input to top. | |
| 517 parent_ctrl = phase->C->top(); | |
| 518 } else { | |
| 519 // The fallthrough case since we already checked dead loops above. | |
| 520 parent_ctrl = in(1); | |
| 521 assert(parent_ctrl != NULL, "Region is a copy of some non-null control"); | |
| 522 assert(!igvn->eqv(parent_ctrl, this), "Close dead loop"); | |
| 523 } | |
| 524 if (!add_to_worklist) | |
| 525 igvn->add_users_to_worklist(this); // Check for further allowed opts | |
| 526 for (DUIterator_Last imin, i = last_outs(imin); i >= imin; --i) { | |
| 527 Node* n = last_out(i); | |
| 528 igvn->hash_delete(n); // Remove from worklist before modifying edges | |
| 529 if( n->is_Phi() ) { // Collapse all Phis | |
| 530 // 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
|
531 Node* in; |
| 0 | 532 if( cnt == 0 ) { |
| 533 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
|
534 in = parent_ctrl; // replaced by top |
| 0 | 535 } else { |
| 536 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
|
537 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
|
538 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
|
539 in = phase->C->top(); // replaced by top |
| 0 | 540 } |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
541 igvn->replace_node(n, in); |
| 0 | 542 } |
| 543 else if( n->is_Region() ) { // Update all incoming edges | |
| 544 assert( !igvn->eqv(n, this), "Must be removed from DefUse edges"); | |
| 545 uint uses_found = 0; | |
| 546 for( uint k=1; k < n->req(); k++ ) { | |
| 547 if( n->in(k) == this ) { | |
| 548 n->set_req(k, parent_ctrl); | |
| 549 uses_found++; | |
| 550 } | |
| 551 } | |
| 552 if( uses_found > 1 ) { // (--i) done at the end of the loop. | |
| 553 i -= (uses_found - 1); | |
| 554 } | |
| 555 } | |
| 556 else { | |
| 557 assert( igvn->eqv(n->in(0), this), "Expect RegionNode to be control parent"); | |
| 558 n->set_req(0, parent_ctrl); | |
| 559 } | |
| 560 #ifdef ASSERT | |
| 561 for( uint k=0; k < n->req(); k++ ) { | |
| 562 assert( !igvn->eqv(n->in(k), this), "All uses of RegionNode should be gone"); | |
| 563 } | |
| 564 #endif | |
| 565 } | |
| 566 // Remove the RegionNode itself from DefUse info | |
| 567 igvn->remove_dead_node(this); | |
| 568 return NULL; | |
| 569 } | |
| 570 return this; // Record progress | |
| 571 } | |
| 572 | |
| 573 | |
| 574 // If a Region flows into a Region, merge into one big happy merge. | |
| 575 if (can_reshape) { | |
| 576 Node *m = merge_region(this, phase); | |
| 577 if (m != NULL) return m; | |
| 578 } | |
| 579 | |
| 580 // Check if this region is the root of a clipping idiom on floats | |
| 581 if( ConvertFloat2IntClipping && can_reshape && req() == 4 ) { | |
| 582 // Check that only one use is a Phi and that it simplifies to two constants + | |
| 583 PhiNode* phi = has_unique_phi(); | |
| 584 if (phi != NULL) { // One Phi user | |
| 585 // Check inputs to the Phi | |
| 586 ConNode *min; | |
| 587 ConNode *max; | |
| 588 Node *val; | |
| 589 uint min_idx; | |
| 590 uint max_idx; | |
| 591 uint val_idx; | |
| 592 if( check_phi_clipping( phi, min, min_idx, max, max_idx, val, val_idx ) ) { | |
| 593 IfNode *top_if; | |
| 594 IfNode *bot_if; | |
| 595 if( check_if_clipping( this, bot_if, top_if ) ) { | |
| 596 // Control pattern checks, now verify compares | |
| 597 Node *top_in = NULL; // value being compared against | |
| 598 Node *bot_in = NULL; | |
| 599 if( check_compare_clipping( true, bot_if, min, bot_in ) && | |
| 600 check_compare_clipping( false, top_if, max, top_in ) ) { | |
| 601 if( bot_in == top_in ) { | |
| 602 PhaseIterGVN *gvn = phase->is_IterGVN(); | |
| 603 assert( gvn != NULL, "Only had DefUse info in IterGVN"); | |
| 604 // Only remaining check is that bot_in == top_in == (Phi's val + mods) | |
| 605 | |
| 606 // Check for the ConvF2INode | |
| 607 ConvF2INode *convf2i; | |
| 608 if( check_convf2i_clipping( phi, val_idx, convf2i, min, max ) && | |
| 609 convf2i->in(1) == bot_in ) { | |
| 610 // Matched pattern, including LShiftI; RShiftI, replace with integer compares | |
| 611 // max test | |
| 612 Node *cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, min )); | |
| 613 Node *boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::lt )); | |
| 614 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 )); | |
| 615 Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); | |
| 616 Node *ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); | |
| 617 // min test | |
| 618 cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, max )); | |
| 619 boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::gt )); | |
| 620 iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C, 2) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt )); | |
| 621 Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); | |
| 622 ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); | |
| 623 // update input edges to region node | |
| 624 set_req_X( min_idx, if_min, gvn ); | |
| 625 set_req_X( max_idx, if_max, gvn ); | |
| 626 set_req_X( val_idx, ifF, gvn ); | |
| 627 // remove unnecessary 'LShiftI; RShiftI' idiom | |
| 628 gvn->hash_delete(phi); | |
| 629 phi->set_req_X( val_idx, convf2i, gvn ); | |
| 630 gvn->hash_find_insert(phi); | |
| 631 // Return transformed region node | |
| 632 return this; | |
| 633 } | |
| 634 } | |
| 635 } | |
| 636 } | |
| 637 } | |
| 638 } | |
| 639 } | |
| 640 | |
| 641 return NULL; | |
| 642 } | |
| 643 | |
| 644 | |
| 645 | |
| 646 const RegMask &RegionNode::out_RegMask() const { | |
| 647 return RegMask::Empty; | |
| 648 } | |
| 649 | |
| 650 // Find the one non-null required input. RegionNode only | |
| 651 Node *Node::nonnull_req() const { | |
| 652 assert( is_Region(), "" ); | |
| 653 for( uint i = 1; i < _cnt; i++ ) | |
| 654 if( in(i) ) | |
| 655 return in(i); | |
| 656 ShouldNotReachHere(); | |
| 657 return NULL; | |
| 658 } | |
| 659 | |
| 660 | |
| 661 //============================================================================= | |
| 662 // note that these functions assume that the _adr_type field is flattened | |
| 663 uint PhiNode::hash() const { | |
| 664 const Type* at = _adr_type; | |
| 665 return TypeNode::hash() + (at ? at->hash() : 0); | |
| 666 } | |
| 667 uint PhiNode::cmp( const Node &n ) const { | |
| 668 return TypeNode::cmp(n) && _adr_type == ((PhiNode&)n)._adr_type; | |
| 669 } | |
| 670 static inline | |
| 671 const TypePtr* flatten_phi_adr_type(const TypePtr* at) { | |
| 672 if (at == NULL || at == TypePtr::BOTTOM) return at; | |
| 673 return Compile::current()->alias_type(at)->adr_type(); | |
| 674 } | |
| 675 | |
| 676 //----------------------------make--------------------------------------------- | |
| 677 // create a new phi with edges matching r and set (initially) to x | |
| 678 PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) { | |
| 679 uint preds = r->req(); // Number of predecessor paths | |
| 680 assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at"); | |
| 681 PhiNode* p = new (Compile::current(), preds) PhiNode(r, t, at); | |
| 682 for (uint j = 1; j < preds; j++) { | |
| 683 // Fill in all inputs, except those which the region does not yet have | |
| 684 if (r->in(j) != NULL) | |
| 685 p->init_req(j, x); | |
| 686 } | |
| 687 return p; | |
| 688 } | |
| 689 PhiNode* PhiNode::make(Node* r, Node* x) { | |
| 690 const Type* t = x->bottom_type(); | |
| 691 const TypePtr* at = NULL; | |
| 692 if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); | |
| 693 return make(r, x, t, at); | |
| 694 } | |
| 695 PhiNode* PhiNode::make_blank(Node* r, Node* x) { | |
| 696 const Type* t = x->bottom_type(); | |
| 697 const TypePtr* at = NULL; | |
| 698 if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); | |
| 699 return new (Compile::current(), r->req()) PhiNode(r, t, at); | |
| 700 } | |
| 701 | |
| 702 | |
| 703 //------------------------slice_memory----------------------------------------- | |
| 704 // create a new phi with narrowed memory type | |
| 705 PhiNode* PhiNode::slice_memory(const TypePtr* adr_type) const { | |
| 706 PhiNode* mem = (PhiNode*) clone(); | |
| 707 *(const TypePtr**)&mem->_adr_type = adr_type; | |
| 708 // convert self-loops, or else we get a bad graph | |
| 709 for (uint i = 1; i < req(); i++) { | |
| 710 if ((const Node*)in(i) == this) mem->set_req(i, mem); | |
| 711 } | |
| 712 mem->verify_adr_type(); | |
| 713 return mem; | |
| 714 } | |
| 715 | |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
716 //------------------------split_out_instance----------------------------------- |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
717 // 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
|
718 PhiNode* PhiNode::split_out_instance(const TypePtr* at, PhaseIterGVN *igvn) const { |
| 163 | 719 const TypeOopPtr *t_oop = at->isa_oopptr(); |
| 223 | 720 assert(t_oop != NULL && t_oop->is_known_instance(), "expecting instance oopptr"); |
| 163 | 721 const TypePtr *t = adr_type(); |
| 722 assert(type() == Type::MEMORY && | |
| 723 (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM || | |
| 223 | 724 t->isa_oopptr() && !t->is_oopptr()->is_known_instance() && |
| 247 | 725 t->is_oopptr()->cast_to_exactness(true) |
| 726 ->is_oopptr()->cast_to_ptr_type(t_oop->ptr()) | |
| 727 ->is_oopptr()->cast_to_instance_id(t_oop->instance_id()) == t_oop), | |
| 163 | 728 "bottom or raw memory required"); |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
729 |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
730 // Check if an appropriate node already exists. |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
731 Node *region = in(0); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
732 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
|
733 Node* use = region->fast_out(k); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
734 if( use->is_Phi()) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
735 PhiNode *phi2 = use->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
736 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
|
737 return phi2; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
738 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
739 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
740 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
741 Compile *C = igvn->C; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
742 Arena *a = Thread::current()->resource_area(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
743 Node_Array node_map = new Node_Array(a); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
744 Node_Stack stack(a, C->unique() >> 4); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
745 PhiNode *nphi = slice_memory(at); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
746 igvn->register_new_node_with_optimizer( nphi ); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
747 node_map.map(_idx, nphi); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
748 stack.push((Node *)this, 1); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
749 while(!stack.is_empty()) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
750 PhiNode *ophi = stack.node()->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
751 uint i = stack.index(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
752 assert(i >= 1, "not control edge"); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
753 stack.pop(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
754 nphi = node_map[ophi->_idx]->as_Phi(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
755 for (; i < ophi->req(); i++) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
756 Node *in = ophi->in(i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
757 if (in == NULL || igvn->type(in) == Type::TOP) |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
758 continue; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
759 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
|
760 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
|
761 if (optphi != NULL && optphi->adr_type() == TypePtr::BOTTOM) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
762 opt = node_map[optphi->_idx]; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
763 if (opt == NULL) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
764 stack.push(ophi, i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
765 nphi = optphi->slice_memory(at); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
766 igvn->register_new_node_with_optimizer( nphi ); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
767 node_map.map(optphi->_idx, nphi); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
768 ophi = optphi; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
769 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
|
770 continue; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
771 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
772 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
773 nphi->set_req(i, opt); |
|
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 return nphi; |
|
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 |
| 0 | 779 //------------------------verify_adr_type-------------------------------------- |
| 780 #ifdef ASSERT | |
| 781 void PhiNode::verify_adr_type(VectorSet& visited, const TypePtr* at) const { | |
| 782 if (visited.test_set(_idx)) return; //already visited | |
| 783 | |
| 784 // recheck constructor invariants: | |
| 785 verify_adr_type(false); | |
| 786 | |
| 787 // recheck local phi/phi consistency: | |
| 788 assert(_adr_type == at || _adr_type == TypePtr::BOTTOM, | |
| 789 "adr_type must be consistent across phi nest"); | |
| 790 | |
| 791 // walk around | |
| 792 for (uint i = 1; i < req(); i++) { | |
| 793 Node* n = in(i); | |
| 794 if (n == NULL) continue; | |
| 795 const Node* np = in(i); | |
| 796 if (np->is_Phi()) { | |
| 797 np->as_Phi()->verify_adr_type(visited, at); | |
| 798 } else if (n->bottom_type() == Type::TOP | |
| 799 || (n->is_Mem() && n->in(MemNode::Address)->bottom_type() == Type::TOP)) { | |
| 800 // ignore top inputs | |
| 801 } else { | |
| 802 const TypePtr* nat = flatten_phi_adr_type(n->adr_type()); | |
| 803 // recheck phi/non-phi consistency at leaves: | |
| 804 assert((nat != NULL) == (at != NULL), ""); | |
| 805 assert(nat == at || nat == TypePtr::BOTTOM, | |
| 806 "adr_type must be consistent at leaves of phi nest"); | |
| 807 } | |
| 808 } | |
| 809 } | |
| 810 | |
| 811 // Verify a whole nest of phis rooted at this one. | |
| 812 void PhiNode::verify_adr_type(bool recursive) const { | |
| 813 if (is_error_reported()) return; // muzzle asserts when debugging an error | |
| 814 if (Node::in_dump()) return; // muzzle asserts when printing | |
| 815 | |
| 816 assert((_type == Type::MEMORY) == (_adr_type != NULL), "adr_type for memory phis only"); | |
| 817 | |
| 818 if (!VerifyAliases) return; // verify thoroughly only if requested | |
| 819 | |
| 820 assert(_adr_type == flatten_phi_adr_type(_adr_type), | |
| 821 "Phi::adr_type must be pre-normalized"); | |
| 822 | |
| 823 if (recursive) { | |
| 824 VectorSet visited(Thread::current()->resource_area()); | |
| 825 verify_adr_type(visited, _adr_type); | |
| 826 } | |
| 827 } | |
| 828 #endif | |
| 829 | |
| 830 | |
| 831 //------------------------------Value------------------------------------------ | |
| 832 // Compute the type of the PhiNode | |
| 833 const Type *PhiNode::Value( PhaseTransform *phase ) const { | |
| 834 Node *r = in(0); // RegionNode | |
| 835 if( !r ) // Copy or dead | |
| 836 return in(1) ? phase->type(in(1)) : Type::TOP; | |
| 837 | |
| 838 // Note: During parsing, phis are often transformed before their regions. | |
| 839 // This means we have to use type_or_null to defend against untyped regions. | |
| 840 if( phase->type_or_null(r) == Type::TOP ) // Dead code? | |
| 841 return Type::TOP; | |
| 842 | |
| 843 // Check for trip-counted loop. If so, be smarter. | |
| 844 CountedLoopNode *l = r->is_CountedLoop() ? r->as_CountedLoop() : NULL; | |
| 845 if( l && l->can_be_counted_loop(phase) && | |
| 846 ((const Node*)l->phi() == this) ) { // Trip counted loop! | |
| 847 // protect against init_trip() or limit() returning NULL | |
| 848 const Node *init = l->init_trip(); | |
| 849 const Node *limit = l->limit(); | |
| 850 if( init != NULL && limit != NULL && l->stride_is_con() ) { | |
| 851 const TypeInt *lo = init ->bottom_type()->isa_int(); | |
| 852 const TypeInt *hi = limit->bottom_type()->isa_int(); | |
| 853 if( lo && hi ) { // Dying loops might have TOP here | |
| 854 int stride = l->stride_con(); | |
| 855 if( stride < 0 ) { // Down-counter loop | |
| 856 const TypeInt *tmp = lo; lo = hi; hi = tmp; | |
| 857 stride = -stride; | |
| 858 } | |
| 859 if( lo->_hi < hi->_lo ) // Reversed endpoints are well defined :-( | |
| 860 return TypeInt::make(lo->_lo,hi->_hi,3); | |
| 861 } | |
| 862 } | |
| 863 } | |
| 864 | |
| 865 // Until we have harmony between classes and interfaces in the type | |
| 866 // lattice, we must tread carefully around phis which implicitly | |
| 867 // 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
|
868 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
|
869 const TypeInstPtr* ttip = (ttp != NULL) ? ttp->isa_instptr() : NULL; |
| 555 | 870 const TypeKlassPtr* ttkp = (ttp != NULL) ? ttp->isa_klassptr() : NULL; |
| 0 | 871 bool is_intf = false; |
| 872 if (ttip != NULL) { | |
| 873 ciKlass* k = ttip->klass(); | |
| 874 if (k->is_loaded() && k->is_interface()) | |
| 875 is_intf = true; | |
| 876 } | |
| 555 | 877 if (ttkp != NULL) { |
| 878 ciKlass* k = ttkp->klass(); | |
| 879 if (k->is_loaded() && k->is_interface()) | |
| 880 is_intf = true; | |
| 881 } | |
| 0 | 882 |
| 883 // Default case: merge all inputs | |
| 884 const Type *t = Type::TOP; // Merged type starting value | |
| 885 for (uint i = 1; i < req(); ++i) {// For all paths in | |
| 886 // Reachable control path? | |
| 887 if (r->in(i) && phase->type(r->in(i)) == Type::CONTROL) { | |
| 888 const Type* ti = phase->type(in(i)); | |
| 889 // We assume that each input of an interface-valued Phi is a true | |
| 890 // subtype of that interface. This might not be true of the meet | |
| 891 // of all the input types. The lattice is not distributive in | |
| 892 // such cases. Ward off asserts in type.cpp by refusing to do | |
| 893 // 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
|
894 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
|
895 const TypeInstPtr* tiip = (tip != NULL) ? tip->isa_instptr() : NULL; |
| 0 | 896 if (tiip) { |
| 897 bool ti_is_intf = false; | |
| 898 ciKlass* k = tiip->klass(); | |
| 899 if (k->is_loaded() && k->is_interface()) | |
| 900 ti_is_intf = true; | |
| 901 if (is_intf != ti_is_intf) | |
| 902 { t = _type; break; } | |
| 903 } | |
| 904 t = t->meet(ti); | |
| 905 } | |
| 906 } | |
| 907 | |
| 908 // The worst-case type (from ciTypeFlow) should be consistent with "t". | |
| 909 // That is, we expect that "t->higher_equal(_type)" holds true. | |
| 910 // There are various exceptions: | |
| 911 // - Inputs which are phis might in fact be widened unnecessarily. | |
| 912 // For example, an input might be a widened int while the phi is a short. | |
| 913 // - Inputs might be BotPtrs but this phi is dependent on a null check, | |
| 914 // and postCCP has removed the cast which encodes the result of the check. | |
| 915 // - The type of this phi is an interface, and the inputs are classes. | |
| 916 // - Value calls on inputs might produce fuzzy results. | |
| 917 // (Occurrences of this case suggest improvements to Value methods.) | |
| 918 // | |
| 919 // It is not possible to see Type::BOTTOM values as phi inputs, | |
| 920 // because the ciTypeFlow pre-pass produces verifier-quality types. | |
| 921 const Type* ft = t->filter(_type); // Worst case type | |
| 922 | |
| 923 #ifdef ASSERT | |
| 924 // The following logic has been moved into TypeOopPtr::filter. | |
| 925 const Type* jt = t->join(_type); | |
| 926 if( jt->empty() ) { // Emptied out??? | |
| 927 | |
| 928 // Check for evil case of 't' being a class and '_type' expecting an | |
| 929 // interface. This can happen because the bytecodes do not contain | |
| 930 // enough type info to distinguish a Java-level interface variable | |
| 931 // from a Java-level object variable. If we meet 2 classes which | |
| 932 // both implement interface I, but their meet is at 'j/l/O' which | |
| 933 // doesn't implement I, we have no way to tell if the result should | |
| 934 // be 'I' or 'j/l/O'. Thus we'll pick 'j/l/O'. If this then flows | |
| 935 // into a Phi which "knows" it's an Interface type we'll have to | |
| 936 // uplift the type. | |
| 937 if( !t->empty() && ttip && ttip->is_loaded() && ttip->klass()->is_interface() ) | |
| 938 { assert(ft == _type, ""); } // Uplift to interface | |
| 555 | 939 else if( !t->empty() && ttkp && ttkp->is_loaded() && ttkp->klass()->is_interface() ) |
| 940 { assert(ft == _type, ""); } // Uplift to interface | |
| 0 | 941 // Otherwise it's something stupid like non-overlapping int ranges |
| 942 // found on dying counted loops. | |
| 943 else | |
| 944 { assert(ft == Type::TOP, ""); } // Canonical empty value | |
| 945 } | |
| 946 | |
| 947 else { | |
| 948 | |
| 949 // If we have an interface-typed Phi and we narrow to a class type, the join | |
| 950 // should report back the class. However, if we have a J/L/Object | |
| 951 // class-typed Phi and an interface flows in, it's possible that the meet & | |
| 952 // join report an interface back out. This isn't possible but happens | |
| 953 // 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
|
954 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
|
955 const TypeInstPtr *jtip = (jtp != NULL) ? jtp->isa_instptr() : NULL; |
| 555 | 956 const TypeKlassPtr *jtkp = (jtp != NULL) ? jtp->isa_klassptr() : NULL; |
| 0 | 957 if( jtip && ttip ) { |
| 958 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
|
959 ttip->is_loaded() && !ttip->klass()->is_interface() ) { |
| 0 | 960 // 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
|
961 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
|
962 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
|
963 jt = ft; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
74
diff
changeset
|
964 } |
| 0 | 965 } |
| 555 | 966 if( jtkp && ttkp ) { |
| 967 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
|
968 !jtkp->klass_is_exact() && // Keep exact interface klass (6894807) |
| 555 | 969 ttkp->is_loaded() && !ttkp->klass()->is_interface() ) { |
| 970 assert(ft == ttkp->cast_to_ptr_type(jtkp->ptr()) || | |
| 971 ft->isa_narrowoop() && ft->make_ptr() == ttkp->cast_to_ptr_type(jtkp->ptr()), ""); | |
| 972 jt = ft; | |
| 973 } | |
| 974 } | |
| 0 | 975 if (jt != ft && jt->base() == ft->base()) { |
| 976 if (jt->isa_int() && | |
| 977 jt->is_int()->_lo == ft->is_int()->_lo && | |
| 978 jt->is_int()->_hi == ft->is_int()->_hi) | |
| 979 jt = ft; | |
| 980 if (jt->isa_long() && | |
| 981 jt->is_long()->_lo == ft->is_long()->_lo && | |
| 982 jt->is_long()->_hi == ft->is_long()->_hi) | |
| 983 jt = ft; | |
| 984 } | |
| 985 if (jt != ft) { | |
| 986 tty->print("merge type: "); t->dump(); tty->cr(); | |
| 987 tty->print("kill type: "); _type->dump(); tty->cr(); | |
| 988 tty->print("join type: "); jt->dump(); tty->cr(); | |
| 989 tty->print("filter type: "); ft->dump(); tty->cr(); | |
| 990 } | |
| 991 assert(jt == ft, ""); | |
| 992 } | |
| 993 #endif //ASSERT | |
| 994 | |
| 995 // Deal with conversion problems found in data loops. | |
| 996 ft = phase->saturate(ft, phase->type_or_null(this), _type); | |
| 997 | |
| 998 return ft; | |
| 999 } | |
| 1000 | |
| 1001 | |
| 1002 //------------------------------is_diamond_phi--------------------------------- | |
| 1003 // Does this Phi represent a simple well-shaped diamond merge? Return the | |
| 1004 // index of the true path or 0 otherwise. | |
| 1005 int PhiNode::is_diamond_phi() const { | |
| 1006 // Check for a 2-path merge | |
| 1007 Node *region = in(0); | |
| 1008 if( !region ) return 0; | |
| 1009 if( region->req() != 3 ) return 0; | |
| 1010 if( req() != 3 ) return 0; | |
| 1011 // Check that both paths come from the same If | |
| 1012 Node *ifp1 = region->in(1); | |
| 1013 Node *ifp2 = region->in(2); | |
| 1014 if( !ifp1 || !ifp2 ) return 0; | |
| 1015 Node *iff = ifp1->in(0); | |
| 1016 if( !iff || !iff->is_If() ) return 0; | |
| 1017 if( iff != ifp2->in(0) ) return 0; | |
| 1018 // Check for a proper bool/cmp | |
| 1019 const Node *b = iff->in(1); | |
| 1020 if( !b->is_Bool() ) return 0; | |
| 1021 const Node *cmp = b->in(1); | |
| 1022 if( !cmp->is_Cmp() ) return 0; | |
| 1023 | |
| 1024 // Check for branching opposite expected | |
| 1025 if( ifp2->Opcode() == Op_IfTrue ) { | |
| 1026 assert( ifp1->Opcode() == Op_IfFalse, "" ); | |
| 1027 return 2; | |
| 1028 } else { | |
| 1029 assert( ifp1->Opcode() == Op_IfTrue, "" ); | |
| 1030 return 1; | |
| 1031 } | |
| 1032 } | |
| 1033 | |
| 1034 //----------------------------check_cmove_id----------------------------------- | |
| 1035 // Check for CMove'ing a constant after comparing against the constant. | |
| 1036 // Happens all the time now, since if we compare equality vs a constant in | |
| 1037 // the parser, we "know" the variable is constant on one path and we force | |
| 1038 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a | |
| 1039 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more | |
| 1040 // general in that we don't need constants. Since CMove's are only inserted | |
| 1041 // in very special circumstances, we do it here on generic Phi's. | |
| 1042 Node* PhiNode::is_cmove_id(PhaseTransform* phase, int true_path) { | |
| 1043 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1044 | |
| 1045 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1046 // phi->region->if_proj->ifnode->bool->cmp | |
| 1047 Node* region = in(0); | |
| 1048 Node* iff = region->in(1)->in(0); | |
| 1049 BoolNode* b = iff->in(1)->as_Bool(); | |
| 1050 Node* cmp = b->in(1); | |
| 1051 Node* tval = in(true_path); | |
| 1052 Node* fval = in(3-true_path); | |
| 1053 Node* id = CMoveNode::is_cmove_id(phase, cmp, tval, fval, b); | |
| 1054 if (id == NULL) | |
| 1055 return NULL; | |
| 1056 | |
| 1057 // Either value might be a cast that depends on a branch of 'iff'. | |
| 1058 // Since the 'id' value will float free of the diamond, either | |
| 1059 // decast or return failure. | |
| 1060 Node* ctl = id->in(0); | |
| 1061 if (ctl != NULL && ctl->in(0) == iff) { | |
| 1062 if (id->is_ConstraintCast()) { | |
| 1063 return id->in(1); | |
| 1064 } else { | |
| 1065 // Don't know how to disentangle this value. | |
| 1066 return NULL; | |
| 1067 } | |
| 1068 } | |
| 1069 | |
| 1070 return id; | |
| 1071 } | |
| 1072 | |
| 1073 //------------------------------Identity--------------------------------------- | |
| 1074 // Check for Region being Identity. | |
| 1075 Node *PhiNode::Identity( PhaseTransform *phase ) { | |
| 1076 // Check for no merging going on | |
| 1077 // (There used to be special-case code here when this->region->is_Loop. | |
| 1078 // It would check for a tributary phi on the backedge that the main phi | |
| 1079 // trivially, perhaps with a single cast. The unique_input method | |
| 1080 // does all this and more, by reducing such tributaries to 'this'.) | |
| 1081 Node* uin = unique_input(phase); | |
| 1082 if (uin != NULL) { | |
| 1083 return uin; | |
| 1084 } | |
| 1085 | |
| 1086 int true_path = is_diamond_phi(); | |
| 1087 if (true_path != 0) { | |
| 1088 Node* id = is_cmove_id(phase, true_path); | |
| 1089 if (id != NULL) return id; | |
| 1090 } | |
| 1091 | |
| 1092 return this; // No identity | |
| 1093 } | |
| 1094 | |
| 1095 //-----------------------------unique_input------------------------------------ | |
| 1096 // Find the unique value, discounting top, self-loops, and casts. | |
| 1097 // Return top if there are no inputs, and self if there are multiple. | |
| 1098 Node* PhiNode::unique_input(PhaseTransform* phase) { | |
| 1099 // 1) One unique direct input, or | |
| 1100 // 2) some of the inputs have an intervening ConstraintCast and | |
| 1101 // the type of input is the same or sharper (more specific) | |
| 1102 // than the phi's type. | |
| 1103 // 3) an input is a self loop | |
| 1104 // | |
| 1105 // 1) input or 2) input or 3) input __ | |
| 1106 // / \ / \ \ / \ | |
| 1107 // \ / | cast phi cast | |
| 1108 // phi \ / / \ / | |
| 1109 // phi / -- | |
| 1110 | |
| 1111 Node* r = in(0); // RegionNode | |
| 1112 if (r == NULL) return in(1); // Already degraded to a Copy | |
| 1113 Node* uncasted_input = NULL; // The unique uncasted input (ConstraintCasts removed) | |
| 1114 Node* direct_input = NULL; // The unique direct input | |
| 1115 | |
| 1116 for (uint i = 1, cnt = req(); i < cnt; ++i) { | |
| 1117 Node* rc = r->in(i); | |
| 1118 if (rc == NULL || phase->type(rc) == Type::TOP) | |
| 1119 continue; // ignore unreachable control path | |
| 1120 Node* n = in(i); | |
| 247 | 1121 if (n == NULL) |
| 1122 continue; | |
| 0 | 1123 Node* un = n->uncast(); |
| 1124 if (un == NULL || un == this || phase->type(un) == Type::TOP) { | |
| 1125 continue; // ignore if top, or in(i) and "this" are in a data cycle | |
| 1126 } | |
| 1127 // Check for a unique uncasted input | |
| 1128 if (uncasted_input == NULL) { | |
| 1129 uncasted_input = un; | |
| 1130 } else if (uncasted_input != un) { | |
| 1131 uncasted_input = NodeSentinel; // no unique uncasted input | |
| 1132 } | |
| 1133 // Check for a unique direct input | |
| 1134 if (direct_input == NULL) { | |
| 1135 direct_input = n; | |
| 1136 } else if (direct_input != n) { | |
| 1137 direct_input = NodeSentinel; // no unique direct input | |
| 1138 } | |
| 1139 } | |
| 1140 if (direct_input == NULL) { | |
| 1141 return phase->C->top(); // no inputs | |
| 1142 } | |
| 1143 assert(uncasted_input != NULL,""); | |
| 1144 | |
| 1145 if (direct_input != NodeSentinel) { | |
| 1146 return direct_input; // one unique direct input | |
| 1147 } | |
| 1148 if (uncasted_input != NodeSentinel && | |
| 1149 phase->type(uncasted_input)->higher_equal(type())) { | |
| 1150 return uncasted_input; // one unique uncasted input | |
| 1151 } | |
| 1152 | |
| 1153 // Nothing. | |
| 1154 return NULL; | |
| 1155 } | |
| 1156 | |
| 1157 //------------------------------is_x2logic------------------------------------- | |
| 1158 // Check for simple convert-to-boolean pattern | |
| 1159 // If:(C Bool) Region:(IfF IfT) Phi:(Region 0 1) | |
| 1160 // Convert Phi to an ConvIB. | |
| 1161 static Node *is_x2logic( PhaseGVN *phase, PhiNode *phi, int true_path ) { | |
| 1162 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1163 // Convert the true/false index into an expected 0/1 return. | |
| 1164 // Map 2->0 and 1->1. | |
| 1165 int flipped = 2-true_path; | |
| 1166 | |
| 1167 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1168 // phi->region->if_proj->ifnode->bool->cmp | |
| 1169 Node *region = phi->in(0); | |
| 1170 Node *iff = region->in(1)->in(0); | |
| 1171 BoolNode *b = (BoolNode*)iff->in(1); | |
| 1172 const CmpNode *cmp = (CmpNode*)b->in(1); | |
| 1173 | |
| 1174 Node *zero = phi->in(1); | |
| 1175 Node *one = phi->in(2); | |
| 1176 const Type *tzero = phase->type( zero ); | |
| 1177 const Type *tone = phase->type( one ); | |
| 1178 | |
| 1179 // Check for compare vs 0 | |
| 1180 const Type *tcmp = phase->type(cmp->in(2)); | |
| 1181 if( tcmp != TypeInt::ZERO && tcmp != TypePtr::NULL_PTR ) { | |
| 1182 // Allow cmp-vs-1 if the other input is bounded by 0-1 | |
| 1183 if( !(tcmp == TypeInt::ONE && phase->type(cmp->in(1)) == TypeInt::BOOL) ) | |
| 1184 return NULL; | |
| 1185 flipped = 1-flipped; // Test is vs 1 instead of 0! | |
| 1186 } | |
| 1187 | |
| 1188 // Check for setting zero/one opposite expected | |
| 1189 if( tzero == TypeInt::ZERO ) { | |
| 1190 if( tone == TypeInt::ONE ) { | |
| 1191 } else return NULL; | |
| 1192 } else if( tzero == TypeInt::ONE ) { | |
| 1193 if( tone == TypeInt::ZERO ) { | |
| 1194 flipped = 1-flipped; | |
| 1195 } else return NULL; | |
| 1196 } else return NULL; | |
| 1197 | |
| 1198 // Check for boolean test backwards | |
| 1199 if( b->_test._test == BoolTest::ne ) { | |
| 1200 } else if( b->_test._test == BoolTest::eq ) { | |
| 1201 flipped = 1-flipped; | |
| 1202 } else return NULL; | |
| 1203 | |
| 1204 // Build int->bool conversion | |
| 1205 Node *n = new (phase->C, 2) Conv2BNode( cmp->in(1) ); | |
| 1206 if( flipped ) | |
| 1207 n = new (phase->C, 3) XorINode( phase->transform(n), phase->intcon(1) ); | |
| 1208 | |
| 1209 return n; | |
| 1210 } | |
| 1211 | |
| 1212 //------------------------------is_cond_add------------------------------------ | |
| 1213 // Check for simple conditional add pattern: "(P < Q) ? X+Y : X;" | |
| 1214 // To be profitable the control flow has to disappear; there can be no other | |
| 1215 // values merging here. We replace the test-and-branch with: | |
| 1216 // "(sgn(P-Q))&Y) + X". Basically, convert "(P < Q)" into 0 or -1 by | |
| 1217 // moving the carry bit from (P-Q) into a register with 'sbb EAX,EAX'. | |
| 1218 // Then convert Y to 0-or-Y and finally add. | |
| 1219 // This is a key transform for SpecJava _201_compress. | |
| 1220 static Node* is_cond_add(PhaseGVN *phase, PhiNode *phi, int true_path) { | |
| 1221 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1222 | |
| 1223 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1224 // phi->region->if_proj->ifnode->bool->cmp | |
| 1225 RegionNode *region = (RegionNode*)phi->in(0); | |
| 1226 Node *iff = region->in(1)->in(0); | |
| 1227 BoolNode* b = iff->in(1)->as_Bool(); | |
| 1228 const CmpNode *cmp = (CmpNode*)b->in(1); | |
| 1229 | |
| 1230 // Make sure only merging this one phi here | |
| 1231 if (region->has_unique_phi() != phi) return NULL; | |
| 1232 | |
| 1233 // Make sure each arm of the diamond has exactly one output, which we assume | |
| 1234 // is the region. Otherwise, the control flow won't disappear. | |
| 1235 if (region->in(1)->outcnt() != 1) return NULL; | |
| 1236 if (region->in(2)->outcnt() != 1) return NULL; | |
| 1237 | |
| 1238 // Check for "(P < Q)" of type signed int | |
| 1239 if (b->_test._test != BoolTest::lt) return NULL; | |
| 1240 if (cmp->Opcode() != Op_CmpI) return NULL; | |
| 1241 | |
| 1242 Node *p = cmp->in(1); | |
| 1243 Node *q = cmp->in(2); | |
| 1244 Node *n1 = phi->in( true_path); | |
| 1245 Node *n2 = phi->in(3-true_path); | |
| 1246 | |
| 1247 int op = n1->Opcode(); | |
| 1248 if( op != Op_AddI // Need zero as additive identity | |
| 1249 /*&&op != Op_SubI && | |
| 1250 op != Op_AddP && | |
| 1251 op != Op_XorI && | |
| 1252 op != Op_OrI*/ ) | |
| 1253 return NULL; | |
| 1254 | |
| 1255 Node *x = n2; | |
| 1256 Node *y = n1->in(1); | |
| 1257 if( n2 == n1->in(1) ) { | |
| 1258 y = n1->in(2); | |
| 1259 } else if( n2 == n1->in(1) ) { | |
| 1260 } else return NULL; | |
| 1261 | |
| 1262 // Not so profitable if compare and add are constants | |
| 1263 if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() ) | |
| 1264 return NULL; | |
| 1265 | |
| 1266 Node *cmplt = phase->transform( new (phase->C, 3) CmpLTMaskNode(p,q) ); | |
| 1267 Node *j_and = phase->transform( new (phase->C, 3) AndINode(cmplt,y) ); | |
| 1268 return new (phase->C, 3) AddINode(j_and,x); | |
| 1269 } | |
| 1270 | |
| 1271 //------------------------------is_absolute------------------------------------ | |
| 1272 // Check for absolute value. | |
| 1273 static Node* is_absolute( PhaseGVN *phase, PhiNode *phi_root, int true_path) { | |
| 1274 assert(true_path !=0, "only diamond shape graph expected"); | |
| 1275 | |
| 1276 int cmp_zero_idx = 0; // Index of compare input where to look for zero | |
| 1277 int phi_x_idx = 0; // Index of phi input where to find naked x | |
| 1278 | |
| 1279 // ABS ends with the merge of 2 control flow paths. | |
| 1280 // Find the false path from the true path. With only 2 inputs, 3 - x works nicely. | |
| 1281 int false_path = 3 - true_path; | |
| 1282 | |
| 1283 // is_diamond_phi() has guaranteed the correctness of the nodes sequence: | |
| 1284 // phi->region->if_proj->ifnode->bool->cmp | |
| 1285 BoolNode *bol = phi_root->in(0)->in(1)->in(0)->in(1)->as_Bool(); | |
| 1286 | |
| 1287 // Check bool sense | |
| 1288 switch( bol->_test._test ) { | |
| 1289 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = true_path; break; | |
| 1290 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = false_path; break; | |
| 1291 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = true_path; break; | |
| 1292 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = false_path; break; | |
| 1293 default: return NULL; break; | |
| 1294 } | |
| 1295 | |
| 1296 // Test is next | |
| 1297 Node *cmp = bol->in(1); | |
| 1298 const Type *tzero = NULL; | |
| 1299 switch( cmp->Opcode() ) { | |
| 1300 case Op_CmpF: tzero = TypeF::ZERO; break; // Float ABS | |
| 1301 case Op_CmpD: tzero = TypeD::ZERO; break; // Double ABS | |
| 1302 default: return NULL; | |
| 1303 } | |
| 1304 | |
| 1305 // Find zero input of compare; the other input is being abs'd | |
| 1306 Node *x = NULL; | |
| 1307 bool flip = false; | |
| 1308 if( phase->type(cmp->in(cmp_zero_idx)) == tzero ) { | |
| 1309 x = cmp->in(3 - cmp_zero_idx); | |
| 1310 } else if( phase->type(cmp->in(3 - cmp_zero_idx)) == tzero ) { | |
| 1311 // The test is inverted, we should invert the result... | |
| 1312 x = cmp->in(cmp_zero_idx); | |
| 1313 flip = true; | |
| 1314 } else { | |
| 1315 return NULL; | |
| 1316 } | |
| 1317 | |
| 1318 // Next get the 2 pieces being selected, one is the original value | |
| 1319 // and the other is the negated value. | |
| 1320 if( phi_root->in(phi_x_idx) != x ) return NULL; | |
| 1321 | |
| 1322 // Check other phi input for subtract node | |
| 1323 Node *sub = phi_root->in(3 - phi_x_idx); | |
| 1324 | |
| 1325 // Allow only Sub(0,X) and fail out for all others; Neg is not OK | |
| 1326 if( tzero == TypeF::ZERO ) { | |
| 1327 if( sub->Opcode() != Op_SubF || | |
| 1328 sub->in(2) != x || | |
| 1329 phase->type(sub->in(1)) != tzero ) return NULL; | |
| 1330 x = new (phase->C, 2) AbsFNode(x); | |
| 1331 if (flip) { | |
| 1332 x = new (phase->C, 3) SubFNode(sub->in(1), phase->transform(x)); | |
| 1333 } | |
| 1334 } else { | |
| 1335 if( sub->Opcode() != Op_SubD || | |
| 1336 sub->in(2) != x || | |
| 1337 phase->type(sub->in(1)) != tzero ) return NULL; | |
| 1338 x = new (phase->C, 2) AbsDNode(x); | |
| 1339 if (flip) { | |
| 1340 x = new (phase->C, 3) SubDNode(sub->in(1), phase->transform(x)); | |
| 1341 } | |
| 1342 } | |
| 1343 | |
| 1344 return x; | |
| 1345 } | |
| 1346 | |
| 1347 //------------------------------split_once------------------------------------- | |
| 1348 // Helper for split_flow_path | |
| 1349 static void split_once(PhaseIterGVN *igvn, Node *phi, Node *val, Node *n, Node *newn) { | |
| 1350 igvn->hash_delete(n); // Remove from hash before hacking edges | |
| 1351 | |
| 1352 uint j = 1; | |
| 1353 for( uint i = phi->req()-1; i > 0; i-- ) { | |
| 1354 if( phi->in(i) == val ) { // Found a path with val? | |
| 1355 // Add to NEW Region/Phi, no DU info | |
| 1356 newn->set_req( j++, n->in(i) ); | |
| 1357 // Remove from OLD Region/Phi | |
| 1358 n->del_req(i); | |
| 1359 } | |
| 1360 } | |
| 1361 | |
| 1362 // Register the new node but do not transform it. Cannot transform until the | |
| 605 | 1363 // entire Region/Phi conglomerate has been hacked as a single huge transform. |
| 0 | 1364 igvn->register_new_node_with_optimizer( newn ); |
| 1365 // Now I can point to the new node. | |
| 1366 n->add_req(newn); | |
| 1367 igvn->_worklist.push(n); | |
| 1368 } | |
| 1369 | |
| 1370 //------------------------------split_flow_path-------------------------------- | |
| 1371 // Check for merging identical values and split flow paths | |
| 1372 static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) { | |
| 1373 BasicType bt = phi->type()->basic_type(); | |
| 1374 if( bt == T_ILLEGAL || type2size[bt] <= 0 ) | |
| 1375 return NULL; // Bail out on funny non-value stuff | |
| 1376 if( phi->req() <= 3 ) // Need at least 2 matched inputs and a | |
| 1377 return NULL; // third unequal input to be worth doing | |
| 1378 | |
| 1379 // Scan for a constant | |
| 1380 uint i; | |
| 1381 for( i = 1; i < phi->req()-1; i++ ) { | |
| 1382 Node *n = phi->in(i); | |
| 1383 if( !n ) return NULL; | |
| 1384 if( phase->type(n) == Type::TOP ) return NULL; | |
| 163 | 1385 if( n->Opcode() == Op_ConP || n->Opcode() == Op_ConN ) |
| 0 | 1386 break; |
| 1387 } | |
| 1388 if( i >= phi->req() ) // Only split for constants | |
| 1389 return NULL; | |
| 1390 | |
| 1391 Node *val = phi->in(i); // Constant to split for | |
| 1392 uint hit = 0; // Number of times it occurs | |
| 1393 | |
| 605 | 1394 for( ; i < phi->req(); i++ ){ // Count occurrences of constant |
| 0 | 1395 Node *n = phi->in(i); |
| 1396 if( !n ) return NULL; | |
| 1397 if( phase->type(n) == Type::TOP ) return NULL; | |
| 1398 if( phi->in(i) == val ) | |
| 1399 hit++; | |
| 1400 } | |
| 1401 | |
| 1402 if( hit <= 1 || // Make sure we find 2 or more | |
| 1403 hit == phi->req()-1 ) // and not ALL the same value | |
| 1404 return NULL; | |
| 1405 | |
| 1406 // Now start splitting out the flow paths that merge the same value. | |
| 1407 // Split first the RegionNode. | |
| 1408 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 1409 Node *r = phi->region(); | |
| 1410 RegionNode *newr = new (phase->C, hit+1) RegionNode(hit+1); | |
| 1411 split_once(igvn, phi, val, r, newr); | |
| 1412 | |
| 1413 // Now split all other Phis than this one | |
| 1414 for (DUIterator_Fast kmax, k = r->fast_outs(kmax); k < kmax; k++) { | |
| 1415 Node* phi2 = r->fast_out(k); | |
| 1416 if( phi2->is_Phi() && phi2->as_Phi() != phi ) { | |
| 1417 PhiNode *newphi = PhiNode::make_blank(newr, phi2); | |
| 1418 split_once(igvn, phi, val, phi2, newphi); | |
| 1419 } | |
| 1420 } | |
| 1421 | |
| 1422 // Clean up this guy | |
| 1423 igvn->hash_delete(phi); | |
| 1424 for( i = phi->req()-1; i > 0; i-- ) { | |
| 1425 if( phi->in(i) == val ) { | |
| 1426 phi->del_req(i); | |
| 1427 } | |
| 1428 } | |
| 1429 phi->add_req(val); | |
| 1430 | |
| 1431 return phi; | |
| 1432 } | |
| 1433 | |
| 1434 //============================================================================= | |
| 1435 //------------------------------simple_data_loop_check------------------------- | |
| 605 | 1436 // Try to determining if the phi node in a simple safe/unsafe data loop. |
| 0 | 1437 // Returns: |
| 1438 // enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; | |
| 1439 // Safe - safe case when the phi and it's inputs reference only safe data | |
| 1440 // nodes; | |
| 1441 // Unsafe - the phi and it's inputs reference unsafe data nodes but there | |
| 1442 // is no reference back to the phi - need a graph walk | |
| 1443 // to determine if it is in a loop; | |
| 1444 // UnsafeLoop - unsafe case when the phi references itself directly or through | |
| 1445 // unsafe data node. | |
| 1446 // Note: a safe data node is a node which could/never reference itself during | |
| 1447 // GVN transformations. For now it is Con, Proj, Phi, CastPP, CheckCastPP. | |
| 1448 // I mark Phi nodes as safe node not only because they can reference itself | |
| 1449 // but also to prevent mistaking the fallthrough case inside an outer loop | |
| 1450 // as dead loop when the phi references itselfs through an other phi. | |
| 1451 PhiNode::LoopSafety PhiNode::simple_data_loop_check(Node *in) const { | |
| 1452 // It is unsafe loop if the phi node references itself directly. | |
| 1453 if (in == (Node*)this) | |
| 1454 return UnsafeLoop; // Unsafe loop | |
| 1455 // Unsafe loop if the phi node references itself through an unsafe data node. | |
| 1456 // Exclude cases with null inputs or data nodes which could reference | |
| 1457 // itself (safe for dead loops). | |
| 1458 if (in != NULL && !in->is_dead_loop_safe()) { | |
| 1459 // Check inputs of phi's inputs also. | |
| 1460 // It is much less expensive then full graph walk. | |
| 1461 uint cnt = in->req(); | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1462 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
|
1463 for (; i < cnt; ++i) { |
| 0 | 1464 Node* m = in->in(i); |
| 1465 if (m == (Node*)this) | |
| 1466 return UnsafeLoop; // Unsafe loop | |
| 1467 if (m != NULL && !m->is_dead_loop_safe()) { | |
| 1468 // Check the most common case (about 30% of all cases): | |
| 1469 // phi->Load/Store->AddP->(ConP ConP Con)/(Parm Parm Con). | |
| 1470 Node *m1 = (m->is_AddP() && m->req() > 3) ? m->in(1) : NULL; | |
| 1471 if (m1 == (Node*)this) | |
| 1472 return UnsafeLoop; // Unsafe loop | |
| 1473 if (m1 != NULL && m1 == m->in(2) && | |
| 1474 m1->is_dead_loop_safe() && m->in(3)->is_Con()) { | |
| 1475 continue; // Safe case | |
| 1476 } | |
| 1477 // The phi references an unsafe node - need full analysis. | |
| 1478 return Unsafe; | |
| 1479 } | |
| 1480 } | |
| 1481 } | |
| 1482 return Safe; // Safe case - we can optimize the phi node. | |
| 1483 } | |
| 1484 | |
| 1485 //------------------------------is_unsafe_data_reference----------------------- | |
| 1486 // If phi can be reached through the data input - it is data loop. | |
| 1487 bool PhiNode::is_unsafe_data_reference(Node *in) const { | |
| 1488 assert(req() > 1, ""); | |
| 1489 // First, check simple cases when phi references itself directly or | |
| 1490 // through an other node. | |
| 1491 LoopSafety safety = simple_data_loop_check(in); | |
| 1492 if (safety == UnsafeLoop) | |
| 1493 return true; // phi references itself - unsafe loop | |
| 1494 else if (safety == Safe) | |
| 1495 return false; // Safe case - phi could be replaced with the unique input. | |
| 1496 | |
| 1497 // Unsafe case when we should go through data graph to determine | |
| 1498 // if the phi references itself. | |
| 1499 | |
| 1500 ResourceMark rm; | |
| 1501 | |
| 1502 Arena *a = Thread::current()->resource_area(); | |
| 1503 Node_List nstack(a); | |
| 1504 VectorSet visited(a); | |
| 1505 | |
| 1506 nstack.push(in); // Start with unique input. | |
| 1507 visited.set(in->_idx); | |
| 1508 while (nstack.size() != 0) { | |
| 1509 Node* n = nstack.pop(); | |
| 1510 uint cnt = n->req(); | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
113
diff
changeset
|
1511 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
|
1512 for (; i < cnt; i++) { |
| 0 | 1513 Node* m = n->in(i); |
| 1514 if (m == (Node*)this) { | |
| 1515 return true; // Data loop | |
| 1516 } | |
| 1517 if (m != NULL && !m->is_dead_loop_safe()) { // Only look for unsafe cases. | |
| 1518 if (!visited.test_set(m->_idx)) | |
| 1519 nstack.push(m); | |
| 1520 } | |
| 1521 } | |
| 1522 } | |
| 1523 return false; // The phi is not reachable from its inputs | |
| 1524 } | |
| 1525 | |
| 1526 | |
| 1527 //------------------------------Ideal------------------------------------------ | |
| 1528 // Return a node which is more "ideal" than the current node. Must preserve | |
| 1529 // the CFG, but we can still strip out dead paths. | |
| 1530 Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1531 // The next should never happen after 6297035 fix. | |
| 1532 if( is_copy() ) // Already degraded to a Copy ? | |
| 1533 return NULL; // No change | |
| 1534 | |
| 1535 Node *r = in(0); // RegionNode | |
| 1536 assert(r->in(0) == NULL || !r->in(0)->is_Root(), "not a specially hidden merge"); | |
| 1537 | |
| 1538 // Note: During parsing, phis are often transformed before their regions. | |
| 1539 // This means we have to use type_or_null to defend against untyped regions. | |
| 1540 if( phase->type_or_null(r) == Type::TOP ) // Dead code? | |
| 1541 return NULL; // No change | |
| 1542 | |
| 1543 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
|
1544 bool new_phi = (outcnt() == 0); // transforming new Phi |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1545 assert(!can_reshape || !new_phi, "for igvn new phi should be hooked"); |
| 0 | 1546 |
| 1547 // The are 2 situations when only one valid phi's input is left | |
| 1548 // (in addition to Region input). | |
| 1549 // One: region is not loop - replace phi with this input. | |
| 1550 // Two: region is loop - replace phi with top since this data path is dead | |
| 1551 // and we need to break the dead data loop. | |
| 1552 Node* progress = NULL; // Record if any progress made | |
| 1553 for( uint j = 1; j < req(); ++j ){ // For all paths in | |
| 1554 // Check unreachable control paths | |
| 1555 Node* rc = r->in(j); | |
| 1556 Node* n = in(j); // Get the input | |
| 1557 if (rc == NULL || phase->type(rc) == Type::TOP) { | |
| 1558 if (n != top) { // Not already top? | |
| 1559 set_req(j, top); // Nuke it down | |
| 1560 progress = this; // Record progress | |
| 1561 } | |
| 1562 } | |
| 1563 } | |
| 1564 | |
|
1013
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1565 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
|
1566 // 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
|
1567 // 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
|
1568 return top; |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1569 } |
|
ce590301ae2a
6889300: assert(i != k || is_new || i->outcnt() > 0, "don't return dead nodes")
kvn
parents:
903
diff
changeset
|
1570 |
| 0 | 1571 Node* uin = unique_input(phase); |
| 1572 if (uin == top) { // Simplest case: no alive inputs. | |
| 1573 if (can_reshape) // IGVN transformation | |
| 1574 return top; | |
| 1575 else | |
| 1576 return NULL; // Identity will return TOP | |
| 1577 } else if (uin != NULL) { | |
| 1578 // Only one not-NULL unique input path is left. | |
| 1579 // Determine if this input is backedge of a loop. | |
| 1580 // (Skip new phis which have no uses and dead regions). | |
| 1581 if( outcnt() > 0 && r->in(0) != NULL ) { | |
| 1582 // First, take the short cut when we know it is a loop and | |
| 1583 // the EntryControl data path is dead. | |
| 1584 assert(!r->is_Loop() || r->req() == 3, "Loop node should have 3 inputs"); | |
| 1585 // Then, check if there is a data loop when phi references itself directly | |
| 1586 // or through other data nodes. | |
| 1587 if( r->is_Loop() && !phase->eqv_uncast(uin, in(LoopNode::EntryControl)) || | |
| 1588 !r->is_Loop() && is_unsafe_data_reference(uin) ) { | |
| 1589 // Break this data loop to avoid creation of a dead loop. | |
| 1590 if (can_reshape) { | |
| 1591 return top; | |
| 1592 } else { | |
| 1593 // We can't return top if we are in Parse phase - cut inputs only | |
| 1594 // let Identity to handle the case. | |
| 1595 replace_edge(uin, top); | |
| 1596 return NULL; | |
| 1597 } | |
| 1598 } | |
| 1599 } | |
| 1600 | |
| 1601 // One unique input. | |
| 1602 debug_only(Node* ident = Identity(phase)); | |
| 1603 // The unique input must eventually be detected by the Identity call. | |
| 1604 #ifdef ASSERT | |
| 1605 if (ident != uin && !ident->is_top()) { | |
| 1606 // print this output before failing assert | |
| 1607 r->dump(3); | |
| 1608 this->dump(3); | |
| 1609 ident->dump(); | |
| 1610 uin->dump(); | |
| 1611 } | |
| 1612 #endif | |
| 1613 assert(ident == uin || ident->is_top(), "Identity must clean this up"); | |
| 1614 return NULL; | |
| 1615 } | |
| 1616 | |
| 1617 | |
| 1618 Node* opt = NULL; | |
| 1619 int true_path = is_diamond_phi(); | |
| 1620 if( true_path != 0 ) { | |
| 1621 // Check for CMove'ing identity. If it would be unsafe, | |
| 1622 // handle it here. In the safe case, let Identity handle it. | |
| 1623 Node* unsafe_id = is_cmove_id(phase, true_path); | |
| 1624 if( unsafe_id != NULL && is_unsafe_data_reference(unsafe_id) ) | |
| 1625 opt = unsafe_id; | |
| 1626 | |
| 1627 // Check for simple convert-to-boolean pattern | |
| 1628 if( opt == NULL ) | |
| 1629 opt = is_x2logic(phase, this, true_path); | |
| 1630 | |
| 1631 // Check for absolute value | |
| 1632 if( opt == NULL ) | |
| 1633 opt = is_absolute(phase, this, true_path); | |
| 1634 | |
| 1635 // Check for conditional add | |
| 1636 if( opt == NULL && can_reshape ) | |
| 1637 opt = is_cond_add(phase, this, true_path); | |
| 1638 | |
| 1639 // These 4 optimizations could subsume the phi: | |
| 1640 // have to check for a dead data loop creation. | |
| 1641 if( opt != NULL ) { | |
| 1642 if( opt == unsafe_id || is_unsafe_data_reference(opt) ) { | |
| 1643 // Found dead loop. | |
| 1644 if( can_reshape ) | |
| 1645 return top; | |
| 1646 // We can't return top if we are in Parse phase - cut inputs only | |
| 1647 // to stop further optimizations for this phi. Identity will return TOP. | |
| 1648 assert(req() == 3, "only diamond merge phi here"); | |
| 1649 set_req(1, top); | |
| 1650 set_req(2, top); | |
| 1651 return NULL; | |
| 1652 } else { | |
| 1653 return opt; | |
| 1654 } | |
| 1655 } | |
| 1656 } | |
| 1657 | |
| 1658 // Check for merging identical values and split flow paths | |
| 1659 if (can_reshape) { | |
| 1660 opt = split_flow_path(phase, this); | |
| 1661 // This optimization only modifies phi - don't need to check for dead loop. | |
| 1662 assert(opt == NULL || phase->eqv(opt, this), "do not elide phi"); | |
| 1663 if (opt != NULL) return opt; | |
| 1664 } | |
| 1665 | |
|
1542
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1666 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
|
1667 // Try to undo Phi of AddP: |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1668 // (Phi (AddP base base y) (AddP base2 base2 y)) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1669 // becomes: |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1670 // newbase := (Phi base base2) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1671 // (AddP newbase newbase y) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1672 // |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1673 // 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
|
1674 // interferes with taking advantage of addressing modes. See the |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1675 // clone_shift_expressions code in matcher.cpp |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1676 Node* addp = in(1); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1677 const Type* type = addp->in(AddPNode::Base)->bottom_type(); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1678 Node* y = addp->in(AddPNode::Offset); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1679 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
|
1680 // 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
|
1681 // 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
|
1682 bool doit = true; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1683 for (uint i = 2; i < req(); i++) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1684 if (in(i) == NULL || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1685 in(i)->Opcode() != Op_AddP || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1686 in(i)->in(AddPNode::Base) != in(i)->in(AddPNode::Address) || |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1687 in(i)->in(AddPNode::Offset) != y) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1688 doit = false; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1689 break; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1690 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1691 // Accumulate type for resulting Phi |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1692 type = type->meet(in(i)->in(AddPNode::Base)->bottom_type()); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1693 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1694 Node* base = NULL; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1695 if (doit) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1696 // Check for neighboring AddP nodes in a tree. |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1697 // If they have a base, use that it. |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1698 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
|
1699 Node* u = this->fast_out(k); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1700 if (u->is_AddP()) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1701 Node* base2 = u->in(AddPNode::Base); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1702 if (base2 != NULL && !base2->is_top()) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1703 if (base == NULL) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1704 base = base2; |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1705 else if (base != base2) |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1706 { doit = false; break; } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1707 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1708 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1709 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1710 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1711 if (doit) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1712 if (base == NULL) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1713 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
|
1714 for (uint i = 1; i < req(); i++) { |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1715 base->init_req(i, in(i)->in(AddPNode::Base)); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1716 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1717 phase->is_IterGVN()->register_new_node_with_optimizer(base); |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1718 } |
|
eb79484f795f
6937111: Restore optimization for Phi of AddP (6552204)
kvn
parents:
1013
diff
changeset
|
1719 return new (phase->C, 4) AddPNode(base, base, y); |
|
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 |
| 0 | 1724 // Split phis through memory merges, so that the memory merges will go away. |
| 1725 // Piggy-back this transformation on the search for a unique input.... | |
| 1726 // It will be as if the merged memory is the unique value of the phi. | |
| 1727 // (Do not attempt this optimization unless parsing is complete. | |
| 1728 // It would make the parser's memory-merge logic sick.) | |
| 1729 // (MergeMemNode is not dead_loop_safe - need to check for dead loop.) | |
| 1730 if (progress == NULL && can_reshape && type() == Type::MEMORY) { | |
| 1731 // see if this phi should be sliced | |
| 1732 uint merge_width = 0; | |
| 1733 bool saw_self = false; | |
| 1734 for( uint i=1; i<req(); ++i ) {// For all paths in | |
| 1735 Node *ii = in(i); | |
| 1736 if (ii->is_MergeMem()) { | |
| 1737 MergeMemNode* n = ii->as_MergeMem(); | |
| 1738 merge_width = MAX2(merge_width, n->req()); | |
| 1739 saw_self = saw_self || phase->eqv(n->base_memory(), this); | |
| 1740 } | |
| 1741 } | |
| 1742 | |
| 1743 // This restriction is temporarily necessary to ensure termination: | |
| 1744 if (!saw_self && adr_type() == TypePtr::BOTTOM) merge_width = 0; | |
| 1745 | |
| 1746 if (merge_width > Compile::AliasIdxRaw) { | |
| 1747 // found at least one non-empty MergeMem | |
| 1748 const TypePtr* at = adr_type(); | |
| 1749 if (at != TypePtr::BOTTOM) { | |
| 1750 // Patch the existing phi to select an input from the merge: | |
| 1751 // Phi:AT1(...MergeMem(m0, m1, m2)...) into | |
| 1752 // Phi:AT1(...m1...) | |
| 1753 int alias_idx = phase->C->get_alias_index(at); | |
| 1754 for (uint i=1; i<req(); ++i) { | |
| 1755 Node *ii = in(i); | |
| 1756 if (ii->is_MergeMem()) { | |
| 1757 MergeMemNode* n = ii->as_MergeMem(); | |
| 1758 // compress paths and change unreachable cycles to TOP | |
| 1759 // If not, we can update the input infinitely along a MergeMem cycle | |
| 1760 // 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
|
1761 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
|
1762 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
|
1763 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
|
1764 } |
| 605 | 1765 // If transformed to a MergeMem, get the desired slice |
| 0 | 1766 // Otherwise the returned node represents memory for every slice |
| 1767 Node *new_mem = (m->is_MergeMem()) ? | |
| 1768 m->as_MergeMem()->memory_at(alias_idx) : m; | |
| 1769 // Update input if it is progress over what we have now | |
| 1770 if (new_mem != ii) { | |
| 1771 set_req(i, new_mem); | |
| 1772 progress = this; | |
| 1773 } | |
| 1774 } | |
| 1775 } | |
| 1776 } else { | |
| 1777 // We know that at least one MergeMem->base_memory() == this | |
| 1778 // (saw_self == true). If all other inputs also references this phi | |
| 1779 // (directly or through data nodes) - it is dead loop. | |
| 1780 bool saw_safe_input = false; | |
| 1781 for (uint j = 1; j < req(); ++j) { | |
| 1782 Node *n = in(j); | |
| 1783 if (n->is_MergeMem() && n->as_MergeMem()->base_memory() == this) | |
| 1784 continue; // skip known cases | |
| 1785 if (!is_unsafe_data_reference(n)) { | |
| 1786 saw_safe_input = true; // found safe input | |
| 1787 break; | |
| 1788 } | |
| 1789 } | |
| 1790 if (!saw_safe_input) | |
| 1791 return top; // all inputs reference back to this phi - dead loop | |
| 1792 | |
| 1793 // Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into | |
| 1794 // MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...)) | |
| 1795 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 1796 Node* hook = new (phase->C, 1) Node(1); | |
| 1797 PhiNode* new_base = (PhiNode*) clone(); | |
| 1798 // Must eagerly register phis, since they participate in loops. | |
| 1799 if (igvn) { | |
| 1800 igvn->register_new_node_with_optimizer(new_base); | |
| 1801 hook->add_req(new_base); | |
| 1802 } | |
| 1803 MergeMemNode* result = MergeMemNode::make(phase->C, new_base); | |
| 1804 for (uint i = 1; i < req(); ++i) { | |
| 1805 Node *ii = in(i); | |
| 1806 if (ii->is_MergeMem()) { | |
| 1807 MergeMemNode* n = ii->as_MergeMem(); | |
| 1808 for (MergeMemStream mms(result, n); mms.next_non_empty2(); ) { | |
| 1809 // If we have not seen this slice yet, make a phi for it. | |
| 1810 bool made_new_phi = false; | |
| 1811 if (mms.is_empty()) { | |
| 1812 Node* new_phi = new_base->slice_memory(mms.adr_type(phase->C)); | |
| 1813 made_new_phi = true; | |
| 1814 if (igvn) { | |
| 1815 igvn->register_new_node_with_optimizer(new_phi); | |
| 1816 hook->add_req(new_phi); | |
| 1817 } | |
| 1818 mms.set_memory(new_phi); | |
| 1819 } | |
| 1820 Node* phi = mms.memory(); | |
| 1821 assert(made_new_phi || phi->in(i) == n, "replace the i-th merge by a slice"); | |
| 1822 phi->set_req(i, mms.memory2()); | |
| 1823 } | |
| 1824 } | |
| 1825 } | |
| 1826 // Distribute all self-loops. | |
| 1827 { // (Extra braces to hide mms.) | |
| 1828 for (MergeMemStream mms(result); mms.next_non_empty(); ) { | |
| 1829 Node* phi = mms.memory(); | |
| 1830 for (uint i = 1; i < req(); ++i) { | |
| 1831 if (phi->in(i) == this) phi->set_req(i, phi); | |
| 1832 } | |
| 1833 } | |
| 1834 } | |
| 1835 // now transform the new nodes, and return the mergemem | |
| 1836 for (MergeMemStream mms(result); mms.next_non_empty(); ) { | |
| 1837 Node* phi = mms.memory(); | |
| 1838 mms.set_memory(phase->transform(phi)); | |
| 1839 } | |
| 1840 if (igvn) { // Unhook. | |
| 1841 igvn->hash_delete(hook); | |
| 1842 for (uint i = 1; i < hook->req(); i++) { | |
| 1843 hook->set_req(i, NULL); | |
| 1844 } | |
| 1845 } | |
| 1846 // Replace self with the result. | |
| 1847 return result; | |
| 1848 } | |
| 1849 } | |
|
74
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1850 // |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1851 // Other optimizations on the memory chain |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1852 // |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1853 const TypePtr* at = adr_type(); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1854 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
|
1855 Node *ii = in(i); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1856 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
|
1857 if (ii != new_in ) { |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1858 set_req(i, new_in); |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1859 progress = this; |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1860 } |
|
2a9af0b9cb1c
6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents:
0
diff
changeset
|
1861 } |
| 0 | 1862 } |
| 1863 | |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1864 #ifdef _LP64 |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1865 // Push DecodeN down through phi. |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1866 // 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
|
1867 if (UseCompressedOops && can_reshape && progress == NULL) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1868 bool may_push = true; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1869 bool has_decodeN = false; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1870 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
|
1871 Node *ii = in(i); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1872 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
|
1873 // 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
|
1874 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
|
1875 has_decodeN = true; |
|
64219d2a6493
6851282: JIT miscompilation results in null entry in array when using CompressedOops
kvn
parents:
628
diff
changeset
|
1876 } |
|
368
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1877 } else if (!ii->is_Phi()) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1878 may_push = false; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1879 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1880 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1881 |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1882 if (has_decodeN && may_push) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1883 PhaseIterGVN *igvn = phase->is_IterGVN(); |
|
899
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1884 // Make narrow type for new phi. |
|
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1885 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
|
1886 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
|
1887 uint orig_cnt = req(); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1888 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
|
1889 Node *ii = in(i); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1890 Node* new_ii = NULL; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1891 if (ii->is_DecodeN()) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1892 assert(ii->bottom_type() == bottom_type(), "sanity"); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1893 new_ii = ii->in(1); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1894 } else { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1895 assert(ii->is_Phi(), "sanity"); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1896 if (ii->as_Phi() == this) { |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1897 new_ii = new_phi; |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1898 } else { |
|
899
55cb84cd1247
6865031: Application gives bad result (throws bad exception) with compressed oops
kvn
parents:
860
diff
changeset
|
1899 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
|
1900 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
|
1901 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1902 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1903 new_phi->set_req(i, new_ii); |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1904 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1905 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
|
1906 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
|
1907 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1908 } |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1909 #endif |
|
36ccc817fca4
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
367
diff
changeset
|
1910 |
| 0 | 1911 return progress; // Return any progress |
| 1912 } | |
| 1913 | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1914 //------------------------------is_tripcount----------------------------------- |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1915 bool PhiNode::is_tripcount() const { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1916 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
|
1917 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
|
1918 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1919 |
| 0 | 1920 //------------------------------out_RegMask------------------------------------ |
| 1921 const RegMask &PhiNode::in_RegMask(uint i) const { | |
| 1922 return i ? out_RegMask() : RegMask::Empty; | |
| 1923 } | |
| 1924 | |
| 1925 const RegMask &PhiNode::out_RegMask() const { | |
| 1926 uint ideal_reg = Matcher::base2reg[_type->base()]; | |
| 1927 assert( ideal_reg != Node::NotAMachineReg, "invalid type at Phi" ); | |
| 1928 if( ideal_reg == 0 ) return RegMask::Empty; | |
| 1929 return *(Compile::current()->matcher()->idealreg2spillmask[ideal_reg]); | |
| 1930 } | |
| 1931 | |
| 1932 #ifndef PRODUCT | |
| 1933 void PhiNode::dump_spec(outputStream *st) const { | |
| 1934 TypeNode::dump_spec(st); | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
368
diff
changeset
|
1935 if (is_tripcount()) { |
| 0 | 1936 st->print(" #tripcount"); |
| 1937 } | |
| 1938 } | |
| 1939 #endif | |
| 1940 | |
| 1941 | |
| 1942 //============================================================================= | |
| 1943 const Type *GotoNode::Value( PhaseTransform *phase ) const { | |
| 1944 // If the input is reachable, then we are executed. | |
| 1945 // If the input is not reachable, then we are not executed. | |
| 1946 return phase->type(in(0)); | |
| 1947 } | |
| 1948 | |
| 1949 Node *GotoNode::Identity( PhaseTransform *phase ) { | |
| 1950 return in(0); // Simple copy of incoming control | |
| 1951 } | |
| 1952 | |
| 1953 const RegMask &GotoNode::out_RegMask() const { | |
| 1954 return RegMask::Empty; | |
| 1955 } | |
| 1956 | |
| 1957 //============================================================================= | |
| 1958 const RegMask &JumpNode::out_RegMask() const { | |
| 1959 return RegMask::Empty; | |
| 1960 } | |
| 1961 | |
| 1962 //============================================================================= | |
| 1963 const RegMask &JProjNode::out_RegMask() const { | |
| 1964 return RegMask::Empty; | |
| 1965 } | |
| 1966 | |
| 1967 //============================================================================= | |
| 1968 const RegMask &CProjNode::out_RegMask() const { | |
| 1969 return RegMask::Empty; | |
| 1970 } | |
| 1971 | |
| 1972 | |
| 1973 | |
| 1974 //============================================================================= | |
| 1975 | |
| 1976 uint PCTableNode::hash() const { return Node::hash() + _size; } | |
| 1977 uint PCTableNode::cmp( const Node &n ) const | |
| 1978 { return _size == ((PCTableNode&)n)._size; } | |
| 1979 | |
| 1980 const Type *PCTableNode::bottom_type() const { | |
| 1981 const Type** f = TypeTuple::fields(_size); | |
| 1982 for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; | |
| 1983 return TypeTuple::make(_size, f); | |
| 1984 } | |
| 1985 | |
| 1986 //------------------------------Value------------------------------------------ | |
| 1987 // Compute the type of the PCTableNode. If reachable it is a tuple of | |
| 1988 // Control, otherwise the table targets are not reachable | |
| 1989 const Type *PCTableNode::Value( PhaseTransform *phase ) const { | |
| 1990 if( phase->type(in(0)) == Type::CONTROL ) | |
| 1991 return bottom_type(); | |
| 1992 return Type::TOP; // All paths dead? Then so are we | |
| 1993 } | |
| 1994 | |
| 1995 //------------------------------Ideal------------------------------------------ | |
| 1996 // Return a node which is more "ideal" than the current node. Strip out | |
| 1997 // control copies | |
| 1998 Node *PCTableNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 1999 return remove_dead_region(phase, can_reshape) ? this : NULL; | |
| 2000 } | |
| 2001 | |
| 2002 //============================================================================= | |
| 2003 uint JumpProjNode::hash() const { | |
| 2004 return Node::hash() + _dest_bci; | |
| 2005 } | |
| 2006 | |
| 2007 uint JumpProjNode::cmp( const Node &n ) const { | |
| 2008 return ProjNode::cmp(n) && | |
| 2009 _dest_bci == ((JumpProjNode&)n)._dest_bci; | |
| 2010 } | |
| 2011 | |
| 2012 #ifndef PRODUCT | |
| 2013 void JumpProjNode::dump_spec(outputStream *st) const { | |
| 2014 ProjNode::dump_spec(st); | |
| 2015 st->print("@bci %d ",_dest_bci); | |
| 2016 } | |
| 2017 #endif | |
| 2018 | |
| 2019 //============================================================================= | |
| 2020 //------------------------------Value------------------------------------------ | |
| 2021 // Check for being unreachable, or for coming from a Rethrow. Rethrow's cannot | |
| 2022 // have the default "fall_through_index" path. | |
| 2023 const Type *CatchNode::Value( PhaseTransform *phase ) const { | |
| 2024 // Unreachable? Then so are all paths from here. | |
| 2025 if( phase->type(in(0)) == Type::TOP ) return Type::TOP; | |
| 2026 // First assume all paths are reachable | |
| 2027 const Type** f = TypeTuple::fields(_size); | |
| 2028 for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; | |
| 2029 // Identify cases that will always throw an exception | |
| 2030 // () rethrow call | |
| 2031 // () virtual or interface call with NULL receiver | |
| 2032 // () call is a check cast with incompatible arguments | |
| 2033 if( in(1)->is_Proj() ) { | |
| 2034 Node *i10 = in(1)->in(0); | |
| 2035 if( i10->is_Call() ) { | |
| 2036 CallNode *call = i10->as_Call(); | |
| 2037 // Rethrows always throw exceptions, never return | |
| 2038 if (call->entry_point() == OptoRuntime::rethrow_stub()) { | |
| 2039 f[CatchProjNode::fall_through_index] = Type::TOP; | |
| 2040 } else if( call->req() > TypeFunc::Parms ) { | |
| 2041 const Type *arg0 = phase->type( call->in(TypeFunc::Parms) ); | |
| 605 | 2042 // Check for null receiver to virtual or interface calls |
| 0 | 2043 if( call->is_CallDynamicJava() && |
| 2044 arg0->higher_equal(TypePtr::NULL_PTR) ) { | |
| 2045 f[CatchProjNode::fall_through_index] = Type::TOP; | |
| 2046 } | |
| 2047 } // End of if not a runtime stub | |
| 2048 } // End of if have call above me | |
| 2049 } // End of slot 1 is not a projection | |
| 2050 return TypeTuple::make(_size, f); | |
| 2051 } | |
| 2052 | |
| 2053 //============================================================================= | |
| 2054 uint CatchProjNode::hash() const { | |
| 2055 return Node::hash() + _handler_bci; | |
| 2056 } | |
| 2057 | |
| 2058 | |
| 2059 uint CatchProjNode::cmp( const Node &n ) const { | |
| 2060 return ProjNode::cmp(n) && | |
| 2061 _handler_bci == ((CatchProjNode&)n)._handler_bci; | |
| 2062 } | |
| 2063 | |
| 2064 | |
| 2065 //------------------------------Identity--------------------------------------- | |
| 2066 // If only 1 target is possible, choose it if it is the main control | |
| 2067 Node *CatchProjNode::Identity( PhaseTransform *phase ) { | |
| 2068 // If my value is control and no other value is, then treat as ID | |
| 2069 const TypeTuple *t = phase->type(in(0))->is_tuple(); | |
| 2070 if (t->field_at(_con) != Type::CONTROL) return this; | |
| 2071 // If we remove the last CatchProj and elide the Catch/CatchProj, then we | |
| 2072 // also remove any exception table entry. Thus we must know the call | |
| 2073 // feeding the Catch will not really throw an exception. This is ok for | |
| 2074 // the main fall-thru control (happens when we know a call can never throw | |
| 605 | 2075 // an exception) or for "rethrow", because a further optimization will |
| 0 | 2076 // yank the rethrow (happens when we inline a function that can throw an |
| 2077 // exception and the caller has no handler). Not legal, e.g., for passing | |
| 2078 // a NULL receiver to a v-call, or passing bad types to a slow-check-cast. | |
| 2079 // These cases MUST throw an exception via the runtime system, so the VM | |
| 2080 // will be looking for a table entry. | |
| 2081 Node *proj = in(0)->in(1); // Expect a proj feeding CatchNode | |
| 2082 CallNode *call; | |
| 2083 if (_con != TypeFunc::Control && // Bail out if not the main control. | |
| 2084 !(proj->is_Proj() && // AND NOT a rethrow | |
| 2085 proj->in(0)->is_Call() && | |
| 2086 (call = proj->in(0)->as_Call()) && | |
| 2087 call->entry_point() == OptoRuntime::rethrow_stub())) | |
| 2088 return this; | |
| 2089 | |
| 2090 // Search for any other path being control | |
| 2091 for (uint i = 0; i < t->cnt(); i++) { | |
| 2092 if (i != _con && t->field_at(i) == Type::CONTROL) | |
| 2093 return this; | |
| 2094 } | |
| 2095 // Only my path is possible; I am identity on control to the jump | |
| 2096 return in(0)->in(0); | |
| 2097 } | |
| 2098 | |
| 2099 | |
| 2100 #ifndef PRODUCT | |
| 2101 void CatchProjNode::dump_spec(outputStream *st) const { | |
| 2102 ProjNode::dump_spec(st); | |
| 2103 st->print("@bci %d ",_handler_bci); | |
| 2104 } | |
| 2105 #endif | |
| 2106 | |
| 2107 //============================================================================= | |
| 2108 //------------------------------Identity--------------------------------------- | |
| 2109 // Check for CreateEx being Identity. | |
| 2110 Node *CreateExNode::Identity( PhaseTransform *phase ) { | |
| 2111 if( phase->type(in(1)) == Type::TOP ) return in(1); | |
| 2112 if( phase->type(in(0)) == Type::TOP ) return in(0); | |
| 2113 // We only come from CatchProj, unless the CatchProj goes away. | |
| 2114 // If the CatchProj is optimized away, then we just carry the | |
| 2115 // exception oop through. | |
| 2116 CallNode *call = in(1)->in(0)->as_Call(); | |
| 2117 | |
| 2118 return ( in(0)->is_CatchProj() && in(0)->in(0)->in(1) == in(1) ) | |
| 2119 ? this | |
| 2120 : call->in(TypeFunc::Parms); | |
| 2121 } | |
| 2122 | |
| 2123 //============================================================================= | |
| 127 | 2124 //------------------------------Value------------------------------------------ |
| 2125 // Check for being unreachable. | |
| 2126 const Type *NeverBranchNode::Value( PhaseTransform *phase ) const { | |
| 2127 if (!in(0) || in(0)->is_top()) return Type::TOP; | |
| 2128 return bottom_type(); | |
| 2129 } | |
| 2130 | |
| 2131 //------------------------------Ideal------------------------------------------ | |
| 2132 // Check for no longer being part of a loop | |
| 2133 Node *NeverBranchNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 2134 if (can_reshape && !in(0)->is_Loop()) { | |
| 2135 // Dead code elimination can sometimes delete this projection so | |
| 2136 // if it's not there, there's nothing to do. | |
| 2137 Node* fallthru = proj_out(0); | |
| 2138 if (fallthru != NULL) { | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
2139 phase->is_IterGVN()->replace_node(fallthru, in(0)); |
| 127 | 2140 } |
| 2141 return phase->C->top(); | |
| 2142 } | |
| 2143 return NULL; | |
| 2144 } | |
| 2145 | |
| 0 | 2146 #ifndef PRODUCT |
| 2147 void NeverBranchNode::format( PhaseRegAlloc *ra_, outputStream *st) const { | |
| 2148 st->print("%s", Name()); | |
| 2149 } | |
| 2150 #endif |