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