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