1 /*
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "memory/allocation.inline.hpp"
27 #include "opto/addnode.hpp"
28 #include "opto/compile.hpp"
29 #include "opto/connode.hpp"
30 #include "opto/machnode.hpp"
31 #include "opto/matcher.hpp"
32 #include "opto/memnode.hpp"
33 #include "opto/phaseX.hpp"
34 #include "opto/subnode.hpp"
35 #include "runtime/sharedRuntime.hpp"
36
37 // Optimization - Graph Style
38
39 //=============================================================================
40 //------------------------------hash-------------------------------------------
41 uint ConNode::hash() const {
42 return (uintptr_t)in(TypeFunc::Control) + _type->hash();
43 }
44
45 //------------------------------make-------------------------------------------
46 ConNode *ConNode::make( Compile* C, const Type *t ) {
47 switch( t->basic_type() ) {
48 case T_INT: return new (C) ConINode( t->is_int() );
49 case T_LONG: return new (C) ConLNode( t->is_long() );
50 case T_FLOAT: return new (C) ConFNode( t->is_float_constant() );
51 case T_DOUBLE: return new (C) ConDNode( t->is_double_constant() );
52 case T_VOID: return new (C) ConNode ( Type::TOP );
53 case T_OBJECT: return new (C) ConPNode( t->is_ptr() );
54 case T_ARRAY: return new (C) ConPNode( t->is_aryptr() );
55 case T_ADDRESS: return new (C) ConPNode( t->is_ptr() );
56 case T_NARROWOOP: return new (C) ConNNode( t->is_narrowoop() );
57 case T_NARROWKLASS: return new (C) ConNKlassNode( t->is_narrowklass() );
58 case T_METADATA: return new (C) ConPNode( t->is_ptr() );
59 // Expected cases: TypePtr::NULL_PTR, any is_rawptr()
60 // Also seen: AnyPtr(TopPTR *+top); from command line:
61 // r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660
62 // %%%% Stop using TypePtr::NULL_PTR to represent nulls: use either TypeRawPtr::NULL_PTR
63 // or else TypeOopPtr::NULL_PTR. Then set Type::_basic_type[AnyPtr] = T_ILLEGAL
64 }
65 ShouldNotReachHere();
66 return NULL;
67 }
68
69 //=============================================================================
70 /*
71 The major change is for CMoveP and StrComp. They have related but slightly
72 different problems. They both take in TWO oops which are both null-checked
73 independently before the using Node. After CCP removes the CastPP's they need
74 to pick up the guarding test edge - in this case TWO control edges. I tried
75 various solutions, all have problems:
76
77 (1) Do nothing. This leads to a bug where we hoist a Load from a CMoveP or a
78 StrComp above a guarding null check. I've seen both cases in normal -Xcomp
79 testing.
80
81 (2) Plug the control edge from 1 of the 2 oops in. Apparent problem here is
82 to figure out which test post-dominates. The real problem is that it doesn't
83 matter which one you pick. After you pick up, the dominating-test elider in
84 IGVN can remove the test and allow you to hoist up to the dominating test on
85 the chosen oop bypassing the test on the not-chosen oop. Seen in testing.
86 Oops.
87
88 (3) Leave the CastPP's in. This makes the graph more accurate in some sense;
89 we get to keep around the knowledge that an oop is not-null after some test.
90 Alas, the CastPP's interfere with GVN (some values are the regular oop, some
91 are the CastPP of the oop, all merge at Phi's which cannot collapse, etc).
92 This cost us 10% on SpecJVM, even when I removed some of the more trivial
93 cases in the optimizer. Removing more useless Phi's started allowing Loads to
94 illegally float above null checks. I gave up on this approach.
95
96 (4) Add BOTH control edges to both tests. Alas, too much code knows that
97 control edges are in slot-zero ONLY. Many quick asserts fail; no way to do
98 this one. Note that I really want to allow the CMoveP to float and add both
99 control edges to the dependent Load op - meaning I can select early but I
100 cannot Load until I pass both tests.
101
102 (5) Do not hoist CMoveP and StrComp. To this end I added the v-call
103 depends_only_on_test(). No obvious performance loss on Spec, but we are
104 clearly conservative on CMoveP (also so on StrComp but that's unlikely to
105 matter ever).
106
107 */
108
109
110 //------------------------------Ideal------------------------------------------
111 // Return a node which is more "ideal" than the current node.
112 // Move constants to the right.
113 Node *CMoveNode::Ideal(PhaseGVN *phase, bool can_reshape) {
114 if( in(0) && remove_dead_region(phase, can_reshape) ) return this;
115 // Don't bother trying to transform a dead node
116 if( in(0) && in(0)->is_top() ) return NULL;
117 assert( !phase->eqv(in(Condition), this) &&
118 !phase->eqv(in(IfFalse), this) &&
119 !phase->eqv(in(IfTrue), this), "dead loop in CMoveNode::Ideal" );
120 if( phase->type(in(Condition)) == Type::TOP )
121 return NULL; // return NULL when Condition is dead
122
123 if( in(IfFalse)->is_Con() && !in(IfTrue)->is_Con() ) {
124 if( in(Condition)->is_Bool() ) {
125 BoolNode* b = in(Condition)->as_Bool();
126 BoolNode* b2 = b->negate(phase);
127 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );
128 }
129 }
130 return NULL;
131 }
132
133 //------------------------------is_cmove_id------------------------------------
134 // Helper function to check for CMOVE identity. Shared with PhiNode::Identity
135 Node *CMoveNode::is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ) {
136 // Check for Cmp'ing and CMove'ing same values
137 if( (phase->eqv(cmp->in(1),f) &&
138 phase->eqv(cmp->in(2),t)) ||
139 // Swapped Cmp is OK
140 (phase->eqv(cmp->in(2),f) &&
141 phase->eqv(cmp->in(1),t)) ) {
142 // Give up this identity check for floating points because it may choose incorrect
143 // value around 0.0 and -0.0
144 if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD )
145 return NULL;
146 // Check for "(t==f)?t:f;" and replace with "f"
147 if( b->_test._test == BoolTest::eq )
148 return f;
149 // Allow the inverted case as well
150 // Check for "(t!=f)?t:f;" and replace with "t"
151 if( b->_test._test == BoolTest::ne )
152 return t;
153 }
154 return NULL;
155 }
156
157 //------------------------------Identity---------------------------------------
158 // Conditional-move is an identity if both inputs are the same, or the test
159 // true or false.
160 Node *CMoveNode::Identity( PhaseTransform *phase ) {
161 if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs?
162 return in(IfFalse); // Then it doesn't matter
163 if( phase->type(in(Condition)) == TypeInt::ZERO )
164 return in(IfFalse); // Always pick left(false) input
165 if( phase->type(in(Condition)) == TypeInt::ONE )
166 return in(IfTrue); // Always pick right(true) input
167
168 // Check for CMove'ing a constant after comparing against the constant.
169 // Happens all the time now, since if we compare equality vs a constant in
170 // the parser, we "know" the variable is constant on one path and we force
171 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a
172 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more
173 // general in that we don't need constants.
174 if( in(Condition)->is_Bool() ) {
175 BoolNode *b = in(Condition)->as_Bool();
176 Node *cmp = b->in(1);
177 if( cmp->is_Cmp() ) {
178 Node *id = is_cmove_id( phase, cmp, in(IfTrue), in(IfFalse), b );
179 if( id ) return id;
180 }
181 }
182
183 return this;
184 }
185
186 //------------------------------Value------------------------------------------
187 // Result is the meet of inputs
188 const Type *CMoveNode::Value( PhaseTransform *phase ) const {
189 if( phase->type(in(Condition)) == Type::TOP )
190 return Type::TOP;
191 return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue)));
192 }
193
194 //------------------------------make-------------------------------------------
195 // Make a correctly-flavored CMove. Since _type is directly determined
196 // from the inputs we do not need to specify it here.
197 CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) {
198 switch( t->basic_type() ) {
199 case T_INT: return new (C) CMoveINode( bol, left, right, t->is_int() );
200 case T_FLOAT: return new (C) CMoveFNode( bol, left, right, t );
201 case T_DOUBLE: return new (C) CMoveDNode( bol, left, right, t );
202 case T_LONG: return new (C) CMoveLNode( bol, left, right, t->is_long() );
203 case T_OBJECT: return new (C) CMovePNode( c, bol, left, right, t->is_oopptr() );
204 case T_ADDRESS: return new (C) CMovePNode( c, bol, left, right, t->is_ptr() );
205 case T_NARROWOOP: return new (C) CMoveNNode( c, bol, left, right, t );
206 default:
207 ShouldNotReachHere();
208 return NULL;
209 }
210 }
211
212 //=============================================================================
213 //------------------------------Ideal------------------------------------------
214 // Return a node which is more "ideal" than the current node.
215 // Check for conversions to boolean
216 Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) {
217 // Try generic ideal's first
218 Node *x = CMoveNode::Ideal(phase, can_reshape);
219 if( x ) return x;
220
221 // If zero is on the left (false-case, no-move-case) it must mean another
222 // constant is on the right (otherwise the shared CMove::Ideal code would
223 // have moved the constant to the right). This situation is bad for Intel
224 // and a don't-care for Sparc. It's bad for Intel because the zero has to
225 // be manifested in a register with a XOR which kills flags, which are live
226 // on input to the CMoveI, leading to a situation which causes excessive
227 // spilling on Intel. For Sparc, if the zero in on the left the Sparc will
228 // zero a register via G0 and conditionally-move the other constant. If the
229 // zero is on the right, the Sparc will load the first constant with a
230 // 13-bit set-lo and conditionally move G0. See bug 4677505.
231 if( phase->type(in(IfFalse)) == TypeInt::ZERO && !(phase->type(in(IfTrue)) == TypeInt::ZERO) ) {
232 if( in(Condition)->is_Bool() ) {
233 BoolNode* b = in(Condition)->as_Bool();
234 BoolNode* b2 = b->negate(phase);
235 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );
236 }
237 }
238
239 // Now check for booleans
240 int flip = 0;
241
242 // Check for picking from zero/one
243 if( phase->type(in(IfFalse)) == TypeInt::ZERO && phase->type(in(IfTrue)) == TypeInt::ONE ) {
244 flip = 1 - flip;
245 } else if( phase->type(in(IfFalse)) == TypeInt::ONE && phase->type(in(IfTrue)) == TypeInt::ZERO ) {
246 } else return NULL;
247
248 // Check for eq/ne test
249 if( !in(1)->is_Bool() ) return NULL;
250 BoolNode *bol = in(1)->as_Bool();
251 if( bol->_test._test == BoolTest::eq ) {
252 } else if( bol->_test._test == BoolTest::ne ) {
253 flip = 1-flip;
254 } else return NULL;
255
256 // Check for vs 0 or 1
257 if( !bol->in(1)->is_Cmp() ) return NULL;
258 const CmpNode *cmp = bol->in(1)->as_Cmp();
259 if( phase->type(cmp->in(2)) == TypeInt::ZERO ) {
260 } else if( phase->type(cmp->in(2)) == TypeInt::ONE ) {
261 // Allow cmp-vs-1 if the other input is bounded by 0-1
262 if( phase->type(cmp->in(1)) != TypeInt::BOOL )
263 return NULL;
264 flip = 1 - flip;
265 } else return NULL;
266
267 // Convert to a bool (flipped)
268 // Build int->bool conversion
269 #ifndef PRODUCT
270 if( PrintOpto ) tty->print_cr("CMOV to I2B");
271 #endif
272 Node *n = new (phase->C) Conv2BNode( cmp->in(1) );
273 if( flip )
274 n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) );
275
276 return n;
277 }
278
279 //=============================================================================
280 //------------------------------Ideal------------------------------------------
281 // Return a node which is more "ideal" than the current node.
282 // Check for absolute value
283 Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
284 // Try generic ideal's first
285 Node *x = CMoveNode::Ideal(phase, can_reshape);
286 if( x ) return x;
287
288 int cmp_zero_idx = 0; // Index of compare input where to look for zero
289 int phi_x_idx = 0; // Index of phi input where to find naked x
290
291 // Find the Bool
292 if( !in(1)->is_Bool() ) return NULL;
293 BoolNode *bol = in(1)->as_Bool();
294 // Check bool sense
295 switch( bol->_test._test ) {
296 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break;
297 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;
298 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break;
299 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;
300 default: return NULL; break;
301 }
302
303 // Find zero input of CmpF; the other input is being abs'd
304 Node *cmpf = bol->in(1);
305 if( cmpf->Opcode() != Op_CmpF ) return NULL;
306 Node *X = NULL;
307 bool flip = false;
308 if( phase->type(cmpf->in(cmp_zero_idx)) == TypeF::ZERO ) {
309 X = cmpf->in(3 - cmp_zero_idx);
310 } else if (phase->type(cmpf->in(3 - cmp_zero_idx)) == TypeF::ZERO) {
311 // The test is inverted, we should invert the result...
312 X = cmpf->in(cmp_zero_idx);
313 flip = true;
314 } else {
315 return NULL;
316 }
317
318 // If X is found on the appropriate phi input, find the subtract on the other
319 if( X != in(phi_x_idx) ) return NULL;
320 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;
321 Node *sub = in(phi_sub_idx);
322
323 // Allow only SubF(0,X) and fail out for all others; NegF is not OK
324 if( sub->Opcode() != Op_SubF ||
325 sub->in(2) != X ||
326 phase->type(sub->in(1)) != TypeF::ZERO ) return NULL;
327
328 Node *abs = new (phase->C) AbsFNode( X );
329 if( flip )
330 abs = new (phase->C) SubFNode(sub->in(1), phase->transform(abs));
331
332 return abs;
333 }
334
335 //=============================================================================
336 //------------------------------Ideal------------------------------------------
337 // Return a node which is more "ideal" than the current node.
338 // Check for absolute value
339 Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
340 // Try generic ideal's first
341 Node *x = CMoveNode::Ideal(phase, can_reshape);
342 if( x ) return x;
343
344 int cmp_zero_idx = 0; // Index of compare input where to look for zero
345 int phi_x_idx = 0; // Index of phi input where to find naked x
346
347 // Find the Bool
348 if( !in(1)->is_Bool() ) return NULL;
349 BoolNode *bol = in(1)->as_Bool();
350 // Check bool sense
351 switch( bol->_test._test ) {
352 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break;
353 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;
354 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break;
355 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;
356 default: return NULL; break;
357 }
358
359 // Find zero input of CmpD; the other input is being abs'd
360 Node *cmpd = bol->in(1);
361 if( cmpd->Opcode() != Op_CmpD ) return NULL;
362 Node *X = NULL;
363 bool flip = false;
364 if( phase->type(cmpd->in(cmp_zero_idx)) == TypeD::ZERO ) {
365 X = cmpd->in(3 - cmp_zero_idx);
366 } else if (phase->type(cmpd->in(3 - cmp_zero_idx)) == TypeD::ZERO) {
367 // The test is inverted, we should invert the result...
368 X = cmpd->in(cmp_zero_idx);
369 flip = true;
370 } else {
371 return NULL;
372 }
373
374 // If X is found on the appropriate phi input, find the subtract on the other
375 if( X != in(phi_x_idx) ) return NULL;
376 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;
377 Node *sub = in(phi_sub_idx);
378
379 // Allow only SubD(0,X) and fail out for all others; NegD is not OK
380 if( sub->Opcode() != Op_SubD ||
381 sub->in(2) != X ||
382 phase->type(sub->in(1)) != TypeD::ZERO ) return NULL;
383
384 Node *abs = new (phase->C) AbsDNode( X );
385 if( flip )
386 abs = new (phase->C) SubDNode(sub->in(1), phase->transform(abs));
387
388 return abs;
389 }
390
391
392 //=============================================================================
393 // If input is already higher or equal to cast type, then this is an identity.
394 Node *ConstraintCastNode::Identity( PhaseTransform *phase ) {
395 return phase->type(in(1))->higher_equal_speculative(_type) ? in(1) : this;
396 }
397
398 //------------------------------Value------------------------------------------
399 // Take 'join' of input and cast-up type
400 const Type *ConstraintCastNode::Value( PhaseTransform *phase ) const {
401 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
402 const Type* ft = phase->type(in(1))->filter_speculative(_type);
403
404 #ifdef ASSERT
405 // Previous versions of this function had some special case logic,
406 // which is no longer necessary. Make sure of the required effects.
407 switch (Opcode()) {
408 case Op_CastII:
409 {
410 const Type* t1 = phase->type(in(1));
411 if( t1 == Type::TOP ) assert(ft == Type::TOP, "special case #1");
412 const Type* rt = t1->join_speculative(_type);
413 if (rt->empty()) assert(ft == Type::TOP, "special case #2");
414 break;
415 }
416 case Op_CastPP:
417 if (phase->type(in(1)) == TypePtr::NULL_PTR &&
418 _type->isa_ptr() && _type->is_ptr()->_ptr == TypePtr::NotNull)
419 assert(ft == Type::TOP, "special case #3");
420 break;
421 }
422 #endif //ASSERT
423
424 return ft;
425 }
426
427 //------------------------------Ideal------------------------------------------
428 // Return a node which is more "ideal" than the current node. Strip out
429 // control copies
430 Node *ConstraintCastNode::Ideal(PhaseGVN *phase, bool can_reshape){
431 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
432 }
433
434 //------------------------------Ideal_DU_postCCP-------------------------------
435 // Throw away cast after constant propagation
436 Node *ConstraintCastNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {
437 const Type *t = ccp->type(in(1));
438 ccp->hash_delete(this);
439 set_type(t); // Turn into ID function
440 ccp->hash_insert(this);
441 return this;
442 }
443
444
445 //=============================================================================
446
447 //------------------------------Ideal_DU_postCCP-------------------------------
448 // If not converting int->oop, throw away cast after constant propagation
449 Node *CastPPNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {
450 const Type *t = ccp->type(in(1));
451 if (!t->isa_oop_ptr() || ((in(1)->is_DecodeN()) && Matcher::gen_narrow_oop_implicit_null_checks())) {
452 return NULL; // do not transform raw pointers or narrow oops
453 }
454 return ConstraintCastNode::Ideal_DU_postCCP(ccp);
455 }
456
457
458
459 //=============================================================================
460 //------------------------------Identity---------------------------------------
461 // If input is already higher or equal to cast type, then this is an identity.
462 Node *CheckCastPPNode::Identity( PhaseTransform *phase ) {
463 // Toned down to rescue meeting at a Phi 3 different oops all implementing
464 // the same interface. CompileTheWorld starting at 502, kd12rc1.zip.
465 return (phase->type(in(1)) == phase->type(this)) ? in(1) : this;
466 }
467
468 //------------------------------Value------------------------------------------
469 // Take 'join' of input and cast-up type, unless working with an Interface
470 const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {
471 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
472
473 const Type *inn = phase->type(in(1));
474 if( inn == Type::TOP ) return Type::TOP; // No information yet
475
476 const TypePtr *in_type = inn->isa_ptr();
477 const TypePtr *my_type = _type->isa_ptr();
478 const Type *result = _type;
479 if( in_type != NULL && my_type != NULL ) {
480 TypePtr::PTR in_ptr = in_type->ptr();
481 if( in_ptr == TypePtr::Null ) {
482 result = in_type;
483 } else if( in_ptr == TypePtr::Constant ) {
484 // Casting a constant oop to an interface?
485 // (i.e., a String to a Comparable?)
486 // Then return the interface.
487 const TypeOopPtr *jptr = my_type->isa_oopptr();
488 assert( jptr, "" );
489 result = (jptr->klass()->is_interface() || !in_type->higher_equal(_type))
490 ? my_type->cast_to_ptr_type( TypePtr::NotNull )
491 : in_type;
492 } else {
493 result = my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) );
494 }
495 }
496
497 // This is the code from TypePtr::xmeet() that prevents us from
498 // having 2 ways to represent the same type. We have to replicate it
499 // here because we don't go through meet/join.
500 if (result->remove_speculative() == result->speculative()) {
501 result = result->remove_speculative();
502 }
503
504 // Same as above: because we don't go through meet/join, remove the
505 // speculative type if we know we won't use it.
506 return result->cleanup_speculative();
507
508 // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES.
509 // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR!
510
511 //
512 // Remove this code after overnight run indicates no performance
513 // loss from not performing JOIN at CheckCastPPNode
514 //
515 // const TypeInstPtr *in_oop = in->isa_instptr();
516 // const TypeInstPtr *my_oop = _type->isa_instptr();
517 // // If either input is an 'interface', return destination type
518 // assert (in_oop == NULL || in_oop->klass() != NULL, "");
519 // assert (my_oop == NULL || my_oop->klass() != NULL, "");
520 // if( (in_oop && in_oop->klass()->is_interface())
521 // ||(my_oop && my_oop->klass()->is_interface()) ) {
522 // TypePtr::PTR in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR;
523 // // Preserve cast away nullness for interfaces
524 // if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) {
525 // return my_oop->cast_to_ptr_type(TypePtr::NotNull);
526 // }
527 // return _type;
528 // }
529 //
530 // // Neither the input nor the destination type is an interface,
531 //
532 // // history: JOIN used to cause weird corner case bugs
533 // // return (in == TypeOopPtr::NULL_PTR) ? in : _type;
534 // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops.
535 // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr
536 // const Type *join = in->join(_type);
537 // // Check if join preserved NotNull'ness for pointers
538 // if( join->isa_ptr() && _type->isa_ptr() ) {
539 // TypePtr::PTR join_ptr = join->is_ptr()->_ptr;
540 // TypePtr::PTR type_ptr = _type->is_ptr()->_ptr;
541 // // If there isn't any NotNull'ness to preserve
542 // // OR if join preserved NotNull'ness then return it
543 // if( type_ptr == TypePtr::BotPTR || type_ptr == TypePtr::Null ||
544 // join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) {
545 // return join;
546 // }
547 // // ELSE return same old type as before
548 // return _type;
549 // }
550 // // Not joining two pointers
551 // return join;
552 }
553
554 //------------------------------Ideal------------------------------------------
555 // Return a node which is more "ideal" than the current node. Strip out
556 // control copies
557 Node *CheckCastPPNode::Ideal(PhaseGVN *phase, bool can_reshape){
558 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
559 }
560
561
562 Node* DecodeNNode::Identity(PhaseTransform* phase) {
563 const Type *t = phase->type( in(1) );
564 if( t == Type::TOP ) return in(1);
565
566 if (in(1)->is_EncodeP()) {
567 // (DecodeN (EncodeP p)) -> p
568 return in(1)->in(1);
569 }
570 return this;
571 }
572
573 const Type *DecodeNNode::Value( PhaseTransform *phase ) const {
574 const Type *t = phase->type( in(1) );
575 if (t == Type::TOP) return Type::TOP;
576 if (t == TypeNarrowOop::NULL_PTR) return TypePtr::NULL_PTR;
577
578 assert(t->isa_narrowoop(), "only narrowoop here");
579 return t->make_ptr();
580 }
581
582 Node* EncodePNode::Identity(PhaseTransform* phase) {
583 const Type *t = phase->type( in(1) );
584 if( t == Type::TOP ) return in(1);
585
586 if (in(1)->is_DecodeN()) {
587 // (EncodeP (DecodeN p)) -> p
588 return in(1)->in(1);
589 }
590 return this;
591 }
592
593 const Type *EncodePNode::Value( PhaseTransform *phase ) const {
594 const Type *t = phase->type( in(1) );
595 if (t == Type::TOP) return Type::TOP;
596 if (t == TypePtr::NULL_PTR) return TypeNarrowOop::NULL_PTR;
597
598 assert(t->isa_oop_ptr(), "only oopptr here");
599 return t->make_narrowoop();
600 }
601
602
603 Node *EncodeNarrowPtrNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {
604 return MemNode::Ideal_common_DU_postCCP(ccp, this, in(1));
605 }
606
607 Node* DecodeNKlassNode::Identity(PhaseTransform* phase) {
608 const Type *t = phase->type( in(1) );
609 if( t == Type::TOP ) return in(1);
610
611 if (in(1)->is_EncodePKlass()) {
612 // (DecodeNKlass (EncodePKlass p)) -> p
613 return in(1)->in(1);
614 }
615 return this;
616 }
617
618 const Type *DecodeNKlassNode::Value( PhaseTransform *phase ) const {
619 const Type *t = phase->type( in(1) );
620 if (t == Type::TOP) return Type::TOP;
621 assert(t != TypeNarrowKlass::NULL_PTR, "null klass?");
622
623 assert(t->isa_narrowklass(), "only narrow klass ptr here");
624 return t->make_ptr();
625 }
626
627 Node* EncodePKlassNode::Identity(PhaseTransform* phase) {
628 const Type *t = phase->type( in(1) );
629 if( t == Type::TOP ) return in(1);
630
631 if (in(1)->is_DecodeNKlass()) {
632 // (EncodePKlass (DecodeNKlass p)) -> p
633 return in(1)->in(1);
634 }
635 return this;
636 }
637
638 const Type *EncodePKlassNode::Value( PhaseTransform *phase ) const {
639 const Type *t = phase->type( in(1) );
640 if (t == Type::TOP) return Type::TOP;
641 assert (t != TypePtr::NULL_PTR, "null klass?");
642
643 assert(UseCompressedClassPointers && t->isa_klassptr(), "only klass ptr here");
644 return t->make_narrowklass();
645 }
646
647
648 //=============================================================================
649 //------------------------------Identity---------------------------------------
650 Node *Conv2BNode::Identity( PhaseTransform *phase ) {
651 const Type *t = phase->type( in(1) );
652 if( t == Type::TOP ) return in(1);
653 if( t == TypeInt::ZERO ) return in(1);
654 if( t == TypeInt::ONE ) return in(1);
655 if( t == TypeInt::BOOL ) return in(1);
656 return this;
657 }
658
659 //------------------------------Value------------------------------------------
660 const Type *Conv2BNode::Value( PhaseTransform *phase ) const {
661 const Type *t = phase->type( in(1) );
662 if( t == Type::TOP ) return Type::TOP;
663 if( t == TypeInt::ZERO ) return TypeInt::ZERO;
664 if( t == TypePtr::NULL_PTR ) return TypeInt::ZERO;
665 const TypePtr *tp = t->isa_ptr();
666 if( tp != NULL ) {
667 if( tp->ptr() == TypePtr::AnyNull ) return Type::TOP;
668 if( tp->ptr() == TypePtr::Constant) return TypeInt::ONE;
669 if (tp->ptr() == TypePtr::NotNull) return TypeInt::ONE;
670 return TypeInt::BOOL;
671 }
672 if (t->base() != Type::Int) return TypeInt::BOOL;
673 const TypeInt *ti = t->is_int();
674 if( ti->_hi < 0 || ti->_lo > 0 ) return TypeInt::ONE;
675 return TypeInt::BOOL;
676 }
677
678
679 // The conversions operations are all Alpha sorted. Please keep it that way!
680 //=============================================================================
681 //------------------------------Value------------------------------------------
682 const Type *ConvD2FNode::Value( PhaseTransform *phase ) const {
683 const Type *t = phase->type( in(1) );
684 if( t == Type::TOP ) return Type::TOP;
685 if( t == Type::DOUBLE ) return Type::FLOAT;
686 const TypeD *td = t->is_double_constant();
687 return TypeF::make( (float)td->getd() );
688 }
689
690 //------------------------------Identity---------------------------------------
691 // Float's can be converted to doubles with no loss of bits. Hence
692 // converting a float to a double and back to a float is a NOP.
693 Node *ConvD2FNode::Identity(PhaseTransform *phase) {
694 return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this;
695 }
696
697 //=============================================================================
698 //------------------------------Value------------------------------------------
699 const Type *ConvD2INode::Value( PhaseTransform *phase ) const {
700 const Type *t = phase->type( in(1) );
701 if( t == Type::TOP ) return Type::TOP;
702 if( t == Type::DOUBLE ) return TypeInt::INT;
703 const TypeD *td = t->is_double_constant();
704 return TypeInt::make( SharedRuntime::d2i( td->getd() ) );
705 }
706
707 //------------------------------Ideal------------------------------------------
708 // If converting to an int type, skip any rounding nodes
709 Node *ConvD2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
710 if( in(1)->Opcode() == Op_RoundDouble )
711 set_req(1,in(1)->in(1));
712 return NULL;
713 }
714
715 //------------------------------Identity---------------------------------------
716 // Int's can be converted to doubles with no loss of bits. Hence
717 // converting an integer to a double and back to an integer is a NOP.
718 Node *ConvD2INode::Identity(PhaseTransform *phase) {
719 return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this;
720 }
721
722 //=============================================================================
723 //------------------------------Value------------------------------------------
724 const Type *ConvD2LNode::Value( PhaseTransform *phase ) const {
725 const Type *t = phase->type( in(1) );
726 if( t == Type::TOP ) return Type::TOP;
727 if( t == Type::DOUBLE ) return TypeLong::LONG;
728 const TypeD *td = t->is_double_constant();
729 return TypeLong::make( SharedRuntime::d2l( td->getd() ) );
730 }
731
732 //------------------------------Identity---------------------------------------
733 Node *ConvD2LNode::Identity(PhaseTransform *phase) {
734 // Remove ConvD2L->ConvL2D->ConvD2L sequences.
735 if( in(1) ->Opcode() == Op_ConvL2D &&
736 in(1)->in(1)->Opcode() == Op_ConvD2L )
737 return in(1)->in(1);
738 return this;
739 }
740
741 //------------------------------Ideal------------------------------------------
742 // If converting to an int type, skip any rounding nodes
743 Node *ConvD2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
744 if( in(1)->Opcode() == Op_RoundDouble )
745 set_req(1,in(1)->in(1));
746 return NULL;
747 }
748
749 //=============================================================================
750 //------------------------------Value------------------------------------------
751 const Type *ConvF2DNode::Value( PhaseTransform *phase ) const {
752 const Type *t = phase->type( in(1) );
753 if( t == Type::TOP ) return Type::TOP;
754 if( t == Type::FLOAT ) return Type::DOUBLE;
755 const TypeF *tf = t->is_float_constant();
756 return TypeD::make( (double)tf->getf() );
757 }
758
759 //=============================================================================
760 //------------------------------Value------------------------------------------
761 const Type *ConvF2INode::Value( PhaseTransform *phase ) const {
762 const Type *t = phase->type( in(1) );
763 if( t == Type::TOP ) return Type::TOP;
764 if( t == Type::FLOAT ) return TypeInt::INT;
765 const TypeF *tf = t->is_float_constant();
766 return TypeInt::make( SharedRuntime::f2i( tf->getf() ) );
767 }
768
769 //------------------------------Identity---------------------------------------
770 Node *ConvF2INode::Identity(PhaseTransform *phase) {
771 // Remove ConvF2I->ConvI2F->ConvF2I sequences.
772 if( in(1) ->Opcode() == Op_ConvI2F &&
773 in(1)->in(1)->Opcode() == Op_ConvF2I )
774 return in(1)->in(1);
775 return this;
776 }
777
778 //------------------------------Ideal------------------------------------------
779 // If converting to an int type, skip any rounding nodes
780 Node *ConvF2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
781 if( in(1)->Opcode() == Op_RoundFloat )
782 set_req(1,in(1)->in(1));
783 return NULL;
784 }
785
786 //=============================================================================
787 //------------------------------Value------------------------------------------
788 const Type *ConvF2LNode::Value( PhaseTransform *phase ) const {
789 const Type *t = phase->type( in(1) );
790 if( t == Type::TOP ) return Type::TOP;
791 if( t == Type::FLOAT ) return TypeLong::LONG;
792 const TypeF *tf = t->is_float_constant();
793 return TypeLong::make( SharedRuntime::f2l( tf->getf() ) );
794 }
795
796 //------------------------------Identity---------------------------------------
797 Node *ConvF2LNode::Identity(PhaseTransform *phase) {
798 // Remove ConvF2L->ConvL2F->ConvF2L sequences.
799 if( in(1) ->Opcode() == Op_ConvL2F &&
800 in(1)->in(1)->Opcode() == Op_ConvF2L )
801 return in(1)->in(1);
802 return this;
803 }
804
805 //------------------------------Ideal------------------------------------------
806 // If converting to an int type, skip any rounding nodes
807 Node *ConvF2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
808 if( in(1)->Opcode() == Op_RoundFloat )
809 set_req(1,in(1)->in(1));
810 return NULL;
811 }
812
813 //=============================================================================
814 //------------------------------Value------------------------------------------
815 const Type *ConvI2DNode::Value( PhaseTransform *phase ) const {
816 const Type *t = phase->type( in(1) );
817 if( t == Type::TOP ) return Type::TOP;
818 const TypeInt *ti = t->is_int();
819 if( ti->is_con() ) return TypeD::make( (double)ti->get_con() );
820 return bottom_type();
821 }
822
823 //=============================================================================
824 //------------------------------Value------------------------------------------
825 const Type *ConvI2FNode::Value( PhaseTransform *phase ) const {
826 const Type *t = phase->type( in(1) );
827 if( t == Type::TOP ) return Type::TOP;
828 const TypeInt *ti = t->is_int();
829 if( ti->is_con() ) return TypeF::make( (float)ti->get_con() );
830 return bottom_type();
831 }
832
833 //------------------------------Identity---------------------------------------
834 Node *ConvI2FNode::Identity(PhaseTransform *phase) {
835 // Remove ConvI2F->ConvF2I->ConvI2F sequences.
836 if( in(1) ->Opcode() == Op_ConvF2I &&
837 in(1)->in(1)->Opcode() == Op_ConvI2F )
838 return in(1)->in(1);
839 return this;
840 }
841
842 //=============================================================================
843 //------------------------------Value------------------------------------------
844 const Type *ConvI2LNode::Value( PhaseTransform *phase ) const {
845 const Type *t = phase->type( in(1) );
846 if( t == Type::TOP ) return Type::TOP;
847 const TypeInt *ti = t->is_int();
848 const Type* tl = TypeLong::make(ti->_lo, ti->_hi, ti->_widen);
849 // Join my declared type against my incoming type.
850 tl = tl->filter(_type);
851 return tl;
852 }
853
854 #ifdef _LP64
855 static inline bool long_ranges_overlap(jlong lo1, jlong hi1,
856 jlong lo2, jlong hi2) {
857 // Two ranges overlap iff one range's low point falls in the other range.
858 return (lo2 <= lo1 && lo1 <= hi2) || (lo1 <= lo2 && lo2 <= hi1);
859 }
860 #endif
861
862 //------------------------------Ideal------------------------------------------
863 Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
864 const TypeLong* this_type = this->type()->is_long();
865 Node* this_changed = NULL;
866
867 // If _major_progress, then more loop optimizations follow. Do NOT
868 // remove this node's type assertion until no more loop ops can happen.
869 // The progress bit is set in the major loop optimizations THEN comes the
870 // call to IterGVN and any chance of hitting this code. Cf. Opaque1Node.
871 if (can_reshape && !phase->C->major_progress()) {
872 const TypeInt* in_type = phase->type(in(1))->isa_int();
873 if (in_type != NULL && this_type != NULL &&
874 (in_type->_lo != this_type->_lo ||
875 in_type->_hi != this_type->_hi)) {
876 // Although this WORSENS the type, it increases GVN opportunities,
877 // because I2L nodes with the same input will common up, regardless
878 // of slightly differing type assertions. Such slight differences
879 // arise routinely as a result of loop unrolling, so this is a
880 // post-unrolling graph cleanup. Choose a type which depends only
881 // on my input. (Exception: Keep a range assertion of >=0 or <0.)
882 jlong lo1 = this_type->_lo;
883 jlong hi1 = this_type->_hi;
884 int w1 = this_type->_widen;
885 if (lo1 != (jint)lo1 ||
886 hi1 != (jint)hi1 ||
887 lo1 > hi1) {
888 // Overflow leads to wraparound, wraparound leads to range saturation.
889 lo1 = min_jint; hi1 = max_jint;
890 } else if (lo1 >= 0) {
891 // Keep a range assertion of >=0.
892 lo1 = 0; hi1 = max_jint;
893 } else if (hi1 < 0) {
894 // Keep a range assertion of <0.
895 lo1 = min_jint; hi1 = -1;
896 } else {
897 lo1 = min_jint; hi1 = max_jint;
898 }
899 const TypeLong* wtype = TypeLong::make(MAX2((jlong)in_type->_lo, lo1),
900 MIN2((jlong)in_type->_hi, hi1),
901 MAX2((int)in_type->_widen, w1));
902 if (wtype != type()) {
903 set_type(wtype);
904 // Note: this_type still has old type value, for the logic below.
905 this_changed = this;
906 }
907 }
908 }
909
910 #ifdef _LP64
911 // Convert ConvI2L(AddI(x, y)) to AddL(ConvI2L(x), ConvI2L(y)) ,
912 // but only if x and y have subranges that cannot cause 32-bit overflow,
913 // under the assumption that x+y is in my own subrange this->type().
914
915 // This assumption is based on a constraint (i.e., type assertion)
916 // established in Parse::array_addressing or perhaps elsewhere.
917 // This constraint has been adjoined to the "natural" type of
918 // the incoming argument in(0). We know (because of runtime
919 // checks) - that the result value I2L(x+y) is in the joined range.
920 // Hence we can restrict the incoming terms (x, y) to values such
921 // that their sum also lands in that range.
922
923 // This optimization is useful only on 64-bit systems, where we hope
924 // the addition will end up subsumed in an addressing mode.
925 // It is necessary to do this when optimizing an unrolled array
926 // copy loop such as x[i++] = y[i++].
927
928 // On 32-bit systems, it's better to perform as much 32-bit math as
929 // possible before the I2L conversion, because 32-bit math is cheaper.
930 // There's no common reason to "leak" a constant offset through the I2L.
931 // Addressing arithmetic will not absorb it as part of a 64-bit AddL.
932
933 Node* z = in(1);
934 int op = z->Opcode();
935 if (op == Op_AddI || op == Op_SubI) {
936 Node* x = z->in(1);
937 Node* y = z->in(2);
938 assert (x != z && y != z, "dead loop in ConvI2LNode::Ideal");
939 if (phase->type(x) == Type::TOP) return this_changed;
940 if (phase->type(y) == Type::TOP) return this_changed;
941 const TypeInt* tx = phase->type(x)->is_int();
942 const TypeInt* ty = phase->type(y)->is_int();
943 const TypeLong* tz = this_type;
944 jlong xlo = tx->_lo;
945 jlong xhi = tx->_hi;
946 jlong ylo = ty->_lo;
947 jlong yhi = ty->_hi;
948 jlong zlo = tz->_lo;
949 jlong zhi = tz->_hi;
950 jlong vbit = CONST64(1) << BitsPerInt;
951 int widen = MAX2(tx->_widen, ty->_widen);
952 if (op == Op_SubI) {
953 jlong ylo0 = ylo;
954 ylo = -yhi;
955 yhi = -ylo0;
956 }
957 // See if x+y can cause positive overflow into z+2**32
958 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo+vbit, zhi+vbit)) {
959 return this_changed;
960 }
961 // See if x+y can cause negative overflow into z-2**32
962 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo-vbit, zhi-vbit)) {
963 return this_changed;
964 }
965 // Now it's always safe to assume x+y does not overflow.
966 // This is true even if some pairs x,y might cause overflow, as long
967 // as that overflow value cannot fall into [zlo,zhi].
968
969 // Confident that the arithmetic is "as if infinite precision",
970 // we can now use z's range to put constraints on those of x and y.
971 // The "natural" range of x [xlo,xhi] can perhaps be narrowed to a
972 // more "restricted" range by intersecting [xlo,xhi] with the
973 // range obtained by subtracting y's range from the asserted range
974 // of the I2L conversion. Here's the interval arithmetic algebra:
975 // x == z-y == [zlo,zhi]-[ylo,yhi] == [zlo,zhi]+[-yhi,-ylo]
976 // => x in [zlo-yhi, zhi-ylo]
977 // => x in [zlo-yhi, zhi-ylo] INTERSECT [xlo,xhi]
978 // => x in [xlo MAX zlo-yhi, xhi MIN zhi-ylo]
979 jlong rxlo = MAX2(xlo, zlo - yhi);
980 jlong rxhi = MIN2(xhi, zhi - ylo);
981 // And similarly, x changing place with y:
982 jlong rylo = MAX2(ylo, zlo - xhi);
983 jlong ryhi = MIN2(yhi, zhi - xlo);
984 if (rxlo > rxhi || rylo > ryhi) {
985 return this_changed; // x or y is dying; don't mess w/ it
986 }
987 if (op == Op_SubI) {
988 jlong rylo0 = rylo;
989 rylo = -ryhi;
990 ryhi = -rylo0;
991 }
992
993 Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
994 Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
995 switch (op) {
996 case Op_AddI: return new (phase->C) AddLNode(cx, cy);
997 case Op_SubI: return new (phase->C) SubLNode(cx, cy);
998 default: ShouldNotReachHere();
999 }
1000 }
1001 #endif //_LP64
1002
1003 return this_changed;
1004 }
1005
1006 //=============================================================================
1007 //------------------------------Value------------------------------------------
1008 const Type *ConvL2DNode::Value( PhaseTransform *phase ) const {
1009 const Type *t = phase->type( in(1) );
1010 if( t == Type::TOP ) return Type::TOP;
1011 const TypeLong *tl = t->is_long();
1012 if( tl->is_con() ) return TypeD::make( (double)tl->get_con() );
1013 return bottom_type();
1014 }
1015
1016 //=============================================================================
1017 //------------------------------Value------------------------------------------
1018 const Type *ConvL2FNode::Value( PhaseTransform *phase ) const {
1019 const Type *t = phase->type( in(1) );
1020 if( t == Type::TOP ) return Type::TOP;
1021 const TypeLong *tl = t->is_long();
1022 if( tl->is_con() ) return TypeF::make( (float)tl->get_con() );
1023 return bottom_type();
1024 }
1025
1026 //=============================================================================
1027 //----------------------------Identity-----------------------------------------
1028 Node *ConvL2INode::Identity( PhaseTransform *phase ) {
1029 // Convert L2I(I2L(x)) => x
1030 if (in(1)->Opcode() == Op_ConvI2L) return in(1)->in(1);
1031 return this;
1032 }
1033
1034 //------------------------------Value------------------------------------------
1035 const Type *ConvL2INode::Value( PhaseTransform *phase ) const {
1036 const Type *t = phase->type( in(1) );
1037 if( t == Type::TOP ) return Type::TOP;
1038 const TypeLong *tl = t->is_long();
1039 if (tl->is_con())
1040 // Easy case.
1041 return TypeInt::make((jint)tl->get_con());
1042 return bottom_type();
1043 }
1044
1045 //------------------------------Ideal------------------------------------------
1046 // Return a node which is more "ideal" than the current node.
1047 // Blow off prior masking to int
1048 Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
1049 Node *andl = in(1);
1050 uint andl_op = andl->Opcode();
1051 if( andl_op == Op_AndL ) {
1052 // Blow off prior masking to int
1053 if( phase->type(andl->in(2)) == TypeLong::make( 0xFFFFFFFF ) ) {
1054 set_req(1,andl->in(1));
1055 return this;
1056 }
1057 }
1058
1059 // Swap with a prior add: convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y))
1060 // This replaces an 'AddL' with an 'AddI'.
1061 if( andl_op == Op_AddL ) {
1062 // Don't do this for nodes which have more than one user since
1063 // we'll end up computing the long add anyway.
1064 if (andl->outcnt() > 1) return NULL;
1065
1066 Node* x = andl->in(1);
1067 Node* y = andl->in(2);
1068 assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
1069 if (phase->type(x) == Type::TOP) return NULL;
1070 if (phase->type(y) == Type::TOP) return NULL;
1071 Node *add1 = phase->transform(new (phase->C) ConvL2INode(x));
1072 Node *add2 = phase->transform(new (phase->C) ConvL2INode(y));
1073 return new (phase->C) AddINode(add1,add2);
1074 }
1075
1076 // Disable optimization: LoadL->ConvL2I ==> LoadI.
1077 // It causes problems (sizes of Load and Store nodes do not match)
1078 // in objects initialization code and Escape Analysis.
1079 return NULL;
1080 }
1081
1082 //=============================================================================
1083 //------------------------------Value------------------------------------------
1084 const Type *CastX2PNode::Value( PhaseTransform *phase ) const {
1085 const Type* t = phase->type(in(1));
1086 if (t == Type::TOP) return Type::TOP;
1087 if (t->base() == Type_X && t->singleton()) {
1088 uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con();
1089 if (bits == 0) return TypePtr::NULL_PTR;
1090 return TypeRawPtr::make((address) bits);
1091 }
1092 return CastX2PNode::bottom_type();
1093 }
1094
1095 //------------------------------Idealize---------------------------------------
1096 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) {
1097 if (t == Type::TOP) return false;
1098 const TypeX* tl = t->is_intptr_t();
1099 jint lo = min_jint;
1100 jint hi = max_jint;
1101 if (but_not_min_int) ++lo; // caller wants to negate the value w/o overflow
1102 return (tl->_lo >= lo) && (tl->_hi <= hi);
1103 }
1104
1105 static inline Node* addP_of_X2P(PhaseGVN *phase,
1106 Node* base,
1107 Node* dispX,
1108 bool negate = false) {
1109 if (negate) {
1110 dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX));
1111 }
1112 return new (phase->C) AddPNode(phase->C->top(),
1113 phase->transform(new (phase->C) CastX2PNode(base)),
1114 phase->transform(dispX));
1115 }
1116
1117 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {
1118 // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int
1119 int op = in(1)->Opcode();
1120 Node* x;
1121 Node* y;
1122 switch (op) {
1123 case Op_SubX:
1124 x = in(1)->in(1);
1125 // Avoid ideal transformations ping-pong between this and AddP for raw pointers.
1126 if (phase->find_intptr_t_con(x, -1) == 0)
1127 break;
1128 y = in(1)->in(2);
1129 if (fits_in_int(phase->type(y), true)) {
1130 return addP_of_X2P(phase, x, y, true);
1131 }
1132 break;
1133 case Op_AddX:
1134 x = in(1)->in(1);
1135 y = in(1)->in(2);
1136 if (fits_in_int(phase->type(y))) {
1137 return addP_of_X2P(phase, x, y);
1138 }
1139 if (fits_in_int(phase->type(x))) {
1140 return addP_of_X2P(phase, y, x);
1141 }
1142 break;
1143 }
1144 return NULL;
1145 }
1146
1147 //------------------------------Identity---------------------------------------
1148 Node *CastX2PNode::Identity( PhaseTransform *phase ) {
1149 if (in(1)->Opcode() == Op_CastP2X) return in(1)->in(1);
1150 return this;
1151 }
1152
1153 //=============================================================================
1154 //------------------------------Value------------------------------------------
1155 const Type *CastP2XNode::Value( PhaseTransform *phase ) const {
1156 const Type* t = phase->type(in(1));
1157 if (t == Type::TOP) return Type::TOP;
1158 if (t->base() == Type::RawPtr && t->singleton()) {
1159 uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con();
1160 return TypeX::make(bits);
1161 }
1162 return CastP2XNode::bottom_type();
1163 }
1164
1165 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) {
1166 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
1167 }
1168
1169 //------------------------------Identity---------------------------------------
1170 Node *CastP2XNode::Identity( PhaseTransform *phase ) {
1171 if (in(1)->Opcode() == Op_CastX2P) return in(1)->in(1);
1172 return this;
1173 }
1174
1175
1176 //=============================================================================
1177 //------------------------------Identity---------------------------------------
1178 // Remove redundant roundings
1179 Node *RoundFloatNode::Identity( PhaseTransform *phase ) {
1180 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
1181 // Do not round constants
1182 if (phase->type(in(1))->base() == Type::FloatCon) return in(1);
1183 int op = in(1)->Opcode();
1184 // Redundant rounding
1185 if( op == Op_RoundFloat ) return in(1);
1186 // Already rounded
1187 if( op == Op_Parm ) return in(1);
1188 if( op == Op_LoadF ) return in(1);
1189 return this;
1190 }
1191
1192 //------------------------------Value------------------------------------------
1193 const Type *RoundFloatNode::Value( PhaseTransform *phase ) const {
1194 return phase->type( in(1) );
1195 }
1196
1197 //=============================================================================
1198 //------------------------------Identity---------------------------------------
1199 // Remove redundant roundings. Incoming arguments are already rounded.
1200 Node *RoundDoubleNode::Identity( PhaseTransform *phase ) {
1201 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
1202 // Do not round constants
1203 if (phase->type(in(1))->base() == Type::DoubleCon) return in(1);
1204 int op = in(1)->Opcode();
1205 // Redundant rounding
1206 if( op == Op_RoundDouble ) return in(1);
1207 // Already rounded
1208 if( op == Op_Parm ) return in(1);
1209 if( op == Op_LoadD ) return in(1);
1210 if( op == Op_ConvF2D ) return in(1);
1211 if( op == Op_ConvI2D ) return in(1);
1212 return this;
1213 }
1214
1215 //------------------------------Value------------------------------------------
1216 const Type *RoundDoubleNode::Value( PhaseTransform *phase ) const {
1217 return phase->type( in(1) );
1218 }
1219
1220
1221 //=============================================================================
1222 // Do not allow value-numbering
1223 uint Opaque1Node::hash() const { return NO_HASH; }
1224 uint Opaque1Node::cmp( const Node &n ) const {
1225 return (&n == this); // Always fail except on self
1226 }
1227
1228 //------------------------------Identity---------------------------------------
1229 // If _major_progress, then more loop optimizations follow. Do NOT remove
1230 // the opaque Node until no more loop ops can happen. Note the timing of
1231 // _major_progress; it's set in the major loop optimizations THEN comes the
1232 // call to IterGVN and any chance of hitting this code. Hence there's no
1233 // phase-ordering problem with stripping Opaque1 in IGVN followed by some
1234 // more loop optimizations that require it.
1235 Node *Opaque1Node::Identity( PhaseTransform *phase ) {
1236 return phase->C->major_progress() ? this : in(1);
1237 }
1238
1239 //=============================================================================
1240 // A node to prevent unwanted optimizations. Allows constant folding. Stops
1241 // value-numbering, most Ideal calls or Identity functions. This Node is
1242 // specifically designed to prevent the pre-increment value of a loop trip
1243 // counter from being live out of the bottom of the loop (hence causing the
1244 // pre- and post-increment values both being live and thus requiring an extra
1245 // temp register and an extra move). If we "accidentally" optimize through
1246 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus
1247 // it's OK to be slightly sloppy on optimizations here.
1248
1249 // Do not allow value-numbering
1250 uint Opaque2Node::hash() const { return NO_HASH; }
1251 uint Opaque2Node::cmp( const Node &n ) const {
1252 return (&n == this); // Always fail except on self
1253 }
1254
1255
1256 //------------------------------Value------------------------------------------
1257 const Type *MoveL2DNode::Value( PhaseTransform *phase ) const {
1258 const Type *t = phase->type( in(1) );
1259 if( t == Type::TOP ) return Type::TOP;
1260 const TypeLong *tl = t->is_long();
1261 if( !tl->is_con() ) return bottom_type();
1262 JavaValue v;
1263 v.set_jlong(tl->get_con());
1264 return TypeD::make( v.get_jdouble() );
1265 }
1266
1267 //------------------------------Value------------------------------------------
1268 const Type *MoveI2FNode::Value( PhaseTransform *phase ) const {
1269 const Type *t = phase->type( in(1) );
1270 if( t == Type::TOP ) return Type::TOP;
1271 const TypeInt *ti = t->is_int();
1272 if( !ti->is_con() ) return bottom_type();
1273 JavaValue v;
1274 v.set_jint(ti->get_con());
1275 return TypeF::make( v.get_jfloat() );
1276 }
1277
1278 //------------------------------Value------------------------------------------
1279 const Type *MoveF2INode::Value( PhaseTransform *phase ) const {
1280 const Type *t = phase->type( in(1) );
1281 if( t == Type::TOP ) return Type::TOP;
1282 if( t == Type::FLOAT ) return TypeInt::INT;
1283 const TypeF *tf = t->is_float_constant();
1284 JavaValue v;
1285 v.set_jfloat(tf->getf());
1286 return TypeInt::make( v.get_jint() );
1287 }
1288
1289 //------------------------------Value------------------------------------------
1290 const Type *MoveD2LNode::Value( PhaseTransform *phase ) const {
1291 const Type *t = phase->type( in(1) );
1292 if( t == Type::TOP ) return Type::TOP;
1293 if( t == Type::DOUBLE ) return TypeLong::LONG;
1294 const TypeD *td = t->is_double_constant();
1295 JavaValue v;
1296 v.set_jdouble(td->getd());
1297 return TypeLong::make( v.get_jlong() );
1298 }
1299
1300 //------------------------------Value------------------------------------------
1301 const Type* CountLeadingZerosINode::Value(PhaseTransform* phase) const {
1302 const Type* t = phase->type(in(1));
1303 if (t == Type::TOP) return Type::TOP;
1304 const TypeInt* ti = t->isa_int();
1305 if (ti && ti->is_con()) {
1306 jint i = ti->get_con();
1307 // HD, Figure 5-6
1308 if (i == 0)
1309 return TypeInt::make(BitsPerInt);
1310 int n = 1;
1311 unsigned int x = i;
1312 if (x >> 16 == 0) { n += 16; x <<= 16; }
1313 if (x >> 24 == 0) { n += 8; x <<= 8; }
1314 if (x >> 28 == 0) { n += 4; x <<= 4; }
1315 if (x >> 30 == 0) { n += 2; x <<= 2; }
1316 n -= x >> 31;
1317 return TypeInt::make(n);
1318 }
1319 return TypeInt::INT;
1320 }
1321
1322 //------------------------------Value------------------------------------------
1323 const Type* CountLeadingZerosLNode::Value(PhaseTransform* phase) const {
1324 const Type* t = phase->type(in(1));
1325 if (t == Type::TOP) return Type::TOP;
1326 const TypeLong* tl = t->isa_long();
1327 if (tl && tl->is_con()) {
1328 jlong l = tl->get_con();
1329 // HD, Figure 5-6
1330 if (l == 0)
1331 return TypeInt::make(BitsPerLong);
1332 int n = 1;
1333 unsigned int x = (((julong) l) >> 32);
1334 if (x == 0) { n += 32; x = (int) l; }
1335 if (x >> 16 == 0) { n += 16; x <<= 16; }
1336 if (x >> 24 == 0) { n += 8; x <<= 8; }
1337 if (x >> 28 == 0) { n += 4; x <<= 4; }
1338 if (x >> 30 == 0) { n += 2; x <<= 2; }
1339 n -= x >> 31;
1340 return TypeInt::make(n);
1341 }
1342 return TypeInt::INT;
1343 }
1344
1345 //------------------------------Value------------------------------------------
1346 const Type* CountTrailingZerosINode::Value(PhaseTransform* phase) const {
1347 const Type* t = phase->type(in(1));
1348 if (t == Type::TOP) return Type::TOP;
1349 const TypeInt* ti = t->isa_int();
1350 if (ti && ti->is_con()) {
1351 jint i = ti->get_con();
1352 // HD, Figure 5-14
1353 int y;
1354 if (i == 0)
1355 return TypeInt::make(BitsPerInt);
1356 int n = 31;
1357 y = i << 16; if (y != 0) { n = n - 16; i = y; }
1358 y = i << 8; if (y != 0) { n = n - 8; i = y; }
1359 y = i << 4; if (y != 0) { n = n - 4; i = y; }
1360 y = i << 2; if (y != 0) { n = n - 2; i = y; }
1361 y = i << 1; if (y != 0) { n = n - 1; }
1362 return TypeInt::make(n);
1363 }
1364 return TypeInt::INT;
1365 }
1366
1367 //------------------------------Value------------------------------------------
1368 const Type* CountTrailingZerosLNode::Value(PhaseTransform* phase) const {
1369 const Type* t = phase->type(in(1));
1370 if (t == Type::TOP) return Type::TOP;
1371 const TypeLong* tl = t->isa_long();
1372 if (tl && tl->is_con()) {
1373 jlong l = tl->get_con();
1374 // HD, Figure 5-14
1375 int x, y;
1376 if (l == 0)
1377 return TypeInt::make(BitsPerLong);
1378 int n = 63;
1379 y = (int) l; if (y != 0) { n = n - 32; x = y; } else x = (((julong) l) >> 32);
1380 y = x << 16; if (y != 0) { n = n - 16; x = y; }
1381 y = x << 8; if (y != 0) { n = n - 8; x = y; }
1382 y = x << 4; if (y != 0) { n = n - 4; x = y; }
1383 y = x << 2; if (y != 0) { n = n - 2; x = y; }
1384 y = x << 1; if (y != 0) { n = n - 1; }
1385 return TypeInt::make(n);
1386 }
1387 return TypeInt::INT;
1388 }