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