1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/src/share/vm/opto/cfgnode.cpp Sat Dec 01 00:00:00 2007 +0000 1.3 @@ -0,0 +1,1954 @@ 1.4 +/* 1.5 + * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. 1.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 1.7 + * 1.8 + * This code is free software; you can redistribute it and/or modify it 1.9 + * under the terms of the GNU General Public License version 2 only, as 1.10 + * published by the Free Software Foundation. 1.11 + * 1.12 + * This code is distributed in the hope that it will be useful, but WITHOUT 1.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1.14 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1.15 + * version 2 for more details (a copy is included in the LICENSE file that 1.16 + * accompanied this code). 1.17 + * 1.18 + * You should have received a copy of the GNU General Public License version 1.19 + * 2 along with this work; if not, write to the Free Software Foundation, 1.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1.21 + * 1.22 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 1.23 + * CA 95054 USA or visit www.sun.com if you need additional information or 1.24 + * have any questions. 1.25 + * 1.26 + */ 1.27 + 1.28 +// Portions of code courtesy of Clifford Click 1.29 + 1.30 +// Optimization - Graph Style 1.31 + 1.32 +#include "incls/_precompiled.incl" 1.33 +#include "incls/_cfgnode.cpp.incl" 1.34 + 1.35 +//============================================================================= 1.36 +//------------------------------Value------------------------------------------ 1.37 +// Compute the type of the RegionNode. 1.38 +const Type *RegionNode::Value( PhaseTransform *phase ) const { 1.39 + for( uint i=1; i<req(); ++i ) { // For all paths in 1.40 + Node *n = in(i); // Get Control source 1.41 + if( !n ) continue; // Missing inputs are TOP 1.42 + if( phase->type(n) == Type::CONTROL ) 1.43 + return Type::CONTROL; 1.44 + } 1.45 + return Type::TOP; // All paths dead? Then so are we 1.46 +} 1.47 + 1.48 +//------------------------------Identity--------------------------------------- 1.49 +// Check for Region being Identity. 1.50 +Node *RegionNode::Identity( PhaseTransform *phase ) { 1.51 + // Cannot have Region be an identity, even if it has only 1 input. 1.52 + // Phi users cannot have their Region input folded away for them, 1.53 + // since they need to select the proper data input 1.54 + return this; 1.55 +} 1.56 + 1.57 +//------------------------------merge_region----------------------------------- 1.58 +// If a Region flows into a Region, merge into one big happy merge. This is 1.59 +// hard to do if there is stuff that has to happen 1.60 +static Node *merge_region(RegionNode *region, PhaseGVN *phase) { 1.61 + if( region->Opcode() != Op_Region ) // Do not do to LoopNodes 1.62 + return NULL; 1.63 + Node *progress = NULL; // Progress flag 1.64 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.65 + 1.66 + uint rreq = region->req(); 1.67 + for( uint i = 1; i < rreq; i++ ) { 1.68 + Node *r = region->in(i); 1.69 + if( r && r->Opcode() == Op_Region && // Found a region? 1.70 + r->in(0) == r && // Not already collapsed? 1.71 + r != region && // Avoid stupid situations 1.72 + r->outcnt() == 2 ) { // Self user and 'region' user only? 1.73 + assert(!r->as_Region()->has_phi(), "no phi users"); 1.74 + if( !progress ) { // No progress 1.75 + if (region->has_phi()) { 1.76 + return NULL; // Only flatten if no Phi users 1.77 + // igvn->hash_delete( phi ); 1.78 + } 1.79 + igvn->hash_delete( region ); 1.80 + progress = region; // Making progress 1.81 + } 1.82 + igvn->hash_delete( r ); 1.83 + 1.84 + // Append inputs to 'r' onto 'region' 1.85 + for( uint j = 1; j < r->req(); j++ ) { 1.86 + // Move an input from 'r' to 'region' 1.87 + region->add_req(r->in(j)); 1.88 + r->set_req(j, phase->C->top()); 1.89 + // Update phis of 'region' 1.90 + //for( uint k = 0; k < max; k++ ) { 1.91 + // Node *phi = region->out(k); 1.92 + // if( phi->is_Phi() ) { 1.93 + // phi->add_req(phi->in(i)); 1.94 + // } 1.95 + //} 1.96 + 1.97 + rreq++; // One more input to Region 1.98 + } // Found a region to merge into Region 1.99 + // Clobber pointer to the now dead 'r' 1.100 + region->set_req(i, phase->C->top()); 1.101 + } 1.102 + } 1.103 + 1.104 + return progress; 1.105 +} 1.106 + 1.107 + 1.108 + 1.109 +//--------------------------------has_phi-------------------------------------- 1.110 +// Helper function: Return any PhiNode that uses this region or NULL 1.111 +PhiNode* RegionNode::has_phi() const { 1.112 + for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { 1.113 + Node* phi = fast_out(i); 1.114 + if (phi->is_Phi()) { // Check for Phi users 1.115 + assert(phi->in(0) == (Node*)this, "phi uses region only via in(0)"); 1.116 + return phi->as_Phi(); // this one is good enough 1.117 + } 1.118 + } 1.119 + 1.120 + return NULL; 1.121 +} 1.122 + 1.123 + 1.124 +//-----------------------------has_unique_phi---------------------------------- 1.125 +// Helper function: Return the only PhiNode that uses this region or NULL 1.126 +PhiNode* RegionNode::has_unique_phi() const { 1.127 + // Check that only one use is a Phi 1.128 + PhiNode* only_phi = NULL; 1.129 + for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { 1.130 + Node* phi = fast_out(i); 1.131 + if (phi->is_Phi()) { // Check for Phi users 1.132 + assert(phi->in(0) == (Node*)this, "phi uses region only via in(0)"); 1.133 + if (only_phi == NULL) { 1.134 + only_phi = phi->as_Phi(); 1.135 + } else { 1.136 + return NULL; // multiple phis 1.137 + } 1.138 + } 1.139 + } 1.140 + 1.141 + return only_phi; 1.142 +} 1.143 + 1.144 + 1.145 +//------------------------------check_phi_clipping----------------------------- 1.146 +// Helper function for RegionNode's identification of FP clipping 1.147 +// Check inputs to the Phi 1.148 +static bool check_phi_clipping( PhiNode *phi, ConNode * &min, uint &min_idx, ConNode * &max, uint &max_idx, Node * &val, uint &val_idx ) { 1.149 + min = NULL; 1.150 + max = NULL; 1.151 + val = NULL; 1.152 + min_idx = 0; 1.153 + max_idx = 0; 1.154 + val_idx = 0; 1.155 + uint phi_max = phi->req(); 1.156 + if( phi_max == 4 ) { 1.157 + for( uint j = 1; j < phi_max; ++j ) { 1.158 + Node *n = phi->in(j); 1.159 + int opcode = n->Opcode(); 1.160 + switch( opcode ) { 1.161 + case Op_ConI: 1.162 + { 1.163 + if( min == NULL ) { 1.164 + min = n->Opcode() == Op_ConI ? (ConNode*)n : NULL; 1.165 + min_idx = j; 1.166 + } else { 1.167 + max = n->Opcode() == Op_ConI ? (ConNode*)n : NULL; 1.168 + max_idx = j; 1.169 + if( min->get_int() > max->get_int() ) { 1.170 + // Swap min and max 1.171 + ConNode *temp; 1.172 + uint temp_idx; 1.173 + temp = min; min = max; max = temp; 1.174 + temp_idx = min_idx; min_idx = max_idx; max_idx = temp_idx; 1.175 + } 1.176 + } 1.177 + } 1.178 + break; 1.179 + default: 1.180 + { 1.181 + val = n; 1.182 + val_idx = j; 1.183 + } 1.184 + break; 1.185 + } 1.186 + } 1.187 + } 1.188 + return ( min && max && val && (min->get_int() <= 0) && (max->get_int() >=0) ); 1.189 +} 1.190 + 1.191 + 1.192 +//------------------------------check_if_clipping------------------------------ 1.193 +// Helper function for RegionNode's identification of FP clipping 1.194 +// Check that inputs to Region come from two IfNodes, 1.195 +// 1.196 +// If 1.197 +// False True 1.198 +// If | 1.199 +// False True | 1.200 +// | | | 1.201 +// RegionNode_inputs 1.202 +// 1.203 +static bool check_if_clipping( const RegionNode *region, IfNode * &bot_if, IfNode * &top_if ) { 1.204 + top_if = NULL; 1.205 + bot_if = NULL; 1.206 + 1.207 + // Check control structure above RegionNode for (if ( if ) ) 1.208 + Node *in1 = region->in(1); 1.209 + Node *in2 = region->in(2); 1.210 + Node *in3 = region->in(3); 1.211 + // Check that all inputs are projections 1.212 + if( in1->is_Proj() && in2->is_Proj() && in3->is_Proj() ) { 1.213 + Node *in10 = in1->in(0); 1.214 + Node *in20 = in2->in(0); 1.215 + Node *in30 = in3->in(0); 1.216 + // Check that #1 and #2 are ifTrue and ifFalse from same If 1.217 + if( in10 != NULL && in10->is_If() && 1.218 + in20 != NULL && in20->is_If() && 1.219 + in30 != NULL && in30->is_If() && in10 == in20 && 1.220 + (in1->Opcode() != in2->Opcode()) ) { 1.221 + Node *in100 = in10->in(0); 1.222 + Node *in1000 = (in100 != NULL && in100->is_Proj()) ? in100->in(0) : NULL; 1.223 + // Check that control for in10 comes from other branch of IF from in3 1.224 + if( in1000 != NULL && in1000->is_If() && 1.225 + in30 == in1000 && (in3->Opcode() != in100->Opcode()) ) { 1.226 + // Control pattern checks 1.227 + top_if = (IfNode*)in1000; 1.228 + bot_if = (IfNode*)in10; 1.229 + } 1.230 + } 1.231 + } 1.232 + 1.233 + return (top_if != NULL); 1.234 +} 1.235 + 1.236 + 1.237 +//------------------------------check_convf2i_clipping------------------------- 1.238 +// Helper function for RegionNode's identification of FP clipping 1.239 +// Verify that the value input to the phi comes from "ConvF2I; LShift; RShift" 1.240 +static bool check_convf2i_clipping( PhiNode *phi, uint idx, ConvF2INode * &convf2i, Node *min, Node *max) { 1.241 + convf2i = NULL; 1.242 + 1.243 + // Check for the RShiftNode 1.244 + Node *rshift = phi->in(idx); 1.245 + assert( rshift, "Previous checks ensure phi input is present"); 1.246 + if( rshift->Opcode() != Op_RShiftI ) { return false; } 1.247 + 1.248 + // Check for the LShiftNode 1.249 + Node *lshift = rshift->in(1); 1.250 + assert( lshift, "Previous checks ensure phi input is present"); 1.251 + if( lshift->Opcode() != Op_LShiftI ) { return false; } 1.252 + 1.253 + // Check for the ConvF2INode 1.254 + Node *conv = lshift->in(1); 1.255 + if( conv->Opcode() != Op_ConvF2I ) { return false; } 1.256 + 1.257 + // Check that shift amounts are only to get sign bits set after F2I 1.258 + jint max_cutoff = max->get_int(); 1.259 + jint min_cutoff = min->get_int(); 1.260 + jint left_shift = lshift->in(2)->get_int(); 1.261 + jint right_shift = rshift->in(2)->get_int(); 1.262 + jint max_post_shift = nth_bit(BitsPerJavaInteger - left_shift - 1); 1.263 + if( left_shift != right_shift || 1.264 + 0 > left_shift || left_shift >= BitsPerJavaInteger || 1.265 + max_post_shift < max_cutoff || 1.266 + max_post_shift < -min_cutoff ) { 1.267 + // Shifts are necessary but current transformation eliminates them 1.268 + return false; 1.269 + } 1.270 + 1.271 + // OK to return the result of ConvF2I without shifting 1.272 + convf2i = (ConvF2INode*)conv; 1.273 + return true; 1.274 +} 1.275 + 1.276 + 1.277 +//------------------------------check_compare_clipping------------------------- 1.278 +// Helper function for RegionNode's identification of FP clipping 1.279 +static bool check_compare_clipping( bool less_than, IfNode *iff, ConNode *limit, Node * & input ) { 1.280 + Node *i1 = iff->in(1); 1.281 + if ( !i1->is_Bool() ) { return false; } 1.282 + BoolNode *bool1 = i1->as_Bool(); 1.283 + if( less_than && bool1->_test._test != BoolTest::le ) { return false; } 1.284 + else if( !less_than && bool1->_test._test != BoolTest::lt ) { return false; } 1.285 + const Node *cmpF = bool1->in(1); 1.286 + if( cmpF->Opcode() != Op_CmpF ) { return false; } 1.287 + // Test that the float value being compared against 1.288 + // is equivalent to the int value used as a limit 1.289 + Node *nodef = cmpF->in(2); 1.290 + if( nodef->Opcode() != Op_ConF ) { return false; } 1.291 + jfloat conf = nodef->getf(); 1.292 + jint coni = limit->get_int(); 1.293 + if( ((int)conf) != coni ) { return false; } 1.294 + input = cmpF->in(1); 1.295 + return true; 1.296 +} 1.297 + 1.298 +//------------------------------is_unreachable_region-------------------------- 1.299 +// Find if the Region node is reachable from the root. 1.300 +bool RegionNode::is_unreachable_region(PhaseGVN *phase) const { 1.301 + assert(req() == 2, ""); 1.302 + 1.303 + // First, cut the simple case of fallthrough region when NONE of 1.304 + // region's phis references itself directly or through a data node. 1.305 + uint max = outcnt(); 1.306 + uint i; 1.307 + for (i = 0; i < max; i++) { 1.308 + Node* phi = raw_out(i); 1.309 + if (phi != NULL && phi->is_Phi()) { 1.310 + assert(phase->eqv(phi->in(0), this) && phi->req() == 2, ""); 1.311 + if (phi->outcnt() == 0) 1.312 + continue; // Safe case - no loops 1.313 + if (phi->outcnt() == 1) { 1.314 + Node* u = phi->raw_out(0); 1.315 + // Skip if only one use is an other Phi or Call or Uncommon trap. 1.316 + // It is safe to consider this case as fallthrough. 1.317 + if (u != NULL && (u->is_Phi() || u->is_CFG())) 1.318 + continue; 1.319 + } 1.320 + // Check when phi references itself directly or through an other node. 1.321 + if (phi->as_Phi()->simple_data_loop_check(phi->in(1)) >= PhiNode::Unsafe) 1.322 + break; // Found possible unsafe data loop. 1.323 + } 1.324 + } 1.325 + if (i >= max) 1.326 + return false; // An unsafe case was NOT found - don't need graph walk. 1.327 + 1.328 + // Unsafe case - check if the Region node is reachable from root. 1.329 + ResourceMark rm; 1.330 + 1.331 + Arena *a = Thread::current()->resource_area(); 1.332 + Node_List nstack(a); 1.333 + VectorSet visited(a); 1.334 + 1.335 + // Mark all control nodes reachable from root outputs 1.336 + Node *n = (Node*)phase->C->root(); 1.337 + nstack.push(n); 1.338 + visited.set(n->_idx); 1.339 + while (nstack.size() != 0) { 1.340 + n = nstack.pop(); 1.341 + uint max = n->outcnt(); 1.342 + for (uint i = 0; i < max; i++) { 1.343 + Node* m = n->raw_out(i); 1.344 + if (m != NULL && m->is_CFG()) { 1.345 + if (phase->eqv(m, this)) { 1.346 + return false; // We reached the Region node - it is not dead. 1.347 + } 1.348 + if (!visited.test_set(m->_idx)) 1.349 + nstack.push(m); 1.350 + } 1.351 + } 1.352 + } 1.353 + 1.354 + return true; // The Region node is unreachable - it is dead. 1.355 +} 1.356 + 1.357 +//------------------------------Ideal------------------------------------------ 1.358 +// Return a node which is more "ideal" than the current node. Must preserve 1.359 +// the CFG, but we can still strip out dead paths. 1.360 +Node *RegionNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1.361 + if( !can_reshape && !in(0) ) return NULL; // Already degraded to a Copy 1.362 + assert(!in(0) || !in(0)->is_Root(), "not a specially hidden merge"); 1.363 + 1.364 + // Check for RegionNode with no Phi users and both inputs come from either 1.365 + // arm of the same IF. If found, then the control-flow split is useless. 1.366 + bool has_phis = false; 1.367 + if (can_reshape) { // Need DU info to check for Phi users 1.368 + has_phis = (has_phi() != NULL); // Cache result 1.369 + if (!has_phis) { // No Phi users? Nothing merging? 1.370 + for (uint i = 1; i < req()-1; i++) { 1.371 + Node *if1 = in(i); 1.372 + if( !if1 ) continue; 1.373 + Node *iff = if1->in(0); 1.374 + if( !iff || !iff->is_If() ) continue; 1.375 + for( uint j=i+1; j<req(); j++ ) { 1.376 + if( in(j) && in(j)->in(0) == iff && 1.377 + if1->Opcode() != in(j)->Opcode() ) { 1.378 + // Add the IF Projections to the worklist. They (and the IF itself) 1.379 + // will be eliminated if dead. 1.380 + phase->is_IterGVN()->add_users_to_worklist(iff); 1.381 + set_req(i, iff->in(0));// Skip around the useless IF diamond 1.382 + set_req(j, NULL); 1.383 + return this; // Record progress 1.384 + } 1.385 + } 1.386 + } 1.387 + } 1.388 + } 1.389 + 1.390 + // Remove TOP or NULL input paths. If only 1 input path remains, this Region 1.391 + // degrades to a copy. 1.392 + bool add_to_worklist = false; 1.393 + int cnt = 0; // Count of values merging 1.394 + DEBUG_ONLY( int cnt_orig = req(); ) // Save original inputs count 1.395 + int del_it = 0; // The last input path we delete 1.396 + // For all inputs... 1.397 + for( uint i=1; i<req(); ++i ){// For all paths in 1.398 + Node *n = in(i); // Get the input 1.399 + if( n != NULL ) { 1.400 + // Remove useless control copy inputs 1.401 + if( n->is_Region() && n->as_Region()->is_copy() ) { 1.402 + set_req(i, n->nonnull_req()); 1.403 + i--; 1.404 + continue; 1.405 + } 1.406 + if( n->is_Proj() ) { // Remove useless rethrows 1.407 + Node *call = n->in(0); 1.408 + if (call->is_Call() && call->as_Call()->entry_point() == OptoRuntime::rethrow_stub()) { 1.409 + set_req(i, call->in(0)); 1.410 + i--; 1.411 + continue; 1.412 + } 1.413 + } 1.414 + if( phase->type(n) == Type::TOP ) { 1.415 + set_req(i, NULL); // Ignore TOP inputs 1.416 + i--; 1.417 + continue; 1.418 + } 1.419 + cnt++; // One more value merging 1.420 + 1.421 + } else if (can_reshape) { // Else found dead path with DU info 1.422 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.423 + del_req(i); // Yank path from self 1.424 + del_it = i; 1.425 + uint max = outcnt(); 1.426 + DUIterator j; 1.427 + bool progress = true; 1.428 + while(progress) { // Need to establish property over all users 1.429 + progress = false; 1.430 + for (j = outs(); has_out(j); j++) { 1.431 + Node *n = out(j); 1.432 + if( n->req() != req() && n->is_Phi() ) { 1.433 + assert( n->in(0) == this, "" ); 1.434 + igvn->hash_delete(n); // Yank from hash before hacking edges 1.435 + n->set_req_X(i,NULL,igvn);// Correct DU info 1.436 + n->del_req(i); // Yank path from Phis 1.437 + if( max != outcnt() ) { 1.438 + progress = true; 1.439 + j = refresh_out_pos(j); 1.440 + max = outcnt(); 1.441 + } 1.442 + } 1.443 + } 1.444 + } 1.445 + add_to_worklist = true; 1.446 + i--; 1.447 + } 1.448 + } 1.449 + 1.450 + if (can_reshape && cnt == 1) { 1.451 + // Is it dead loop? 1.452 + // If it is LoopNopde it had 2 (+1 itself) inputs and 1.453 + // one of them was cut. The loop is dead if it was EntryContol. 1.454 + assert(!this->is_Loop() || cnt_orig == 3, "Loop node should have 3 inputs"); 1.455 + if (this->is_Loop() && del_it == LoopNode::EntryControl || 1.456 + !this->is_Loop() && has_phis && is_unreachable_region(phase)) { 1.457 + // Yes, the region will be removed during the next step below. 1.458 + // Cut the backedge input and remove phis since no data paths left. 1.459 + // We don't cut outputs to other nodes here since we need to put them 1.460 + // on the worklist. 1.461 + del_req(1); 1.462 + cnt = 0; 1.463 + assert( req() == 1, "no more inputs expected" ); 1.464 + uint max = outcnt(); 1.465 + bool progress = true; 1.466 + Node *top = phase->C->top(); 1.467 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.468 + DUIterator j; 1.469 + while(progress) { 1.470 + progress = false; 1.471 + for (j = outs(); has_out(j); j++) { 1.472 + Node *n = out(j); 1.473 + if( n->is_Phi() ) { 1.474 + assert( igvn->eqv(n->in(0), this), "" ); 1.475 + assert( n->req() == 2 && n->in(1) != NULL, "Only one data input expected" ); 1.476 + // Break dead loop data path. 1.477 + // Eagerly replace phis with top to avoid phis copies generation. 1.478 + igvn->add_users_to_worklist(n); 1.479 + igvn->hash_delete(n); // Yank from hash before hacking edges 1.480 + igvn->subsume_node(n, top); 1.481 + if( max != outcnt() ) { 1.482 + progress = true; 1.483 + j = refresh_out_pos(j); 1.484 + max = outcnt(); 1.485 + } 1.486 + } 1.487 + } 1.488 + } 1.489 + add_to_worklist = true; 1.490 + } 1.491 + } 1.492 + if (add_to_worklist) { 1.493 + phase->is_IterGVN()->add_users_to_worklist(this); // Revisit collapsed Phis 1.494 + } 1.495 + 1.496 + if( cnt <= 1 ) { // Only 1 path in? 1.497 + set_req(0, NULL); // Null control input for region copy 1.498 + if( cnt == 0 && !can_reshape) { // Parse phase - leave the node as it is. 1.499 + // No inputs or all inputs are NULL. 1.500 + return NULL; 1.501 + } else if (can_reshape) { // Optimization phase - remove the node 1.502 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.503 + Node *parent_ctrl; 1.504 + if( cnt == 0 ) { 1.505 + assert( req() == 1, "no inputs expected" ); 1.506 + // During IGVN phase such region will be subsumed by TOP node 1.507 + // so region's phis will have TOP as control node. 1.508 + // Kill phis here to avoid it. PhiNode::is_copy() will be always false. 1.509 + // Also set other user's input to top. 1.510 + parent_ctrl = phase->C->top(); 1.511 + } else { 1.512 + // The fallthrough case since we already checked dead loops above. 1.513 + parent_ctrl = in(1); 1.514 + assert(parent_ctrl != NULL, "Region is a copy of some non-null control"); 1.515 + assert(!igvn->eqv(parent_ctrl, this), "Close dead loop"); 1.516 + } 1.517 + if (!add_to_worklist) 1.518 + igvn->add_users_to_worklist(this); // Check for further allowed opts 1.519 + for (DUIterator_Last imin, i = last_outs(imin); i >= imin; --i) { 1.520 + Node* n = last_out(i); 1.521 + igvn->hash_delete(n); // Remove from worklist before modifying edges 1.522 + if( n->is_Phi() ) { // Collapse all Phis 1.523 + // Eagerly replace phis to avoid copies generation. 1.524 + igvn->add_users_to_worklist(n); 1.525 + igvn->hash_delete(n); // Yank from hash before hacking edges 1.526 + if( cnt == 0 ) { 1.527 + assert( n->req() == 1, "No data inputs expected" ); 1.528 + igvn->subsume_node(n, parent_ctrl); // replaced by top 1.529 + } else { 1.530 + assert( n->req() == 2 && n->in(1) != NULL, "Only one data input expected" ); 1.531 + Node* in1 = n->in(1); // replaced by unique input 1.532 + if( n->as_Phi()->is_unsafe_data_reference(in1) ) 1.533 + in1 = phase->C->top(); // replaced by top 1.534 + igvn->subsume_node(n, in1); 1.535 + } 1.536 + } 1.537 + else if( n->is_Region() ) { // Update all incoming edges 1.538 + assert( !igvn->eqv(n, this), "Must be removed from DefUse edges"); 1.539 + uint uses_found = 0; 1.540 + for( uint k=1; k < n->req(); k++ ) { 1.541 + if( n->in(k) == this ) { 1.542 + n->set_req(k, parent_ctrl); 1.543 + uses_found++; 1.544 + } 1.545 + } 1.546 + if( uses_found > 1 ) { // (--i) done at the end of the loop. 1.547 + i -= (uses_found - 1); 1.548 + } 1.549 + } 1.550 + else { 1.551 + assert( igvn->eqv(n->in(0), this), "Expect RegionNode to be control parent"); 1.552 + n->set_req(0, parent_ctrl); 1.553 + } 1.554 +#ifdef ASSERT 1.555 + for( uint k=0; k < n->req(); k++ ) { 1.556 + assert( !igvn->eqv(n->in(k), this), "All uses of RegionNode should be gone"); 1.557 + } 1.558 +#endif 1.559 + } 1.560 + // Remove the RegionNode itself from DefUse info 1.561 + igvn->remove_dead_node(this); 1.562 + return NULL; 1.563 + } 1.564 + return this; // Record progress 1.565 + } 1.566 + 1.567 + 1.568 + // If a Region flows into a Region, merge into one big happy merge. 1.569 + if (can_reshape) { 1.570 + Node *m = merge_region(this, phase); 1.571 + if (m != NULL) return m; 1.572 + } 1.573 + 1.574 + // Check if this region is the root of a clipping idiom on floats 1.575 + if( ConvertFloat2IntClipping && can_reshape && req() == 4 ) { 1.576 + // Check that only one use is a Phi and that it simplifies to two constants + 1.577 + PhiNode* phi = has_unique_phi(); 1.578 + if (phi != NULL) { // One Phi user 1.579 + // Check inputs to the Phi 1.580 + ConNode *min; 1.581 + ConNode *max; 1.582 + Node *val; 1.583 + uint min_idx; 1.584 + uint max_idx; 1.585 + uint val_idx; 1.586 + if( check_phi_clipping( phi, min, min_idx, max, max_idx, val, val_idx ) ) { 1.587 + IfNode *top_if; 1.588 + IfNode *bot_if; 1.589 + if( check_if_clipping( this, bot_if, top_if ) ) { 1.590 + // Control pattern checks, now verify compares 1.591 + Node *top_in = NULL; // value being compared against 1.592 + Node *bot_in = NULL; 1.593 + if( check_compare_clipping( true, bot_if, min, bot_in ) && 1.594 + check_compare_clipping( false, top_if, max, top_in ) ) { 1.595 + if( bot_in == top_in ) { 1.596 + PhaseIterGVN *gvn = phase->is_IterGVN(); 1.597 + assert( gvn != NULL, "Only had DefUse info in IterGVN"); 1.598 + // Only remaining check is that bot_in == top_in == (Phi's val + mods) 1.599 + 1.600 + // Check for the ConvF2INode 1.601 + ConvF2INode *convf2i; 1.602 + if( check_convf2i_clipping( phi, val_idx, convf2i, min, max ) && 1.603 + convf2i->in(1) == bot_in ) { 1.604 + // Matched pattern, including LShiftI; RShiftI, replace with integer compares 1.605 + // max test 1.606 + Node *cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, min )); 1.607 + Node *boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::lt )); 1.608 + 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 )); 1.609 + Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); 1.610 + Node *ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); 1.611 + // min test 1.612 + cmp = gvn->register_new_node_with_optimizer(new (phase->C, 3) CmpINode( convf2i, max )); 1.613 + boo = gvn->register_new_node_with_optimizer(new (phase->C, 2) BoolNode( cmp, BoolTest::gt )); 1.614 + iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C, 2) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt )); 1.615 + Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C, 1) IfTrueNode (iff)); 1.616 + ifF = gvn->register_new_node_with_optimizer(new (phase->C, 1) IfFalseNode(iff)); 1.617 + // update input edges to region node 1.618 + set_req_X( min_idx, if_min, gvn ); 1.619 + set_req_X( max_idx, if_max, gvn ); 1.620 + set_req_X( val_idx, ifF, gvn ); 1.621 + // remove unnecessary 'LShiftI; RShiftI' idiom 1.622 + gvn->hash_delete(phi); 1.623 + phi->set_req_X( val_idx, convf2i, gvn ); 1.624 + gvn->hash_find_insert(phi); 1.625 + // Return transformed region node 1.626 + return this; 1.627 + } 1.628 + } 1.629 + } 1.630 + } 1.631 + } 1.632 + } 1.633 + } 1.634 + 1.635 + return NULL; 1.636 +} 1.637 + 1.638 + 1.639 + 1.640 +const RegMask &RegionNode::out_RegMask() const { 1.641 + return RegMask::Empty; 1.642 +} 1.643 + 1.644 +// Find the one non-null required input. RegionNode only 1.645 +Node *Node::nonnull_req() const { 1.646 + assert( is_Region(), "" ); 1.647 + for( uint i = 1; i < _cnt; i++ ) 1.648 + if( in(i) ) 1.649 + return in(i); 1.650 + ShouldNotReachHere(); 1.651 + return NULL; 1.652 +} 1.653 + 1.654 + 1.655 +//============================================================================= 1.656 +// note that these functions assume that the _adr_type field is flattened 1.657 +uint PhiNode::hash() const { 1.658 + const Type* at = _adr_type; 1.659 + return TypeNode::hash() + (at ? at->hash() : 0); 1.660 +} 1.661 +uint PhiNode::cmp( const Node &n ) const { 1.662 + return TypeNode::cmp(n) && _adr_type == ((PhiNode&)n)._adr_type; 1.663 +} 1.664 +static inline 1.665 +const TypePtr* flatten_phi_adr_type(const TypePtr* at) { 1.666 + if (at == NULL || at == TypePtr::BOTTOM) return at; 1.667 + return Compile::current()->alias_type(at)->adr_type(); 1.668 +} 1.669 + 1.670 +//----------------------------make--------------------------------------------- 1.671 +// create a new phi with edges matching r and set (initially) to x 1.672 +PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) { 1.673 + uint preds = r->req(); // Number of predecessor paths 1.674 + assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at"); 1.675 + PhiNode* p = new (Compile::current(), preds) PhiNode(r, t, at); 1.676 + for (uint j = 1; j < preds; j++) { 1.677 + // Fill in all inputs, except those which the region does not yet have 1.678 + if (r->in(j) != NULL) 1.679 + p->init_req(j, x); 1.680 + } 1.681 + return p; 1.682 +} 1.683 +PhiNode* PhiNode::make(Node* r, Node* x) { 1.684 + const Type* t = x->bottom_type(); 1.685 + const TypePtr* at = NULL; 1.686 + if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); 1.687 + return make(r, x, t, at); 1.688 +} 1.689 +PhiNode* PhiNode::make_blank(Node* r, Node* x) { 1.690 + const Type* t = x->bottom_type(); 1.691 + const TypePtr* at = NULL; 1.692 + if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); 1.693 + return new (Compile::current(), r->req()) PhiNode(r, t, at); 1.694 +} 1.695 + 1.696 + 1.697 +//------------------------slice_memory----------------------------------------- 1.698 +// create a new phi with narrowed memory type 1.699 +PhiNode* PhiNode::slice_memory(const TypePtr* adr_type) const { 1.700 + PhiNode* mem = (PhiNode*) clone(); 1.701 + *(const TypePtr**)&mem->_adr_type = adr_type; 1.702 + // convert self-loops, or else we get a bad graph 1.703 + for (uint i = 1; i < req(); i++) { 1.704 + if ((const Node*)in(i) == this) mem->set_req(i, mem); 1.705 + } 1.706 + mem->verify_adr_type(); 1.707 + return mem; 1.708 +} 1.709 + 1.710 +//------------------------verify_adr_type-------------------------------------- 1.711 +#ifdef ASSERT 1.712 +void PhiNode::verify_adr_type(VectorSet& visited, const TypePtr* at) const { 1.713 + if (visited.test_set(_idx)) return; //already visited 1.714 + 1.715 + // recheck constructor invariants: 1.716 + verify_adr_type(false); 1.717 + 1.718 + // recheck local phi/phi consistency: 1.719 + assert(_adr_type == at || _adr_type == TypePtr::BOTTOM, 1.720 + "adr_type must be consistent across phi nest"); 1.721 + 1.722 + // walk around 1.723 + for (uint i = 1; i < req(); i++) { 1.724 + Node* n = in(i); 1.725 + if (n == NULL) continue; 1.726 + const Node* np = in(i); 1.727 + if (np->is_Phi()) { 1.728 + np->as_Phi()->verify_adr_type(visited, at); 1.729 + } else if (n->bottom_type() == Type::TOP 1.730 + || (n->is_Mem() && n->in(MemNode::Address)->bottom_type() == Type::TOP)) { 1.731 + // ignore top inputs 1.732 + } else { 1.733 + const TypePtr* nat = flatten_phi_adr_type(n->adr_type()); 1.734 + // recheck phi/non-phi consistency at leaves: 1.735 + assert((nat != NULL) == (at != NULL), ""); 1.736 + assert(nat == at || nat == TypePtr::BOTTOM, 1.737 + "adr_type must be consistent at leaves of phi nest"); 1.738 + } 1.739 + } 1.740 +} 1.741 + 1.742 +// Verify a whole nest of phis rooted at this one. 1.743 +void PhiNode::verify_adr_type(bool recursive) const { 1.744 + if (is_error_reported()) return; // muzzle asserts when debugging an error 1.745 + if (Node::in_dump()) return; // muzzle asserts when printing 1.746 + 1.747 + assert((_type == Type::MEMORY) == (_adr_type != NULL), "adr_type for memory phis only"); 1.748 + 1.749 + if (!VerifyAliases) return; // verify thoroughly only if requested 1.750 + 1.751 + assert(_adr_type == flatten_phi_adr_type(_adr_type), 1.752 + "Phi::adr_type must be pre-normalized"); 1.753 + 1.754 + if (recursive) { 1.755 + VectorSet visited(Thread::current()->resource_area()); 1.756 + verify_adr_type(visited, _adr_type); 1.757 + } 1.758 +} 1.759 +#endif 1.760 + 1.761 + 1.762 +//------------------------------Value------------------------------------------ 1.763 +// Compute the type of the PhiNode 1.764 +const Type *PhiNode::Value( PhaseTransform *phase ) const { 1.765 + Node *r = in(0); // RegionNode 1.766 + if( !r ) // Copy or dead 1.767 + return in(1) ? phase->type(in(1)) : Type::TOP; 1.768 + 1.769 + // Note: During parsing, phis are often transformed before their regions. 1.770 + // This means we have to use type_or_null to defend against untyped regions. 1.771 + if( phase->type_or_null(r) == Type::TOP ) // Dead code? 1.772 + return Type::TOP; 1.773 + 1.774 + // Check for trip-counted loop. If so, be smarter. 1.775 + CountedLoopNode *l = r->is_CountedLoop() ? r->as_CountedLoop() : NULL; 1.776 + if( l && l->can_be_counted_loop(phase) && 1.777 + ((const Node*)l->phi() == this) ) { // Trip counted loop! 1.778 + // protect against init_trip() or limit() returning NULL 1.779 + const Node *init = l->init_trip(); 1.780 + const Node *limit = l->limit(); 1.781 + if( init != NULL && limit != NULL && l->stride_is_con() ) { 1.782 + const TypeInt *lo = init ->bottom_type()->isa_int(); 1.783 + const TypeInt *hi = limit->bottom_type()->isa_int(); 1.784 + if( lo && hi ) { // Dying loops might have TOP here 1.785 + int stride = l->stride_con(); 1.786 + if( stride < 0 ) { // Down-counter loop 1.787 + const TypeInt *tmp = lo; lo = hi; hi = tmp; 1.788 + stride = -stride; 1.789 + } 1.790 + if( lo->_hi < hi->_lo ) // Reversed endpoints are well defined :-( 1.791 + return TypeInt::make(lo->_lo,hi->_hi,3); 1.792 + } 1.793 + } 1.794 + } 1.795 + 1.796 + // Until we have harmony between classes and interfaces in the type 1.797 + // lattice, we must tread carefully around phis which implicitly 1.798 + // convert the one to the other. 1.799 + const TypeInstPtr* ttip = _type->isa_instptr(); 1.800 + bool is_intf = false; 1.801 + if (ttip != NULL) { 1.802 + ciKlass* k = ttip->klass(); 1.803 + if (k->is_loaded() && k->is_interface()) 1.804 + is_intf = true; 1.805 + } 1.806 + 1.807 + // Default case: merge all inputs 1.808 + const Type *t = Type::TOP; // Merged type starting value 1.809 + for (uint i = 1; i < req(); ++i) {// For all paths in 1.810 + // Reachable control path? 1.811 + if (r->in(i) && phase->type(r->in(i)) == Type::CONTROL) { 1.812 + const Type* ti = phase->type(in(i)); 1.813 + // We assume that each input of an interface-valued Phi is a true 1.814 + // subtype of that interface. This might not be true of the meet 1.815 + // of all the input types. The lattice is not distributive in 1.816 + // such cases. Ward off asserts in type.cpp by refusing to do 1.817 + // meets between interfaces and proper classes. 1.818 + const TypeInstPtr* tiip = ti->isa_instptr(); 1.819 + if (tiip) { 1.820 + bool ti_is_intf = false; 1.821 + ciKlass* k = tiip->klass(); 1.822 + if (k->is_loaded() && k->is_interface()) 1.823 + ti_is_intf = true; 1.824 + if (is_intf != ti_is_intf) 1.825 + { t = _type; break; } 1.826 + } 1.827 + t = t->meet(ti); 1.828 + } 1.829 + } 1.830 + 1.831 + // The worst-case type (from ciTypeFlow) should be consistent with "t". 1.832 + // That is, we expect that "t->higher_equal(_type)" holds true. 1.833 + // There are various exceptions: 1.834 + // - Inputs which are phis might in fact be widened unnecessarily. 1.835 + // For example, an input might be a widened int while the phi is a short. 1.836 + // - Inputs might be BotPtrs but this phi is dependent on a null check, 1.837 + // and postCCP has removed the cast which encodes the result of the check. 1.838 + // - The type of this phi is an interface, and the inputs are classes. 1.839 + // - Value calls on inputs might produce fuzzy results. 1.840 + // (Occurrences of this case suggest improvements to Value methods.) 1.841 + // 1.842 + // It is not possible to see Type::BOTTOM values as phi inputs, 1.843 + // because the ciTypeFlow pre-pass produces verifier-quality types. 1.844 + const Type* ft = t->filter(_type); // Worst case type 1.845 + 1.846 +#ifdef ASSERT 1.847 + // The following logic has been moved into TypeOopPtr::filter. 1.848 + const Type* jt = t->join(_type); 1.849 + if( jt->empty() ) { // Emptied out??? 1.850 + 1.851 + // Check for evil case of 't' being a class and '_type' expecting an 1.852 + // interface. This can happen because the bytecodes do not contain 1.853 + // enough type info to distinguish a Java-level interface variable 1.854 + // from a Java-level object variable. If we meet 2 classes which 1.855 + // both implement interface I, but their meet is at 'j/l/O' which 1.856 + // doesn't implement I, we have no way to tell if the result should 1.857 + // be 'I' or 'j/l/O'. Thus we'll pick 'j/l/O'. If this then flows 1.858 + // into a Phi which "knows" it's an Interface type we'll have to 1.859 + // uplift the type. 1.860 + if( !t->empty() && ttip && ttip->is_loaded() && ttip->klass()->is_interface() ) 1.861 + { assert(ft == _type, ""); } // Uplift to interface 1.862 + // Otherwise it's something stupid like non-overlapping int ranges 1.863 + // found on dying counted loops. 1.864 + else 1.865 + { assert(ft == Type::TOP, ""); } // Canonical empty value 1.866 + } 1.867 + 1.868 + else { 1.869 + 1.870 + // If we have an interface-typed Phi and we narrow to a class type, the join 1.871 + // should report back the class. However, if we have a J/L/Object 1.872 + // class-typed Phi and an interface flows in, it's possible that the meet & 1.873 + // join report an interface back out. This isn't possible but happens 1.874 + // because the type system doesn't interact well with interfaces. 1.875 + const TypeInstPtr *jtip = jt->isa_instptr(); 1.876 + if( jtip && ttip ) { 1.877 + if( jtip->is_loaded() && jtip->klass()->is_interface() && 1.878 + ttip->is_loaded() && !ttip->klass()->is_interface() ) 1.879 + // Happens in a CTW of rt.jar, 320-341, no extra flags 1.880 + { assert(ft == ttip->cast_to_ptr_type(jtip->ptr()), ""); jt = ft; } 1.881 + } 1.882 + if (jt != ft && jt->base() == ft->base()) { 1.883 + if (jt->isa_int() && 1.884 + jt->is_int()->_lo == ft->is_int()->_lo && 1.885 + jt->is_int()->_hi == ft->is_int()->_hi) 1.886 + jt = ft; 1.887 + if (jt->isa_long() && 1.888 + jt->is_long()->_lo == ft->is_long()->_lo && 1.889 + jt->is_long()->_hi == ft->is_long()->_hi) 1.890 + jt = ft; 1.891 + } 1.892 + if (jt != ft) { 1.893 + tty->print("merge type: "); t->dump(); tty->cr(); 1.894 + tty->print("kill type: "); _type->dump(); tty->cr(); 1.895 + tty->print("join type: "); jt->dump(); tty->cr(); 1.896 + tty->print("filter type: "); ft->dump(); tty->cr(); 1.897 + } 1.898 + assert(jt == ft, ""); 1.899 + } 1.900 +#endif //ASSERT 1.901 + 1.902 + // Deal with conversion problems found in data loops. 1.903 + ft = phase->saturate(ft, phase->type_or_null(this), _type); 1.904 + 1.905 + return ft; 1.906 +} 1.907 + 1.908 + 1.909 +//------------------------------is_diamond_phi--------------------------------- 1.910 +// Does this Phi represent a simple well-shaped diamond merge? Return the 1.911 +// index of the true path or 0 otherwise. 1.912 +int PhiNode::is_diamond_phi() const { 1.913 + // Check for a 2-path merge 1.914 + Node *region = in(0); 1.915 + if( !region ) return 0; 1.916 + if( region->req() != 3 ) return 0; 1.917 + if( req() != 3 ) return 0; 1.918 + // Check that both paths come from the same If 1.919 + Node *ifp1 = region->in(1); 1.920 + Node *ifp2 = region->in(2); 1.921 + if( !ifp1 || !ifp2 ) return 0; 1.922 + Node *iff = ifp1->in(0); 1.923 + if( !iff || !iff->is_If() ) return 0; 1.924 + if( iff != ifp2->in(0) ) return 0; 1.925 + // Check for a proper bool/cmp 1.926 + const Node *b = iff->in(1); 1.927 + if( !b->is_Bool() ) return 0; 1.928 + const Node *cmp = b->in(1); 1.929 + if( !cmp->is_Cmp() ) return 0; 1.930 + 1.931 + // Check for branching opposite expected 1.932 + if( ifp2->Opcode() == Op_IfTrue ) { 1.933 + assert( ifp1->Opcode() == Op_IfFalse, "" ); 1.934 + return 2; 1.935 + } else { 1.936 + assert( ifp1->Opcode() == Op_IfTrue, "" ); 1.937 + return 1; 1.938 + } 1.939 +} 1.940 + 1.941 +//----------------------------check_cmove_id----------------------------------- 1.942 +// Check for CMove'ing a constant after comparing against the constant. 1.943 +// Happens all the time now, since if we compare equality vs a constant in 1.944 +// the parser, we "know" the variable is constant on one path and we force 1.945 +// it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a 1.946 +// conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more 1.947 +// general in that we don't need constants. Since CMove's are only inserted 1.948 +// in very special circumstances, we do it here on generic Phi's. 1.949 +Node* PhiNode::is_cmove_id(PhaseTransform* phase, int true_path) { 1.950 + assert(true_path !=0, "only diamond shape graph expected"); 1.951 + 1.952 + // is_diamond_phi() has guaranteed the correctness of the nodes sequence: 1.953 + // phi->region->if_proj->ifnode->bool->cmp 1.954 + Node* region = in(0); 1.955 + Node* iff = region->in(1)->in(0); 1.956 + BoolNode* b = iff->in(1)->as_Bool(); 1.957 + Node* cmp = b->in(1); 1.958 + Node* tval = in(true_path); 1.959 + Node* fval = in(3-true_path); 1.960 + Node* id = CMoveNode::is_cmove_id(phase, cmp, tval, fval, b); 1.961 + if (id == NULL) 1.962 + return NULL; 1.963 + 1.964 + // Either value might be a cast that depends on a branch of 'iff'. 1.965 + // Since the 'id' value will float free of the diamond, either 1.966 + // decast or return failure. 1.967 + Node* ctl = id->in(0); 1.968 + if (ctl != NULL && ctl->in(0) == iff) { 1.969 + if (id->is_ConstraintCast()) { 1.970 + return id->in(1); 1.971 + } else { 1.972 + // Don't know how to disentangle this value. 1.973 + return NULL; 1.974 + } 1.975 + } 1.976 + 1.977 + return id; 1.978 +} 1.979 + 1.980 +//------------------------------Identity--------------------------------------- 1.981 +// Check for Region being Identity. 1.982 +Node *PhiNode::Identity( PhaseTransform *phase ) { 1.983 + // Check for no merging going on 1.984 + // (There used to be special-case code here when this->region->is_Loop. 1.985 + // It would check for a tributary phi on the backedge that the main phi 1.986 + // trivially, perhaps with a single cast. The unique_input method 1.987 + // does all this and more, by reducing such tributaries to 'this'.) 1.988 + Node* uin = unique_input(phase); 1.989 + if (uin != NULL) { 1.990 + return uin; 1.991 + } 1.992 + 1.993 + int true_path = is_diamond_phi(); 1.994 + if (true_path != 0) { 1.995 + Node* id = is_cmove_id(phase, true_path); 1.996 + if (id != NULL) return id; 1.997 + } 1.998 + 1.999 + return this; // No identity 1.1000 +} 1.1001 + 1.1002 +//-----------------------------unique_input------------------------------------ 1.1003 +// Find the unique value, discounting top, self-loops, and casts. 1.1004 +// Return top if there are no inputs, and self if there are multiple. 1.1005 +Node* PhiNode::unique_input(PhaseTransform* phase) { 1.1006 + // 1) One unique direct input, or 1.1007 + // 2) some of the inputs have an intervening ConstraintCast and 1.1008 + // the type of input is the same or sharper (more specific) 1.1009 + // than the phi's type. 1.1010 + // 3) an input is a self loop 1.1011 + // 1.1012 + // 1) input or 2) input or 3) input __ 1.1013 + // / \ / \ \ / \ 1.1014 + // \ / | cast phi cast 1.1015 + // phi \ / / \ / 1.1016 + // phi / -- 1.1017 + 1.1018 + Node* r = in(0); // RegionNode 1.1019 + if (r == NULL) return in(1); // Already degraded to a Copy 1.1020 + Node* uncasted_input = NULL; // The unique uncasted input (ConstraintCasts removed) 1.1021 + Node* direct_input = NULL; // The unique direct input 1.1022 + 1.1023 + for (uint i = 1, cnt = req(); i < cnt; ++i) { 1.1024 + Node* rc = r->in(i); 1.1025 + if (rc == NULL || phase->type(rc) == Type::TOP) 1.1026 + continue; // ignore unreachable control path 1.1027 + Node* n = in(i); 1.1028 + Node* un = n->uncast(); 1.1029 + if (un == NULL || un == this || phase->type(un) == Type::TOP) { 1.1030 + continue; // ignore if top, or in(i) and "this" are in a data cycle 1.1031 + } 1.1032 + // Check for a unique uncasted input 1.1033 + if (uncasted_input == NULL) { 1.1034 + uncasted_input = un; 1.1035 + } else if (uncasted_input != un) { 1.1036 + uncasted_input = NodeSentinel; // no unique uncasted input 1.1037 + } 1.1038 + // Check for a unique direct input 1.1039 + if (direct_input == NULL) { 1.1040 + direct_input = n; 1.1041 + } else if (direct_input != n) { 1.1042 + direct_input = NodeSentinel; // no unique direct input 1.1043 + } 1.1044 + } 1.1045 + if (direct_input == NULL) { 1.1046 + return phase->C->top(); // no inputs 1.1047 + } 1.1048 + assert(uncasted_input != NULL,""); 1.1049 + 1.1050 + if (direct_input != NodeSentinel) { 1.1051 + return direct_input; // one unique direct input 1.1052 + } 1.1053 + if (uncasted_input != NodeSentinel && 1.1054 + phase->type(uncasted_input)->higher_equal(type())) { 1.1055 + return uncasted_input; // one unique uncasted input 1.1056 + } 1.1057 + 1.1058 + // Nothing. 1.1059 + return NULL; 1.1060 +} 1.1061 + 1.1062 +//------------------------------is_x2logic------------------------------------- 1.1063 +// Check for simple convert-to-boolean pattern 1.1064 +// If:(C Bool) Region:(IfF IfT) Phi:(Region 0 1) 1.1065 +// Convert Phi to an ConvIB. 1.1066 +static Node *is_x2logic( PhaseGVN *phase, PhiNode *phi, int true_path ) { 1.1067 + assert(true_path !=0, "only diamond shape graph expected"); 1.1068 + // Convert the true/false index into an expected 0/1 return. 1.1069 + // Map 2->0 and 1->1. 1.1070 + int flipped = 2-true_path; 1.1071 + 1.1072 + // is_diamond_phi() has guaranteed the correctness of the nodes sequence: 1.1073 + // phi->region->if_proj->ifnode->bool->cmp 1.1074 + Node *region = phi->in(0); 1.1075 + Node *iff = region->in(1)->in(0); 1.1076 + BoolNode *b = (BoolNode*)iff->in(1); 1.1077 + const CmpNode *cmp = (CmpNode*)b->in(1); 1.1078 + 1.1079 + Node *zero = phi->in(1); 1.1080 + Node *one = phi->in(2); 1.1081 + const Type *tzero = phase->type( zero ); 1.1082 + const Type *tone = phase->type( one ); 1.1083 + 1.1084 + // Check for compare vs 0 1.1085 + const Type *tcmp = phase->type(cmp->in(2)); 1.1086 + if( tcmp != TypeInt::ZERO && tcmp != TypePtr::NULL_PTR ) { 1.1087 + // Allow cmp-vs-1 if the other input is bounded by 0-1 1.1088 + if( !(tcmp == TypeInt::ONE && phase->type(cmp->in(1)) == TypeInt::BOOL) ) 1.1089 + return NULL; 1.1090 + flipped = 1-flipped; // Test is vs 1 instead of 0! 1.1091 + } 1.1092 + 1.1093 + // Check for setting zero/one opposite expected 1.1094 + if( tzero == TypeInt::ZERO ) { 1.1095 + if( tone == TypeInt::ONE ) { 1.1096 + } else return NULL; 1.1097 + } else if( tzero == TypeInt::ONE ) { 1.1098 + if( tone == TypeInt::ZERO ) { 1.1099 + flipped = 1-flipped; 1.1100 + } else return NULL; 1.1101 + } else return NULL; 1.1102 + 1.1103 + // Check for boolean test backwards 1.1104 + if( b->_test._test == BoolTest::ne ) { 1.1105 + } else if( b->_test._test == BoolTest::eq ) { 1.1106 + flipped = 1-flipped; 1.1107 + } else return NULL; 1.1108 + 1.1109 + // Build int->bool conversion 1.1110 + Node *n = new (phase->C, 2) Conv2BNode( cmp->in(1) ); 1.1111 + if( flipped ) 1.1112 + n = new (phase->C, 3) XorINode( phase->transform(n), phase->intcon(1) ); 1.1113 + 1.1114 + return n; 1.1115 +} 1.1116 + 1.1117 +//------------------------------is_cond_add------------------------------------ 1.1118 +// Check for simple conditional add pattern: "(P < Q) ? X+Y : X;" 1.1119 +// To be profitable the control flow has to disappear; there can be no other 1.1120 +// values merging here. We replace the test-and-branch with: 1.1121 +// "(sgn(P-Q))&Y) + X". Basically, convert "(P < Q)" into 0 or -1 by 1.1122 +// moving the carry bit from (P-Q) into a register with 'sbb EAX,EAX'. 1.1123 +// Then convert Y to 0-or-Y and finally add. 1.1124 +// This is a key transform for SpecJava _201_compress. 1.1125 +static Node* is_cond_add(PhaseGVN *phase, PhiNode *phi, int true_path) { 1.1126 + assert(true_path !=0, "only diamond shape graph expected"); 1.1127 + 1.1128 + // is_diamond_phi() has guaranteed the correctness of the nodes sequence: 1.1129 + // phi->region->if_proj->ifnode->bool->cmp 1.1130 + RegionNode *region = (RegionNode*)phi->in(0); 1.1131 + Node *iff = region->in(1)->in(0); 1.1132 + BoolNode* b = iff->in(1)->as_Bool(); 1.1133 + const CmpNode *cmp = (CmpNode*)b->in(1); 1.1134 + 1.1135 + // Make sure only merging this one phi here 1.1136 + if (region->has_unique_phi() != phi) return NULL; 1.1137 + 1.1138 + // Make sure each arm of the diamond has exactly one output, which we assume 1.1139 + // is the region. Otherwise, the control flow won't disappear. 1.1140 + if (region->in(1)->outcnt() != 1) return NULL; 1.1141 + if (region->in(2)->outcnt() != 1) return NULL; 1.1142 + 1.1143 + // Check for "(P < Q)" of type signed int 1.1144 + if (b->_test._test != BoolTest::lt) return NULL; 1.1145 + if (cmp->Opcode() != Op_CmpI) return NULL; 1.1146 + 1.1147 + Node *p = cmp->in(1); 1.1148 + Node *q = cmp->in(2); 1.1149 + Node *n1 = phi->in( true_path); 1.1150 + Node *n2 = phi->in(3-true_path); 1.1151 + 1.1152 + int op = n1->Opcode(); 1.1153 + if( op != Op_AddI // Need zero as additive identity 1.1154 + /*&&op != Op_SubI && 1.1155 + op != Op_AddP && 1.1156 + op != Op_XorI && 1.1157 + op != Op_OrI*/ ) 1.1158 + return NULL; 1.1159 + 1.1160 + Node *x = n2; 1.1161 + Node *y = n1->in(1); 1.1162 + if( n2 == n1->in(1) ) { 1.1163 + y = n1->in(2); 1.1164 + } else if( n2 == n1->in(1) ) { 1.1165 + } else return NULL; 1.1166 + 1.1167 + // Not so profitable if compare and add are constants 1.1168 + if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() ) 1.1169 + return NULL; 1.1170 + 1.1171 + Node *cmplt = phase->transform( new (phase->C, 3) CmpLTMaskNode(p,q) ); 1.1172 + Node *j_and = phase->transform( new (phase->C, 3) AndINode(cmplt,y) ); 1.1173 + return new (phase->C, 3) AddINode(j_and,x); 1.1174 +} 1.1175 + 1.1176 +//------------------------------is_absolute------------------------------------ 1.1177 +// Check for absolute value. 1.1178 +static Node* is_absolute( PhaseGVN *phase, PhiNode *phi_root, int true_path) { 1.1179 + assert(true_path !=0, "only diamond shape graph expected"); 1.1180 + 1.1181 + int cmp_zero_idx = 0; // Index of compare input where to look for zero 1.1182 + int phi_x_idx = 0; // Index of phi input where to find naked x 1.1183 + 1.1184 + // ABS ends with the merge of 2 control flow paths. 1.1185 + // Find the false path from the true path. With only 2 inputs, 3 - x works nicely. 1.1186 + int false_path = 3 - true_path; 1.1187 + 1.1188 + // is_diamond_phi() has guaranteed the correctness of the nodes sequence: 1.1189 + // phi->region->if_proj->ifnode->bool->cmp 1.1190 + BoolNode *bol = phi_root->in(0)->in(1)->in(0)->in(1)->as_Bool(); 1.1191 + 1.1192 + // Check bool sense 1.1193 + switch( bol->_test._test ) { 1.1194 + case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = true_path; break; 1.1195 + case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = false_path; break; 1.1196 + case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = true_path; break; 1.1197 + case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = false_path; break; 1.1198 + default: return NULL; break; 1.1199 + } 1.1200 + 1.1201 + // Test is next 1.1202 + Node *cmp = bol->in(1); 1.1203 + const Type *tzero = NULL; 1.1204 + switch( cmp->Opcode() ) { 1.1205 + case Op_CmpF: tzero = TypeF::ZERO; break; // Float ABS 1.1206 + case Op_CmpD: tzero = TypeD::ZERO; break; // Double ABS 1.1207 + default: return NULL; 1.1208 + } 1.1209 + 1.1210 + // Find zero input of compare; the other input is being abs'd 1.1211 + Node *x = NULL; 1.1212 + bool flip = false; 1.1213 + if( phase->type(cmp->in(cmp_zero_idx)) == tzero ) { 1.1214 + x = cmp->in(3 - cmp_zero_idx); 1.1215 + } else if( phase->type(cmp->in(3 - cmp_zero_idx)) == tzero ) { 1.1216 + // The test is inverted, we should invert the result... 1.1217 + x = cmp->in(cmp_zero_idx); 1.1218 + flip = true; 1.1219 + } else { 1.1220 + return NULL; 1.1221 + } 1.1222 + 1.1223 + // Next get the 2 pieces being selected, one is the original value 1.1224 + // and the other is the negated value. 1.1225 + if( phi_root->in(phi_x_idx) != x ) return NULL; 1.1226 + 1.1227 + // Check other phi input for subtract node 1.1228 + Node *sub = phi_root->in(3 - phi_x_idx); 1.1229 + 1.1230 + // Allow only Sub(0,X) and fail out for all others; Neg is not OK 1.1231 + if( tzero == TypeF::ZERO ) { 1.1232 + if( sub->Opcode() != Op_SubF || 1.1233 + sub->in(2) != x || 1.1234 + phase->type(sub->in(1)) != tzero ) return NULL; 1.1235 + x = new (phase->C, 2) AbsFNode(x); 1.1236 + if (flip) { 1.1237 + x = new (phase->C, 3) SubFNode(sub->in(1), phase->transform(x)); 1.1238 + } 1.1239 + } else { 1.1240 + if( sub->Opcode() != Op_SubD || 1.1241 + sub->in(2) != x || 1.1242 + phase->type(sub->in(1)) != tzero ) return NULL; 1.1243 + x = new (phase->C, 2) AbsDNode(x); 1.1244 + if (flip) { 1.1245 + x = new (phase->C, 3) SubDNode(sub->in(1), phase->transform(x)); 1.1246 + } 1.1247 + } 1.1248 + 1.1249 + return x; 1.1250 +} 1.1251 + 1.1252 +//------------------------------split_once------------------------------------- 1.1253 +// Helper for split_flow_path 1.1254 +static void split_once(PhaseIterGVN *igvn, Node *phi, Node *val, Node *n, Node *newn) { 1.1255 + igvn->hash_delete(n); // Remove from hash before hacking edges 1.1256 + 1.1257 + uint j = 1; 1.1258 + for( uint i = phi->req()-1; i > 0; i-- ) { 1.1259 + if( phi->in(i) == val ) { // Found a path with val? 1.1260 + // Add to NEW Region/Phi, no DU info 1.1261 + newn->set_req( j++, n->in(i) ); 1.1262 + // Remove from OLD Region/Phi 1.1263 + n->del_req(i); 1.1264 + } 1.1265 + } 1.1266 + 1.1267 + // Register the new node but do not transform it. Cannot transform until the 1.1268 + // entire Region/Phi conglerate has been hacked as a single huge transform. 1.1269 + igvn->register_new_node_with_optimizer( newn ); 1.1270 + // Now I can point to the new node. 1.1271 + n->add_req(newn); 1.1272 + igvn->_worklist.push(n); 1.1273 +} 1.1274 + 1.1275 +//------------------------------split_flow_path-------------------------------- 1.1276 +// Check for merging identical values and split flow paths 1.1277 +static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) { 1.1278 + BasicType bt = phi->type()->basic_type(); 1.1279 + if( bt == T_ILLEGAL || type2size[bt] <= 0 ) 1.1280 + return NULL; // Bail out on funny non-value stuff 1.1281 + if( phi->req() <= 3 ) // Need at least 2 matched inputs and a 1.1282 + return NULL; // third unequal input to be worth doing 1.1283 + 1.1284 + // Scan for a constant 1.1285 + uint i; 1.1286 + for( i = 1; i < phi->req()-1; i++ ) { 1.1287 + Node *n = phi->in(i); 1.1288 + if( !n ) return NULL; 1.1289 + if( phase->type(n) == Type::TOP ) return NULL; 1.1290 + if( n->Opcode() == Op_ConP ) 1.1291 + break; 1.1292 + } 1.1293 + if( i >= phi->req() ) // Only split for constants 1.1294 + return NULL; 1.1295 + 1.1296 + Node *val = phi->in(i); // Constant to split for 1.1297 + uint hit = 0; // Number of times it occurs 1.1298 + 1.1299 + for( ; i < phi->req(); i++ ){ // Count occurances of constant 1.1300 + Node *n = phi->in(i); 1.1301 + if( !n ) return NULL; 1.1302 + if( phase->type(n) == Type::TOP ) return NULL; 1.1303 + if( phi->in(i) == val ) 1.1304 + hit++; 1.1305 + } 1.1306 + 1.1307 + if( hit <= 1 || // Make sure we find 2 or more 1.1308 + hit == phi->req()-1 ) // and not ALL the same value 1.1309 + return NULL; 1.1310 + 1.1311 + // Now start splitting out the flow paths that merge the same value. 1.1312 + // Split first the RegionNode. 1.1313 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.1314 + Node *r = phi->region(); 1.1315 + RegionNode *newr = new (phase->C, hit+1) RegionNode(hit+1); 1.1316 + split_once(igvn, phi, val, r, newr); 1.1317 + 1.1318 + // Now split all other Phis than this one 1.1319 + for (DUIterator_Fast kmax, k = r->fast_outs(kmax); k < kmax; k++) { 1.1320 + Node* phi2 = r->fast_out(k); 1.1321 + if( phi2->is_Phi() && phi2->as_Phi() != phi ) { 1.1322 + PhiNode *newphi = PhiNode::make_blank(newr, phi2); 1.1323 + split_once(igvn, phi, val, phi2, newphi); 1.1324 + } 1.1325 + } 1.1326 + 1.1327 + // Clean up this guy 1.1328 + igvn->hash_delete(phi); 1.1329 + for( i = phi->req()-1; i > 0; i-- ) { 1.1330 + if( phi->in(i) == val ) { 1.1331 + phi->del_req(i); 1.1332 + } 1.1333 + } 1.1334 + phi->add_req(val); 1.1335 + 1.1336 + return phi; 1.1337 +} 1.1338 + 1.1339 +//============================================================================= 1.1340 +//------------------------------simple_data_loop_check------------------------- 1.1341 +// Try to determing if the phi node in a simple safe/unsafe data loop. 1.1342 +// Returns: 1.1343 +// enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; 1.1344 +// Safe - safe case when the phi and it's inputs reference only safe data 1.1345 +// nodes; 1.1346 +// Unsafe - the phi and it's inputs reference unsafe data nodes but there 1.1347 +// is no reference back to the phi - need a graph walk 1.1348 +// to determine if it is in a loop; 1.1349 +// UnsafeLoop - unsafe case when the phi references itself directly or through 1.1350 +// unsafe data node. 1.1351 +// Note: a safe data node is a node which could/never reference itself during 1.1352 +// GVN transformations. For now it is Con, Proj, Phi, CastPP, CheckCastPP. 1.1353 +// I mark Phi nodes as safe node not only because they can reference itself 1.1354 +// but also to prevent mistaking the fallthrough case inside an outer loop 1.1355 +// as dead loop when the phi references itselfs through an other phi. 1.1356 +PhiNode::LoopSafety PhiNode::simple_data_loop_check(Node *in) const { 1.1357 + // It is unsafe loop if the phi node references itself directly. 1.1358 + if (in == (Node*)this) 1.1359 + return UnsafeLoop; // Unsafe loop 1.1360 + // Unsafe loop if the phi node references itself through an unsafe data node. 1.1361 + // Exclude cases with null inputs or data nodes which could reference 1.1362 + // itself (safe for dead loops). 1.1363 + if (in != NULL && !in->is_dead_loop_safe()) { 1.1364 + // Check inputs of phi's inputs also. 1.1365 + // It is much less expensive then full graph walk. 1.1366 + uint cnt = in->req(); 1.1367 + for (uint i = 1; i < cnt; ++i) { 1.1368 + Node* m = in->in(i); 1.1369 + if (m == (Node*)this) 1.1370 + return UnsafeLoop; // Unsafe loop 1.1371 + if (m != NULL && !m->is_dead_loop_safe()) { 1.1372 + // Check the most common case (about 30% of all cases): 1.1373 + // phi->Load/Store->AddP->(ConP ConP Con)/(Parm Parm Con). 1.1374 + Node *m1 = (m->is_AddP() && m->req() > 3) ? m->in(1) : NULL; 1.1375 + if (m1 == (Node*)this) 1.1376 + return UnsafeLoop; // Unsafe loop 1.1377 + if (m1 != NULL && m1 == m->in(2) && 1.1378 + m1->is_dead_loop_safe() && m->in(3)->is_Con()) { 1.1379 + continue; // Safe case 1.1380 + } 1.1381 + // The phi references an unsafe node - need full analysis. 1.1382 + return Unsafe; 1.1383 + } 1.1384 + } 1.1385 + } 1.1386 + return Safe; // Safe case - we can optimize the phi node. 1.1387 +} 1.1388 + 1.1389 +//------------------------------is_unsafe_data_reference----------------------- 1.1390 +// If phi can be reached through the data input - it is data loop. 1.1391 +bool PhiNode::is_unsafe_data_reference(Node *in) const { 1.1392 + assert(req() > 1, ""); 1.1393 + // First, check simple cases when phi references itself directly or 1.1394 + // through an other node. 1.1395 + LoopSafety safety = simple_data_loop_check(in); 1.1396 + if (safety == UnsafeLoop) 1.1397 + return true; // phi references itself - unsafe loop 1.1398 + else if (safety == Safe) 1.1399 + return false; // Safe case - phi could be replaced with the unique input. 1.1400 + 1.1401 + // Unsafe case when we should go through data graph to determine 1.1402 + // if the phi references itself. 1.1403 + 1.1404 + ResourceMark rm; 1.1405 + 1.1406 + Arena *a = Thread::current()->resource_area(); 1.1407 + Node_List nstack(a); 1.1408 + VectorSet visited(a); 1.1409 + 1.1410 + nstack.push(in); // Start with unique input. 1.1411 + visited.set(in->_idx); 1.1412 + while (nstack.size() != 0) { 1.1413 + Node* n = nstack.pop(); 1.1414 + uint cnt = n->req(); 1.1415 + for (uint i = 1; i < cnt; i++) { // Only data paths 1.1416 + Node* m = n->in(i); 1.1417 + if (m == (Node*)this) { 1.1418 + return true; // Data loop 1.1419 + } 1.1420 + if (m != NULL && !m->is_dead_loop_safe()) { // Only look for unsafe cases. 1.1421 + if (!visited.test_set(m->_idx)) 1.1422 + nstack.push(m); 1.1423 + } 1.1424 + } 1.1425 + } 1.1426 + return false; // The phi is not reachable from its inputs 1.1427 +} 1.1428 + 1.1429 + 1.1430 +//------------------------------Ideal------------------------------------------ 1.1431 +// Return a node which is more "ideal" than the current node. Must preserve 1.1432 +// the CFG, but we can still strip out dead paths. 1.1433 +Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1.1434 + // The next should never happen after 6297035 fix. 1.1435 + if( is_copy() ) // Already degraded to a Copy ? 1.1436 + return NULL; // No change 1.1437 + 1.1438 + Node *r = in(0); // RegionNode 1.1439 + assert(r->in(0) == NULL || !r->in(0)->is_Root(), "not a specially hidden merge"); 1.1440 + 1.1441 + // Note: During parsing, phis are often transformed before their regions. 1.1442 + // This means we have to use type_or_null to defend against untyped regions. 1.1443 + if( phase->type_or_null(r) == Type::TOP ) // Dead code? 1.1444 + return NULL; // No change 1.1445 + 1.1446 + Node *top = phase->C->top(); 1.1447 + 1.1448 + // The are 2 situations when only one valid phi's input is left 1.1449 + // (in addition to Region input). 1.1450 + // One: region is not loop - replace phi with this input. 1.1451 + // Two: region is loop - replace phi with top since this data path is dead 1.1452 + // and we need to break the dead data loop. 1.1453 + Node* progress = NULL; // Record if any progress made 1.1454 + for( uint j = 1; j < req(); ++j ){ // For all paths in 1.1455 + // Check unreachable control paths 1.1456 + Node* rc = r->in(j); 1.1457 + Node* n = in(j); // Get the input 1.1458 + if (rc == NULL || phase->type(rc) == Type::TOP) { 1.1459 + if (n != top) { // Not already top? 1.1460 + set_req(j, top); // Nuke it down 1.1461 + progress = this; // Record progress 1.1462 + } 1.1463 + } 1.1464 + } 1.1465 + 1.1466 + Node* uin = unique_input(phase); 1.1467 + if (uin == top) { // Simplest case: no alive inputs. 1.1468 + if (can_reshape) // IGVN transformation 1.1469 + return top; 1.1470 + else 1.1471 + return NULL; // Identity will return TOP 1.1472 + } else if (uin != NULL) { 1.1473 + // Only one not-NULL unique input path is left. 1.1474 + // Determine if this input is backedge of a loop. 1.1475 + // (Skip new phis which have no uses and dead regions). 1.1476 + if( outcnt() > 0 && r->in(0) != NULL ) { 1.1477 + // First, take the short cut when we know it is a loop and 1.1478 + // the EntryControl data path is dead. 1.1479 + assert(!r->is_Loop() || r->req() == 3, "Loop node should have 3 inputs"); 1.1480 + // Then, check if there is a data loop when phi references itself directly 1.1481 + // or through other data nodes. 1.1482 + if( r->is_Loop() && !phase->eqv_uncast(uin, in(LoopNode::EntryControl)) || 1.1483 + !r->is_Loop() && is_unsafe_data_reference(uin) ) { 1.1484 + // Break this data loop to avoid creation of a dead loop. 1.1485 + if (can_reshape) { 1.1486 + return top; 1.1487 + } else { 1.1488 + // We can't return top if we are in Parse phase - cut inputs only 1.1489 + // let Identity to handle the case. 1.1490 + replace_edge(uin, top); 1.1491 + return NULL; 1.1492 + } 1.1493 + } 1.1494 + } 1.1495 + 1.1496 + // One unique input. 1.1497 + debug_only(Node* ident = Identity(phase)); 1.1498 + // The unique input must eventually be detected by the Identity call. 1.1499 +#ifdef ASSERT 1.1500 + if (ident != uin && !ident->is_top()) { 1.1501 + // print this output before failing assert 1.1502 + r->dump(3); 1.1503 + this->dump(3); 1.1504 + ident->dump(); 1.1505 + uin->dump(); 1.1506 + } 1.1507 +#endif 1.1508 + assert(ident == uin || ident->is_top(), "Identity must clean this up"); 1.1509 + return NULL; 1.1510 + } 1.1511 + 1.1512 + 1.1513 + Node* opt = NULL; 1.1514 + int true_path = is_diamond_phi(); 1.1515 + if( true_path != 0 ) { 1.1516 + // Check for CMove'ing identity. If it would be unsafe, 1.1517 + // handle it here. In the safe case, let Identity handle it. 1.1518 + Node* unsafe_id = is_cmove_id(phase, true_path); 1.1519 + if( unsafe_id != NULL && is_unsafe_data_reference(unsafe_id) ) 1.1520 + opt = unsafe_id; 1.1521 + 1.1522 + // Check for simple convert-to-boolean pattern 1.1523 + if( opt == NULL ) 1.1524 + opt = is_x2logic(phase, this, true_path); 1.1525 + 1.1526 + // Check for absolute value 1.1527 + if( opt == NULL ) 1.1528 + opt = is_absolute(phase, this, true_path); 1.1529 + 1.1530 + // Check for conditional add 1.1531 + if( opt == NULL && can_reshape ) 1.1532 + opt = is_cond_add(phase, this, true_path); 1.1533 + 1.1534 + // These 4 optimizations could subsume the phi: 1.1535 + // have to check for a dead data loop creation. 1.1536 + if( opt != NULL ) { 1.1537 + if( opt == unsafe_id || is_unsafe_data_reference(opt) ) { 1.1538 + // Found dead loop. 1.1539 + if( can_reshape ) 1.1540 + return top; 1.1541 + // We can't return top if we are in Parse phase - cut inputs only 1.1542 + // to stop further optimizations for this phi. Identity will return TOP. 1.1543 + assert(req() == 3, "only diamond merge phi here"); 1.1544 + set_req(1, top); 1.1545 + set_req(2, top); 1.1546 + return NULL; 1.1547 + } else { 1.1548 + return opt; 1.1549 + } 1.1550 + } 1.1551 + } 1.1552 + 1.1553 + // Check for merging identical values and split flow paths 1.1554 + if (can_reshape) { 1.1555 + opt = split_flow_path(phase, this); 1.1556 + // This optimization only modifies phi - don't need to check for dead loop. 1.1557 + assert(opt == NULL || phase->eqv(opt, this), "do not elide phi"); 1.1558 + if (opt != NULL) return opt; 1.1559 + } 1.1560 + 1.1561 + if (in(1) != NULL && in(1)->Opcode() == Op_AddP && can_reshape) { 1.1562 + // Try to undo Phi of AddP: 1.1563 + // (Phi (AddP base base y) (AddP base2 base2 y)) 1.1564 + // becomes: 1.1565 + // newbase := (Phi base base2) 1.1566 + // (AddP newbase newbase y) 1.1567 + // 1.1568 + // This occurs as a result of unsuccessful split_thru_phi and 1.1569 + // interferes with taking advantage of addressing modes. See the 1.1570 + // clone_shift_expressions code in matcher.cpp 1.1571 + Node* addp = in(1); 1.1572 + const Type* type = addp->in(AddPNode::Base)->bottom_type(); 1.1573 + Node* y = addp->in(AddPNode::Offset); 1.1574 + if (y != NULL && addp->in(AddPNode::Base) == addp->in(AddPNode::Address)) { 1.1575 + // make sure that all the inputs are similar to the first one, 1.1576 + // i.e. AddP with base == address and same offset as first AddP 1.1577 + bool doit = true; 1.1578 + for (uint i = 2; i < req(); i++) { 1.1579 + if (in(i) == NULL || 1.1580 + in(i)->Opcode() != Op_AddP || 1.1581 + in(i)->in(AddPNode::Base) != in(i)->in(AddPNode::Address) || 1.1582 + in(i)->in(AddPNode::Offset) != y) { 1.1583 + doit = false; 1.1584 + break; 1.1585 + } 1.1586 + // Accumulate type for resulting Phi 1.1587 + type = type->meet(in(i)->in(AddPNode::Base)->bottom_type()); 1.1588 + } 1.1589 + Node* base = NULL; 1.1590 + if (doit) { 1.1591 + // Check for neighboring AddP nodes in a tree. 1.1592 + // If they have a base, use that it. 1.1593 + for (DUIterator_Fast kmax, k = this->fast_outs(kmax); k < kmax; k++) { 1.1594 + Node* u = this->fast_out(k); 1.1595 + if (u->is_AddP()) { 1.1596 + Node* base2 = u->in(AddPNode::Base); 1.1597 + if (base2 != NULL && !base2->is_top()) { 1.1598 + if (base == NULL) 1.1599 + base = base2; 1.1600 + else if (base != base2) 1.1601 + { doit = false; break; } 1.1602 + } 1.1603 + } 1.1604 + } 1.1605 + } 1.1606 + if (doit) { 1.1607 + if (base == NULL) { 1.1608 + base = new (phase->C, in(0)->req()) PhiNode(in(0), type, NULL); 1.1609 + for (uint i = 1; i < req(); i++) { 1.1610 + base->init_req(i, in(i)->in(AddPNode::Base)); 1.1611 + } 1.1612 + phase->is_IterGVN()->register_new_node_with_optimizer(base); 1.1613 + } 1.1614 + return new (phase->C, 4) AddPNode(base, base, y); 1.1615 + } 1.1616 + } 1.1617 + } 1.1618 + 1.1619 + // Split phis through memory merges, so that the memory merges will go away. 1.1620 + // Piggy-back this transformation on the search for a unique input.... 1.1621 + // It will be as if the merged memory is the unique value of the phi. 1.1622 + // (Do not attempt this optimization unless parsing is complete. 1.1623 + // It would make the parser's memory-merge logic sick.) 1.1624 + // (MergeMemNode is not dead_loop_safe - need to check for dead loop.) 1.1625 + if (progress == NULL && can_reshape && type() == Type::MEMORY) { 1.1626 + // see if this phi should be sliced 1.1627 + uint merge_width = 0; 1.1628 + bool saw_self = false; 1.1629 + for( uint i=1; i<req(); ++i ) {// For all paths in 1.1630 + Node *ii = in(i); 1.1631 + if (ii->is_MergeMem()) { 1.1632 + MergeMemNode* n = ii->as_MergeMem(); 1.1633 + merge_width = MAX2(merge_width, n->req()); 1.1634 + saw_self = saw_self || phase->eqv(n->base_memory(), this); 1.1635 + } 1.1636 + } 1.1637 + 1.1638 + // This restriction is temporarily necessary to ensure termination: 1.1639 + if (!saw_self && adr_type() == TypePtr::BOTTOM) merge_width = 0; 1.1640 + 1.1641 + if (merge_width > Compile::AliasIdxRaw) { 1.1642 + // found at least one non-empty MergeMem 1.1643 + const TypePtr* at = adr_type(); 1.1644 + if (at != TypePtr::BOTTOM) { 1.1645 + // Patch the existing phi to select an input from the merge: 1.1646 + // Phi:AT1(...MergeMem(m0, m1, m2)...) into 1.1647 + // Phi:AT1(...m1...) 1.1648 + int alias_idx = phase->C->get_alias_index(at); 1.1649 + for (uint i=1; i<req(); ++i) { 1.1650 + Node *ii = in(i); 1.1651 + if (ii->is_MergeMem()) { 1.1652 + MergeMemNode* n = ii->as_MergeMem(); 1.1653 + // compress paths and change unreachable cycles to TOP 1.1654 + // If not, we can update the input infinitely along a MergeMem cycle 1.1655 + // Equivalent code is in MemNode::Ideal_common 1.1656 + Node *m = phase->transform(n); 1.1657 + // If tranformed to a MergeMem, get the desired slice 1.1658 + // Otherwise the returned node represents memory for every slice 1.1659 + Node *new_mem = (m->is_MergeMem()) ? 1.1660 + m->as_MergeMem()->memory_at(alias_idx) : m; 1.1661 + // Update input if it is progress over what we have now 1.1662 + if (new_mem != ii) { 1.1663 + set_req(i, new_mem); 1.1664 + progress = this; 1.1665 + } 1.1666 + } 1.1667 + } 1.1668 + } else { 1.1669 + // We know that at least one MergeMem->base_memory() == this 1.1670 + // (saw_self == true). If all other inputs also references this phi 1.1671 + // (directly or through data nodes) - it is dead loop. 1.1672 + bool saw_safe_input = false; 1.1673 + for (uint j = 1; j < req(); ++j) { 1.1674 + Node *n = in(j); 1.1675 + if (n->is_MergeMem() && n->as_MergeMem()->base_memory() == this) 1.1676 + continue; // skip known cases 1.1677 + if (!is_unsafe_data_reference(n)) { 1.1678 + saw_safe_input = true; // found safe input 1.1679 + break; 1.1680 + } 1.1681 + } 1.1682 + if (!saw_safe_input) 1.1683 + return top; // all inputs reference back to this phi - dead loop 1.1684 + 1.1685 + // Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into 1.1686 + // MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...)) 1.1687 + PhaseIterGVN *igvn = phase->is_IterGVN(); 1.1688 + Node* hook = new (phase->C, 1) Node(1); 1.1689 + PhiNode* new_base = (PhiNode*) clone(); 1.1690 + // Must eagerly register phis, since they participate in loops. 1.1691 + if (igvn) { 1.1692 + igvn->register_new_node_with_optimizer(new_base); 1.1693 + hook->add_req(new_base); 1.1694 + } 1.1695 + MergeMemNode* result = MergeMemNode::make(phase->C, new_base); 1.1696 + for (uint i = 1; i < req(); ++i) { 1.1697 + Node *ii = in(i); 1.1698 + if (ii->is_MergeMem()) { 1.1699 + MergeMemNode* n = ii->as_MergeMem(); 1.1700 + for (MergeMemStream mms(result, n); mms.next_non_empty2(); ) { 1.1701 + // If we have not seen this slice yet, make a phi for it. 1.1702 + bool made_new_phi = false; 1.1703 + if (mms.is_empty()) { 1.1704 + Node* new_phi = new_base->slice_memory(mms.adr_type(phase->C)); 1.1705 + made_new_phi = true; 1.1706 + if (igvn) { 1.1707 + igvn->register_new_node_with_optimizer(new_phi); 1.1708 + hook->add_req(new_phi); 1.1709 + } 1.1710 + mms.set_memory(new_phi); 1.1711 + } 1.1712 + Node* phi = mms.memory(); 1.1713 + assert(made_new_phi || phi->in(i) == n, "replace the i-th merge by a slice"); 1.1714 + phi->set_req(i, mms.memory2()); 1.1715 + } 1.1716 + } 1.1717 + } 1.1718 + // Distribute all self-loops. 1.1719 + { // (Extra braces to hide mms.) 1.1720 + for (MergeMemStream mms(result); mms.next_non_empty(); ) { 1.1721 + Node* phi = mms.memory(); 1.1722 + for (uint i = 1; i < req(); ++i) { 1.1723 + if (phi->in(i) == this) phi->set_req(i, phi); 1.1724 + } 1.1725 + } 1.1726 + } 1.1727 + // now transform the new nodes, and return the mergemem 1.1728 + for (MergeMemStream mms(result); mms.next_non_empty(); ) { 1.1729 + Node* phi = mms.memory(); 1.1730 + mms.set_memory(phase->transform(phi)); 1.1731 + } 1.1732 + if (igvn) { // Unhook. 1.1733 + igvn->hash_delete(hook); 1.1734 + for (uint i = 1; i < hook->req(); i++) { 1.1735 + hook->set_req(i, NULL); 1.1736 + } 1.1737 + } 1.1738 + // Replace self with the result. 1.1739 + return result; 1.1740 + } 1.1741 + } 1.1742 + } 1.1743 + 1.1744 + return progress; // Return any progress 1.1745 +} 1.1746 + 1.1747 +//------------------------------out_RegMask------------------------------------ 1.1748 +const RegMask &PhiNode::in_RegMask(uint i) const { 1.1749 + return i ? out_RegMask() : RegMask::Empty; 1.1750 +} 1.1751 + 1.1752 +const RegMask &PhiNode::out_RegMask() const { 1.1753 + uint ideal_reg = Matcher::base2reg[_type->base()]; 1.1754 + assert( ideal_reg != Node::NotAMachineReg, "invalid type at Phi" ); 1.1755 + if( ideal_reg == 0 ) return RegMask::Empty; 1.1756 + return *(Compile::current()->matcher()->idealreg2spillmask[ideal_reg]); 1.1757 +} 1.1758 + 1.1759 +#ifndef PRODUCT 1.1760 +void PhiNode::dump_spec(outputStream *st) const { 1.1761 + TypeNode::dump_spec(st); 1.1762 + if (in(0) != NULL && 1.1763 + in(0)->is_CountedLoop() && 1.1764 + in(0)->as_CountedLoop()->phi() == this) { 1.1765 + st->print(" #tripcount"); 1.1766 + } 1.1767 +} 1.1768 +#endif 1.1769 + 1.1770 + 1.1771 +//============================================================================= 1.1772 +const Type *GotoNode::Value( PhaseTransform *phase ) const { 1.1773 + // If the input is reachable, then we are executed. 1.1774 + // If the input is not reachable, then we are not executed. 1.1775 + return phase->type(in(0)); 1.1776 +} 1.1777 + 1.1778 +Node *GotoNode::Identity( PhaseTransform *phase ) { 1.1779 + return in(0); // Simple copy of incoming control 1.1780 +} 1.1781 + 1.1782 +const RegMask &GotoNode::out_RegMask() const { 1.1783 + return RegMask::Empty; 1.1784 +} 1.1785 + 1.1786 +//============================================================================= 1.1787 +const RegMask &JumpNode::out_RegMask() const { 1.1788 + return RegMask::Empty; 1.1789 +} 1.1790 + 1.1791 +//============================================================================= 1.1792 +const RegMask &JProjNode::out_RegMask() const { 1.1793 + return RegMask::Empty; 1.1794 +} 1.1795 + 1.1796 +//============================================================================= 1.1797 +const RegMask &CProjNode::out_RegMask() const { 1.1798 + return RegMask::Empty; 1.1799 +} 1.1800 + 1.1801 + 1.1802 + 1.1803 +//============================================================================= 1.1804 + 1.1805 +uint PCTableNode::hash() const { return Node::hash() + _size; } 1.1806 +uint PCTableNode::cmp( const Node &n ) const 1.1807 +{ return _size == ((PCTableNode&)n)._size; } 1.1808 + 1.1809 +const Type *PCTableNode::bottom_type() const { 1.1810 + const Type** f = TypeTuple::fields(_size); 1.1811 + for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; 1.1812 + return TypeTuple::make(_size, f); 1.1813 +} 1.1814 + 1.1815 +//------------------------------Value------------------------------------------ 1.1816 +// Compute the type of the PCTableNode. If reachable it is a tuple of 1.1817 +// Control, otherwise the table targets are not reachable 1.1818 +const Type *PCTableNode::Value( PhaseTransform *phase ) const { 1.1819 + if( phase->type(in(0)) == Type::CONTROL ) 1.1820 + return bottom_type(); 1.1821 + return Type::TOP; // All paths dead? Then so are we 1.1822 +} 1.1823 + 1.1824 +//------------------------------Ideal------------------------------------------ 1.1825 +// Return a node which is more "ideal" than the current node. Strip out 1.1826 +// control copies 1.1827 +Node *PCTableNode::Ideal(PhaseGVN *phase, bool can_reshape) { 1.1828 + return remove_dead_region(phase, can_reshape) ? this : NULL; 1.1829 +} 1.1830 + 1.1831 +//============================================================================= 1.1832 +uint JumpProjNode::hash() const { 1.1833 + return Node::hash() + _dest_bci; 1.1834 +} 1.1835 + 1.1836 +uint JumpProjNode::cmp( const Node &n ) const { 1.1837 + return ProjNode::cmp(n) && 1.1838 + _dest_bci == ((JumpProjNode&)n)._dest_bci; 1.1839 +} 1.1840 + 1.1841 +#ifndef PRODUCT 1.1842 +void JumpProjNode::dump_spec(outputStream *st) const { 1.1843 + ProjNode::dump_spec(st); 1.1844 + st->print("@bci %d ",_dest_bci); 1.1845 +} 1.1846 +#endif 1.1847 + 1.1848 +//============================================================================= 1.1849 +//------------------------------Value------------------------------------------ 1.1850 +// Check for being unreachable, or for coming from a Rethrow. Rethrow's cannot 1.1851 +// have the default "fall_through_index" path. 1.1852 +const Type *CatchNode::Value( PhaseTransform *phase ) const { 1.1853 + // Unreachable? Then so are all paths from here. 1.1854 + if( phase->type(in(0)) == Type::TOP ) return Type::TOP; 1.1855 + // First assume all paths are reachable 1.1856 + const Type** f = TypeTuple::fields(_size); 1.1857 + for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL; 1.1858 + // Identify cases that will always throw an exception 1.1859 + // () rethrow call 1.1860 + // () virtual or interface call with NULL receiver 1.1861 + // () call is a check cast with incompatible arguments 1.1862 + if( in(1)->is_Proj() ) { 1.1863 + Node *i10 = in(1)->in(0); 1.1864 + if( i10->is_Call() ) { 1.1865 + CallNode *call = i10->as_Call(); 1.1866 + // Rethrows always throw exceptions, never return 1.1867 + if (call->entry_point() == OptoRuntime::rethrow_stub()) { 1.1868 + f[CatchProjNode::fall_through_index] = Type::TOP; 1.1869 + } else if( call->req() > TypeFunc::Parms ) { 1.1870 + const Type *arg0 = phase->type( call->in(TypeFunc::Parms) ); 1.1871 + // Check for null reciever to virtual or interface calls 1.1872 + if( call->is_CallDynamicJava() && 1.1873 + arg0->higher_equal(TypePtr::NULL_PTR) ) { 1.1874 + f[CatchProjNode::fall_through_index] = Type::TOP; 1.1875 + } 1.1876 + } // End of if not a runtime stub 1.1877 + } // End of if have call above me 1.1878 + } // End of slot 1 is not a projection 1.1879 + return TypeTuple::make(_size, f); 1.1880 +} 1.1881 + 1.1882 +//============================================================================= 1.1883 +uint CatchProjNode::hash() const { 1.1884 + return Node::hash() + _handler_bci; 1.1885 +} 1.1886 + 1.1887 + 1.1888 +uint CatchProjNode::cmp( const Node &n ) const { 1.1889 + return ProjNode::cmp(n) && 1.1890 + _handler_bci == ((CatchProjNode&)n)._handler_bci; 1.1891 +} 1.1892 + 1.1893 + 1.1894 +//------------------------------Identity--------------------------------------- 1.1895 +// If only 1 target is possible, choose it if it is the main control 1.1896 +Node *CatchProjNode::Identity( PhaseTransform *phase ) { 1.1897 + // If my value is control and no other value is, then treat as ID 1.1898 + const TypeTuple *t = phase->type(in(0))->is_tuple(); 1.1899 + if (t->field_at(_con) != Type::CONTROL) return this; 1.1900 + // If we remove the last CatchProj and elide the Catch/CatchProj, then we 1.1901 + // also remove any exception table entry. Thus we must know the call 1.1902 + // feeding the Catch will not really throw an exception. This is ok for 1.1903 + // the main fall-thru control (happens when we know a call can never throw 1.1904 + // an exception) or for "rethrow", because a further optimnization will 1.1905 + // yank the rethrow (happens when we inline a function that can throw an 1.1906 + // exception and the caller has no handler). Not legal, e.g., for passing 1.1907 + // a NULL receiver to a v-call, or passing bad types to a slow-check-cast. 1.1908 + // These cases MUST throw an exception via the runtime system, so the VM 1.1909 + // will be looking for a table entry. 1.1910 + Node *proj = in(0)->in(1); // Expect a proj feeding CatchNode 1.1911 + CallNode *call; 1.1912 + if (_con != TypeFunc::Control && // Bail out if not the main control. 1.1913 + !(proj->is_Proj() && // AND NOT a rethrow 1.1914 + proj->in(0)->is_Call() && 1.1915 + (call = proj->in(0)->as_Call()) && 1.1916 + call->entry_point() == OptoRuntime::rethrow_stub())) 1.1917 + return this; 1.1918 + 1.1919 + // Search for any other path being control 1.1920 + for (uint i = 0; i < t->cnt(); i++) { 1.1921 + if (i != _con && t->field_at(i) == Type::CONTROL) 1.1922 + return this; 1.1923 + } 1.1924 + // Only my path is possible; I am identity on control to the jump 1.1925 + return in(0)->in(0); 1.1926 +} 1.1927 + 1.1928 + 1.1929 +#ifndef PRODUCT 1.1930 +void CatchProjNode::dump_spec(outputStream *st) const { 1.1931 + ProjNode::dump_spec(st); 1.1932 + st->print("@bci %d ",_handler_bci); 1.1933 +} 1.1934 +#endif 1.1935 + 1.1936 +//============================================================================= 1.1937 +//------------------------------Identity--------------------------------------- 1.1938 +// Check for CreateEx being Identity. 1.1939 +Node *CreateExNode::Identity( PhaseTransform *phase ) { 1.1940 + if( phase->type(in(1)) == Type::TOP ) return in(1); 1.1941 + if( phase->type(in(0)) == Type::TOP ) return in(0); 1.1942 + // We only come from CatchProj, unless the CatchProj goes away. 1.1943 + // If the CatchProj is optimized away, then we just carry the 1.1944 + // exception oop through. 1.1945 + CallNode *call = in(1)->in(0)->as_Call(); 1.1946 + 1.1947 + return ( in(0)->is_CatchProj() && in(0)->in(0)->in(1) == in(1) ) 1.1948 + ? this 1.1949 + : call->in(TypeFunc::Parms); 1.1950 +} 1.1951 + 1.1952 +//============================================================================= 1.1953 +#ifndef PRODUCT 1.1954 +void NeverBranchNode::format( PhaseRegAlloc *ra_, outputStream *st) const { 1.1955 + st->print("%s", Name()); 1.1956 +} 1.1957 +#endif