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