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