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