1 /*
2 * Copyright (c) 1997, 2012, 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(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(_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(_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(_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 // Determine whether "n" is a node which can cause an alias of one of its inputs. Node types
469 // which can create aliases are: CheckCastPP, Phi, and any store (if there is also a load from
470 // the location.)
471 // Note: this checks for aliases created in this compilation, not ones which may
472 // be potentially created at call sites.
473 static bool can_cause_alias(Node *n, PhaseTransform *phase) {
474 bool possible_alias = false;
475
476 if (n->is_Store()) {
477 possible_alias = !n->as_Store()->value_never_loaded(phase);
478 } else {
479 int opc = n->Opcode();
480 possible_alias = n->is_Phi() ||
481 opc == Op_CheckCastPP ||
482 opc == Op_StorePConditional ||
483 opc == Op_CompareAndSwapP ||
484 opc == Op_CompareAndSwapN ||
485 opc == Op_GetAndSetP ||
486 opc == Op_GetAndSetN;
487 }
488 return possible_alias;
489 }
490
491 //------------------------------Value------------------------------------------
492 // Take 'join' of input and cast-up type, unless working with an Interface
493 const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {
494 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
495
496 const Type *inn = phase->type(in(1));
497 if( inn == Type::TOP ) return Type::TOP; // No information yet
498
499 const TypePtr *in_type = inn->isa_ptr();
500 const TypePtr *my_type = _type->isa_ptr();
501 const Type *result = _type;
502 if( in_type != NULL && my_type != NULL ) {
503 TypePtr::PTR in_ptr = in_type->ptr();
504 if( in_ptr == TypePtr::Null ) {
505 result = in_type;
506 } else if( in_ptr == TypePtr::Constant ) {
507 // Casting a constant oop to an interface?
508 // (i.e., a String to a Comparable?)
509 // Then return the interface.
510 const TypeOopPtr *jptr = my_type->isa_oopptr();
511 assert( jptr, "" );
512 result = (jptr->klass()->is_interface() || !in_type->higher_equal(_type))
513 ? my_type->cast_to_ptr_type( TypePtr::NotNull )
514 : in_type;
515 } else {
516 result = my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) );
517 }
518 }
519 return result;
520
521 // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES.
522 // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR!
523
524 //
525 // Remove this code after overnight run indicates no performance
526 // loss from not performing JOIN at CheckCastPPNode
527 //
528 // const TypeInstPtr *in_oop = in->isa_instptr();
529 // const TypeInstPtr *my_oop = _type->isa_instptr();
530 // // If either input is an 'interface', return destination type
531 // assert (in_oop == NULL || in_oop->klass() != NULL, "");
532 // assert (my_oop == NULL || my_oop->klass() != NULL, "");
533 // if( (in_oop && in_oop->klass()->is_interface())
534 // ||(my_oop && my_oop->klass()->is_interface()) ) {
535 // TypePtr::PTR in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR;
536 // // Preserve cast away nullness for interfaces
537 // if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) {
538 // return my_oop->cast_to_ptr_type(TypePtr::NotNull);
539 // }
540 // return _type;
541 // }
542 //
543 // // Neither the input nor the destination type is an interface,
544 //
545 // // history: JOIN used to cause weird corner case bugs
546 // // return (in == TypeOopPtr::NULL_PTR) ? in : _type;
547 // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops.
548 // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr
549 // const Type *join = in->join(_type);
550 // // Check if join preserved NotNull'ness for pointers
551 // if( join->isa_ptr() && _type->isa_ptr() ) {
552 // TypePtr::PTR join_ptr = join->is_ptr()->_ptr;
553 // TypePtr::PTR type_ptr = _type->is_ptr()->_ptr;
554 // // If there isn't any NotNull'ness to preserve
555 // // OR if join preserved NotNull'ness then return it
556 // if( type_ptr == TypePtr::BotPTR || type_ptr == TypePtr::Null ||
557 // join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) {
558 // return join;
559 // }
560 // // ELSE return same old type as before
561 // return _type;
562 // }
563 // // Not joining two pointers
564 // return join;
565 }
566
567 //------------------------------Ideal------------------------------------------
568 // Return a node which is more "ideal" than the current node. Strip out
569 // control copies
570 Node *CheckCastPPNode::Ideal(PhaseGVN *phase, bool can_reshape){
571 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
572 }
573
574
575 Node* DecodeNNode::Identity(PhaseTransform* phase) {
576 const Type *t = phase->type( in(1) );
577 if( t == Type::TOP ) return in(1);
578
579 if (in(1)->is_EncodeP()) {
580 // (DecodeN (EncodeP p)) -> p
581 return in(1)->in(1);
582 }
583 return this;
584 }
585
586 const Type *DecodeNNode::Value( PhaseTransform *phase ) const {
587 const Type *t = phase->type( in(1) );
588 if (t == Type::TOP) return Type::TOP;
589 if (t == TypeNarrowOop::NULL_PTR) return TypePtr::NULL_PTR;
590
591 assert(t->isa_narrowoop(), "only narrowoop here");
592 return t->make_ptr();
593 }
594
595 Node* EncodePNode::Identity(PhaseTransform* phase) {
596 const Type *t = phase->type( in(1) );
597 if( t == Type::TOP ) return in(1);
598
599 if (in(1)->is_DecodeN()) {
600 // (EncodeP (DecodeN p)) -> p
601 return in(1)->in(1);
602 }
603 return this;
604 }
605
606 const Type *EncodePNode::Value( PhaseTransform *phase ) const {
607 const Type *t = phase->type( in(1) );
608 if (t == Type::TOP) return Type::TOP;
609 if (t == TypePtr::NULL_PTR) return TypeNarrowOop::NULL_PTR;
610
611 assert(t->isa_oop_ptr(), "only oopptr here");
612 return t->make_narrowoop();
613 }
614
615
616 Node *EncodeNarrowPtrNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {
617 return MemNode::Ideal_common_DU_postCCP(ccp, this, in(1));
618 }
619
620 Node* DecodeNKlassNode::Identity(PhaseTransform* phase) {
621 const Type *t = phase->type( in(1) );
622 if( t == Type::TOP ) return in(1);
623
624 if (in(1)->is_EncodePKlass()) {
625 // (DecodeNKlass (EncodePKlass p)) -> p
626 return in(1)->in(1);
627 }
628 return this;
629 }
630
631 const Type *DecodeNKlassNode::Value( PhaseTransform *phase ) const {
632 const Type *t = phase->type( in(1) );
633 if (t == Type::TOP) return Type::TOP;
634 assert(t != TypeNarrowKlass::NULL_PTR, "null klass?");
635
636 assert(t->isa_narrowklass(), "only narrow klass ptr here");
637 return t->make_ptr();
638 }
639
640 Node* EncodePKlassNode::Identity(PhaseTransform* phase) {
641 const Type *t = phase->type( in(1) );
642 if( t == Type::TOP ) return in(1);
643
644 if (in(1)->is_DecodeNKlass()) {
645 // (EncodePKlass (DecodeNKlass p)) -> p
646 return in(1)->in(1);
647 }
648 return this;
649 }
650
651 const Type *EncodePKlassNode::Value( PhaseTransform *phase ) const {
652 const Type *t = phase->type( in(1) );
653 if (t == Type::TOP) return Type::TOP;
654 assert (t != TypePtr::NULL_PTR, "null klass?");
655
656 assert(UseCompressedKlassPointers && t->isa_klassptr(), "only klass ptr here");
657 return t->make_narrowklass();
658 }
659
660
661 //=============================================================================
662 //------------------------------Identity---------------------------------------
663 Node *Conv2BNode::Identity( PhaseTransform *phase ) {
664 const Type *t = phase->type( in(1) );
665 if( t == Type::TOP ) return in(1);
666 if( t == TypeInt::ZERO ) return in(1);
667 if( t == TypeInt::ONE ) return in(1);
668 if( t == TypeInt::BOOL ) return in(1);
669 return this;
670 }
671
672 //------------------------------Value------------------------------------------
673 const Type *Conv2BNode::Value( PhaseTransform *phase ) const {
674 const Type *t = phase->type( in(1) );
675 if( t == Type::TOP ) return Type::TOP;
676 if( t == TypeInt::ZERO ) return TypeInt::ZERO;
677 if( t == TypePtr::NULL_PTR ) return TypeInt::ZERO;
678 const TypePtr *tp = t->isa_ptr();
679 if( tp != NULL ) {
680 if( tp->ptr() == TypePtr::AnyNull ) return Type::TOP;
681 if( tp->ptr() == TypePtr::Constant) return TypeInt::ONE;
682 if (tp->ptr() == TypePtr::NotNull) return TypeInt::ONE;
683 return TypeInt::BOOL;
684 }
685 if (t->base() != Type::Int) return TypeInt::BOOL;
686 const TypeInt *ti = t->is_int();
687 if( ti->_hi < 0 || ti->_lo > 0 ) return TypeInt::ONE;
688 return TypeInt::BOOL;
689 }
690
691
692 // The conversions operations are all Alpha sorted. Please keep it that way!
693 //=============================================================================
694 //------------------------------Value------------------------------------------
695 const Type *ConvD2FNode::Value( PhaseTransform *phase ) const {
696 const Type *t = phase->type( in(1) );
697 if( t == Type::TOP ) return Type::TOP;
698 if( t == Type::DOUBLE ) return Type::FLOAT;
699 const TypeD *td = t->is_double_constant();
700 return TypeF::make( (float)td->getd() );
701 }
702
703 //------------------------------Identity---------------------------------------
704 // Float's can be converted to doubles with no loss of bits. Hence
705 // converting a float to a double and back to a float is a NOP.
706 Node *ConvD2FNode::Identity(PhaseTransform *phase) {
707 return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this;
708 }
709
710 //=============================================================================
711 //------------------------------Value------------------------------------------
712 const Type *ConvD2INode::Value( PhaseTransform *phase ) const {
713 const Type *t = phase->type( in(1) );
714 if( t == Type::TOP ) return Type::TOP;
715 if( t == Type::DOUBLE ) return TypeInt::INT;
716 const TypeD *td = t->is_double_constant();
717 return TypeInt::make( SharedRuntime::d2i( td->getd() ) );
718 }
719
720 //------------------------------Ideal------------------------------------------
721 // If converting to an int type, skip any rounding nodes
722 Node *ConvD2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
723 if( in(1)->Opcode() == Op_RoundDouble )
724 set_req(1,in(1)->in(1));
725 return NULL;
726 }
727
728 //------------------------------Identity---------------------------------------
729 // Int's can be converted to doubles with no loss of bits. Hence
730 // converting an integer to a double and back to an integer is a NOP.
731 Node *ConvD2INode::Identity(PhaseTransform *phase) {
732 return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this;
733 }
734
735 //=============================================================================
736 //------------------------------Value------------------------------------------
737 const Type *ConvD2LNode::Value( PhaseTransform *phase ) const {
738 const Type *t = phase->type( in(1) );
739 if( t == Type::TOP ) return Type::TOP;
740 if( t == Type::DOUBLE ) return TypeLong::LONG;
741 const TypeD *td = t->is_double_constant();
742 return TypeLong::make( SharedRuntime::d2l( td->getd() ) );
743 }
744
745 //------------------------------Identity---------------------------------------
746 Node *ConvD2LNode::Identity(PhaseTransform *phase) {
747 // Remove ConvD2L->ConvL2D->ConvD2L sequences.
748 if( in(1) ->Opcode() == Op_ConvL2D &&
749 in(1)->in(1)->Opcode() == Op_ConvD2L )
750 return in(1)->in(1);
751 return this;
752 }
753
754 //------------------------------Ideal------------------------------------------
755 // If converting to an int type, skip any rounding nodes
756 Node *ConvD2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
757 if( in(1)->Opcode() == Op_RoundDouble )
758 set_req(1,in(1)->in(1));
759 return NULL;
760 }
761
762 //=============================================================================
763 //------------------------------Value------------------------------------------
764 const Type *ConvF2DNode::Value( PhaseTransform *phase ) const {
765 const Type *t = phase->type( in(1) );
766 if( t == Type::TOP ) return Type::TOP;
767 if( t == Type::FLOAT ) return Type::DOUBLE;
768 const TypeF *tf = t->is_float_constant();
769 return TypeD::make( (double)tf->getf() );
770 }
771
772 //=============================================================================
773 //------------------------------Value------------------------------------------
774 const Type *ConvF2INode::Value( PhaseTransform *phase ) const {
775 const Type *t = phase->type( in(1) );
776 if( t == Type::TOP ) return Type::TOP;
777 if( t == Type::FLOAT ) return TypeInt::INT;
778 const TypeF *tf = t->is_float_constant();
779 return TypeInt::make( SharedRuntime::f2i( tf->getf() ) );
780 }
781
782 //------------------------------Identity---------------------------------------
783 Node *ConvF2INode::Identity(PhaseTransform *phase) {
784 // Remove ConvF2I->ConvI2F->ConvF2I sequences.
785 if( in(1) ->Opcode() == Op_ConvI2F &&
786 in(1)->in(1)->Opcode() == Op_ConvF2I )
787 return in(1)->in(1);
788 return this;
789 }
790
791 //------------------------------Ideal------------------------------------------
792 // If converting to an int type, skip any rounding nodes
793 Node *ConvF2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
794 if( in(1)->Opcode() == Op_RoundFloat )
795 set_req(1,in(1)->in(1));
796 return NULL;
797 }
798
799 //=============================================================================
800 //------------------------------Value------------------------------------------
801 const Type *ConvF2LNode::Value( PhaseTransform *phase ) const {
802 const Type *t = phase->type( in(1) );
803 if( t == Type::TOP ) return Type::TOP;
804 if( t == Type::FLOAT ) return TypeLong::LONG;
805 const TypeF *tf = t->is_float_constant();
806 return TypeLong::make( SharedRuntime::f2l( tf->getf() ) );
807 }
808
809 //------------------------------Identity---------------------------------------
810 Node *ConvF2LNode::Identity(PhaseTransform *phase) {
811 // Remove ConvF2L->ConvL2F->ConvF2L sequences.
812 if( in(1) ->Opcode() == Op_ConvL2F &&
813 in(1)->in(1)->Opcode() == Op_ConvF2L )
814 return in(1)->in(1);
815 return this;
816 }
817
818 //------------------------------Ideal------------------------------------------
819 // If converting to an int type, skip any rounding nodes
820 Node *ConvF2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
821 if( in(1)->Opcode() == Op_RoundFloat )
822 set_req(1,in(1)->in(1));
823 return NULL;
824 }
825
826 //=============================================================================
827 //------------------------------Value------------------------------------------
828 const Type *ConvI2DNode::Value( PhaseTransform *phase ) const {
829 const Type *t = phase->type( in(1) );
830 if( t == Type::TOP ) return Type::TOP;
831 const TypeInt *ti = t->is_int();
832 if( ti->is_con() ) return TypeD::make( (double)ti->get_con() );
833 return bottom_type();
834 }
835
836 //=============================================================================
837 //------------------------------Value------------------------------------------
838 const Type *ConvI2FNode::Value( PhaseTransform *phase ) const {
839 const Type *t = phase->type( in(1) );
840 if( t == Type::TOP ) return Type::TOP;
841 const TypeInt *ti = t->is_int();
842 if( ti->is_con() ) return TypeF::make( (float)ti->get_con() );
843 return bottom_type();
844 }
845
846 //------------------------------Identity---------------------------------------
847 Node *ConvI2FNode::Identity(PhaseTransform *phase) {
848 // Remove ConvI2F->ConvF2I->ConvI2F sequences.
849 if( in(1) ->Opcode() == Op_ConvF2I &&
850 in(1)->in(1)->Opcode() == Op_ConvI2F )
851 return in(1)->in(1);
852 return this;
853 }
854
855 //=============================================================================
856 //------------------------------Value------------------------------------------
857 const Type *ConvI2LNode::Value( PhaseTransform *phase ) const {
858 const Type *t = phase->type( in(1) );
859 if( t == Type::TOP ) return Type::TOP;
860 const TypeInt *ti = t->is_int();
861 const Type* tl = TypeLong::make(ti->_lo, ti->_hi, ti->_widen);
862 // Join my declared type against my incoming type.
863 tl = tl->filter(_type);
864 return tl;
865 }
866
867 #ifdef _LP64
868 static inline bool long_ranges_overlap(jlong lo1, jlong hi1,
869 jlong lo2, jlong hi2) {
870 // Two ranges overlap iff one range's low point falls in the other range.
871 return (lo2 <= lo1 && lo1 <= hi2) || (lo1 <= lo2 && lo2 <= hi1);
872 }
873 #endif
874
875 //------------------------------Ideal------------------------------------------
876 Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
877 const TypeLong* this_type = this->type()->is_long();
878 Node* this_changed = NULL;
879
880 // If _major_progress, then more loop optimizations follow. Do NOT
881 // remove this node's type assertion until no more loop ops can happen.
882 // The progress bit is set in the major loop optimizations THEN comes the
883 // call to IterGVN and any chance of hitting this code. Cf. Opaque1Node.
884 if (can_reshape && !phase->C->major_progress()) {
885 const TypeInt* in_type = phase->type(in(1))->isa_int();
886 if (in_type != NULL && this_type != NULL &&
887 (in_type->_lo != this_type->_lo ||
888 in_type->_hi != this_type->_hi)) {
889 // Although this WORSENS the type, it increases GVN opportunities,
890 // because I2L nodes with the same input will common up, regardless
891 // of slightly differing type assertions. Such slight differences
892 // arise routinely as a result of loop unrolling, so this is a
893 // post-unrolling graph cleanup. Choose a type which depends only
894 // on my input. (Exception: Keep a range assertion of >=0 or <0.)
895 jlong lo1 = this_type->_lo;
896 jlong hi1 = this_type->_hi;
897 int w1 = this_type->_widen;
898 if (lo1 != (jint)lo1 ||
899 hi1 != (jint)hi1 ||
900 lo1 > hi1) {
901 // Overflow leads to wraparound, wraparound leads to range saturation.
902 lo1 = min_jint; hi1 = max_jint;
903 } else if (lo1 >= 0) {
904 // Keep a range assertion of >=0.
905 lo1 = 0; hi1 = max_jint;
906 } else if (hi1 < 0) {
907 // Keep a range assertion of <0.
908 lo1 = min_jint; hi1 = -1;
909 } else {
910 lo1 = min_jint; hi1 = max_jint;
911 }
912 const TypeLong* wtype = TypeLong::make(MAX2((jlong)in_type->_lo, lo1),
913 MIN2((jlong)in_type->_hi, hi1),
914 MAX2((int)in_type->_widen, w1));
915 if (wtype != type()) {
916 set_type(wtype);
917 // Note: this_type still has old type value, for the logic below.
918 this_changed = this;
919 }
920 }
921 }
922
923 #ifdef _LP64
924 // Convert ConvI2L(AddI(x, y)) to AddL(ConvI2L(x), ConvI2L(y)) ,
925 // but only if x and y have subranges that cannot cause 32-bit overflow,
926 // under the assumption that x+y is in my own subrange this->type().
927
928 // This assumption is based on a constraint (i.e., type assertion)
929 // established in Parse::array_addressing or perhaps elsewhere.
930 // This constraint has been adjoined to the "natural" type of
931 // the incoming argument in(0). We know (because of runtime
932 // checks) - that the result value I2L(x+y) is in the joined range.
933 // Hence we can restrict the incoming terms (x, y) to values such
934 // that their sum also lands in that range.
935
936 // This optimization is useful only on 64-bit systems, where we hope
937 // the addition will end up subsumed in an addressing mode.
938 // It is necessary to do this when optimizing an unrolled array
939 // copy loop such as x[i++] = y[i++].
940
941 // On 32-bit systems, it's better to perform as much 32-bit math as
942 // possible before the I2L conversion, because 32-bit math is cheaper.
943 // There's no common reason to "leak" a constant offset through the I2L.
944 // Addressing arithmetic will not absorb it as part of a 64-bit AddL.
945
946 Node* z = in(1);
947 int op = z->Opcode();
948 if (op == Op_AddI || op == Op_SubI) {
949 Node* x = z->in(1);
950 Node* y = z->in(2);
951 assert (x != z && y != z, "dead loop in ConvI2LNode::Ideal");
952 if (phase->type(x) == Type::TOP) return this_changed;
953 if (phase->type(y) == Type::TOP) return this_changed;
954 const TypeInt* tx = phase->type(x)->is_int();
955 const TypeInt* ty = phase->type(y)->is_int();
956 const TypeLong* tz = this_type;
957 jlong xlo = tx->_lo;
958 jlong xhi = tx->_hi;
959 jlong ylo = ty->_lo;
960 jlong yhi = ty->_hi;
961 jlong zlo = tz->_lo;
962 jlong zhi = tz->_hi;
963 jlong vbit = CONST64(1) << BitsPerInt;
964 int widen = MAX2(tx->_widen, ty->_widen);
965 if (op == Op_SubI) {
966 jlong ylo0 = ylo;
967 ylo = -yhi;
968 yhi = -ylo0;
969 }
970 // See if x+y can cause positive overflow into z+2**32
971 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo+vbit, zhi+vbit)) {
972 return this_changed;
973 }
974 // See if x+y can cause negative overflow into z-2**32
975 if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo-vbit, zhi-vbit)) {
976 return this_changed;
977 }
978 // Now it's always safe to assume x+y does not overflow.
979 // This is true even if some pairs x,y might cause overflow, as long
980 // as that overflow value cannot fall into [zlo,zhi].
981
982 // Confident that the arithmetic is "as if infinite precision",
983 // we can now use z's range to put constraints on those of x and y.
984 // The "natural" range of x [xlo,xhi] can perhaps be narrowed to a
985 // more "restricted" range by intersecting [xlo,xhi] with the
986 // range obtained by subtracting y's range from the asserted range
987 // of the I2L conversion. Here's the interval arithmetic algebra:
988 // x == z-y == [zlo,zhi]-[ylo,yhi] == [zlo,zhi]+[-yhi,-ylo]
989 // => x in [zlo-yhi, zhi-ylo]
990 // => x in [zlo-yhi, zhi-ylo] INTERSECT [xlo,xhi]
991 // => x in [xlo MAX zlo-yhi, xhi MIN zhi-ylo]
992 jlong rxlo = MAX2(xlo, zlo - yhi);
993 jlong rxhi = MIN2(xhi, zhi - ylo);
994 // And similarly, x changing place with y:
995 jlong rylo = MAX2(ylo, zlo - xhi);
996 jlong ryhi = MIN2(yhi, zhi - xlo);
997 if (rxlo > rxhi || rylo > ryhi) {
998 return this_changed; // x or y is dying; don't mess w/ it
999 }
1000 if (op == Op_SubI) {
1001 jlong rylo0 = rylo;
1002 rylo = -ryhi;
1003 ryhi = -rylo0;
1004 }
1005
1006 Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
1007 Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
1008 switch (op) {
1009 case Op_AddI: return new (phase->C) AddLNode(cx, cy);
1010 case Op_SubI: return new (phase->C) SubLNode(cx, cy);
1011 default: ShouldNotReachHere();
1012 }
1013 }
1014 #endif //_LP64
1015
1016 return this_changed;
1017 }
1018
1019 //=============================================================================
1020 //------------------------------Value------------------------------------------
1021 const Type *ConvL2DNode::Value( PhaseTransform *phase ) const {
1022 const Type *t = phase->type( in(1) );
1023 if( t == Type::TOP ) return Type::TOP;
1024 const TypeLong *tl = t->is_long();
1025 if( tl->is_con() ) return TypeD::make( (double)tl->get_con() );
1026 return bottom_type();
1027 }
1028
1029 //=============================================================================
1030 //------------------------------Value------------------------------------------
1031 const Type *ConvL2FNode::Value( PhaseTransform *phase ) const {
1032 const Type *t = phase->type( in(1) );
1033 if( t == Type::TOP ) return Type::TOP;
1034 const TypeLong *tl = t->is_long();
1035 if( tl->is_con() ) return TypeF::make( (float)tl->get_con() );
1036 return bottom_type();
1037 }
1038
1039 //=============================================================================
1040 //----------------------------Identity-----------------------------------------
1041 Node *ConvL2INode::Identity( PhaseTransform *phase ) {
1042 // Convert L2I(I2L(x)) => x
1043 if (in(1)->Opcode() == Op_ConvI2L) return in(1)->in(1);
1044 return this;
1045 }
1046
1047 //------------------------------Value------------------------------------------
1048 const Type *ConvL2INode::Value( PhaseTransform *phase ) const {
1049 const Type *t = phase->type( in(1) );
1050 if( t == Type::TOP ) return Type::TOP;
1051 const TypeLong *tl = t->is_long();
1052 if (tl->is_con())
1053 // Easy case.
1054 return TypeInt::make((jint)tl->get_con());
1055 return bottom_type();
1056 }
1057
1058 //------------------------------Ideal------------------------------------------
1059 // Return a node which is more "ideal" than the current node.
1060 // Blow off prior masking to int
1061 Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
1062 Node *andl = in(1);
1063 uint andl_op = andl->Opcode();
1064 if( andl_op == Op_AndL ) {
1065 // Blow off prior masking to int
1066 if( phase->type(andl->in(2)) == TypeLong::make( 0xFFFFFFFF ) ) {
1067 set_req(1,andl->in(1));
1068 return this;
1069 }
1070 }
1071
1072 // Swap with a prior add: convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y))
1073 // This replaces an 'AddL' with an 'AddI'.
1074 if( andl_op == Op_AddL ) {
1075 // Don't do this for nodes which have more than one user since
1076 // we'll end up computing the long add anyway.
1077 if (andl->outcnt() > 1) return NULL;
1078
1079 Node* x = andl->in(1);
1080 Node* y = andl->in(2);
1081 assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
1082 if (phase->type(x) == Type::TOP) return NULL;
1083 if (phase->type(y) == Type::TOP) return NULL;
1084 Node *add1 = phase->transform(new (phase->C) ConvL2INode(x));
1085 Node *add2 = phase->transform(new (phase->C) ConvL2INode(y));
1086 return new (phase->C) AddINode(add1,add2);
1087 }
1088
1089 // Disable optimization: LoadL->ConvL2I ==> LoadI.
1090 // It causes problems (sizes of Load and Store nodes do not match)
1091 // in objects initialization code and Escape Analysis.
1092 return NULL;
1093 }
1094
1095 //=============================================================================
1096 //------------------------------Value------------------------------------------
1097 const Type *CastX2PNode::Value( PhaseTransform *phase ) const {
1098 const Type* t = phase->type(in(1));
1099 if (t == Type::TOP) return Type::TOP;
1100 if (t->base() == Type_X && t->singleton()) {
1101 uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con();
1102 if (bits == 0) return TypePtr::NULL_PTR;
1103 return TypeRawPtr::make((address) bits);
1104 }
1105 return CastX2PNode::bottom_type();
1106 }
1107
1108 //------------------------------Idealize---------------------------------------
1109 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) {
1110 if (t == Type::TOP) return false;
1111 const TypeX* tl = t->is_intptr_t();
1112 jint lo = min_jint;
1113 jint hi = max_jint;
1114 if (but_not_min_int) ++lo; // caller wants to negate the value w/o overflow
1115 return (tl->_lo >= lo) && (tl->_hi <= hi);
1116 }
1117
1118 static inline Node* addP_of_X2P(PhaseGVN *phase,
1119 Node* base,
1120 Node* dispX,
1121 bool negate = false) {
1122 if (negate) {
1123 dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX));
1124 }
1125 return new (phase->C) AddPNode(phase->C->top(),
1126 phase->transform(new (phase->C) CastX2PNode(base)),
1127 phase->transform(dispX));
1128 }
1129
1130 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {
1131 // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int
1132 int op = in(1)->Opcode();
1133 Node* x;
1134 Node* y;
1135 switch (op) {
1136 case Op_SubX:
1137 x = in(1)->in(1);
1138 // Avoid ideal transformations ping-pong between this and AddP for raw pointers.
1139 if (phase->find_intptr_t_con(x, -1) == 0)
1140 break;
1141 y = in(1)->in(2);
1142 if (fits_in_int(phase->type(y), true)) {
1143 return addP_of_X2P(phase, x, y, true);
1144 }
1145 break;
1146 case Op_AddX:
1147 x = in(1)->in(1);
1148 y = in(1)->in(2);
1149 if (fits_in_int(phase->type(y))) {
1150 return addP_of_X2P(phase, x, y);
1151 }
1152 if (fits_in_int(phase->type(x))) {
1153 return addP_of_X2P(phase, y, x);
1154 }
1155 break;
1156 }
1157 return NULL;
1158 }
1159
1160 //------------------------------Identity---------------------------------------
1161 Node *CastX2PNode::Identity( PhaseTransform *phase ) {
1162 if (in(1)->Opcode() == Op_CastP2X) return in(1)->in(1);
1163 return this;
1164 }
1165
1166 //=============================================================================
1167 //------------------------------Value------------------------------------------
1168 const Type *CastP2XNode::Value( PhaseTransform *phase ) const {
1169 const Type* t = phase->type(in(1));
1170 if (t == Type::TOP) return Type::TOP;
1171 if (t->base() == Type::RawPtr && t->singleton()) {
1172 uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con();
1173 return TypeX::make(bits);
1174 }
1175 return CastP2XNode::bottom_type();
1176 }
1177
1178 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) {
1179 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
1180 }
1181
1182 //------------------------------Identity---------------------------------------
1183 Node *CastP2XNode::Identity( PhaseTransform *phase ) {
1184 if (in(1)->Opcode() == Op_CastX2P) return in(1)->in(1);
1185 return this;
1186 }
1187
1188
1189 //=============================================================================
1190 //------------------------------Identity---------------------------------------
1191 // Remove redundant roundings
1192 Node *RoundFloatNode::Identity( PhaseTransform *phase ) {
1193 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
1194 // Do not round constants
1195 if (phase->type(in(1))->base() == Type::FloatCon) return in(1);
1196 int op = in(1)->Opcode();
1197 // Redundant rounding
1198 if( op == Op_RoundFloat ) return in(1);
1199 // Already rounded
1200 if( op == Op_Parm ) return in(1);
1201 if( op == Op_LoadF ) return in(1);
1202 return this;
1203 }
1204
1205 //------------------------------Value------------------------------------------
1206 const Type *RoundFloatNode::Value( PhaseTransform *phase ) const {
1207 return phase->type( in(1) );
1208 }
1209
1210 //=============================================================================
1211 //------------------------------Identity---------------------------------------
1212 // Remove redundant roundings. Incoming arguments are already rounded.
1213 Node *RoundDoubleNode::Identity( PhaseTransform *phase ) {
1214 assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
1215 // Do not round constants
1216 if (phase->type(in(1))->base() == Type::DoubleCon) return in(1);
1217 int op = in(1)->Opcode();
1218 // Redundant rounding
1219 if( op == Op_RoundDouble ) return in(1);
1220 // Already rounded
1221 if( op == Op_Parm ) return in(1);
1222 if( op == Op_LoadD ) return in(1);
1223 if( op == Op_ConvF2D ) return in(1);
1224 if( op == Op_ConvI2D ) return in(1);
1225 return this;
1226 }
1227
1228 //------------------------------Value------------------------------------------
1229 const Type *RoundDoubleNode::Value( PhaseTransform *phase ) const {
1230 return phase->type( in(1) );
1231 }
1232
1233
1234 //=============================================================================
1235 // Do not allow value-numbering
1236 uint Opaque1Node::hash() const { return NO_HASH; }
1237 uint Opaque1Node::cmp( const Node &n ) const {
1238 return (&n == this); // Always fail except on self
1239 }
1240
1241 //------------------------------Identity---------------------------------------
1242 // If _major_progress, then more loop optimizations follow. Do NOT remove
1243 // the opaque Node until no more loop ops can happen. Note the timing of
1244 // _major_progress; it's set in the major loop optimizations THEN comes the
1245 // call to IterGVN and any chance of hitting this code. Hence there's no
1246 // phase-ordering problem with stripping Opaque1 in IGVN followed by some
1247 // more loop optimizations that require it.
1248 Node *Opaque1Node::Identity( PhaseTransform *phase ) {
1249 return phase->C->major_progress() ? this : in(1);
1250 }
1251
1252 //=============================================================================
1253 // A node to prevent unwanted optimizations. Allows constant folding. Stops
1254 // value-numbering, most Ideal calls or Identity functions. This Node is
1255 // specifically designed to prevent the pre-increment value of a loop trip
1256 // counter from being live out of the bottom of the loop (hence causing the
1257 // pre- and post-increment values both being live and thus requiring an extra
1258 // temp register and an extra move). If we "accidentally" optimize through
1259 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus
1260 // it's OK to be slightly sloppy on optimizations here.
1261
1262 // Do not allow value-numbering
1263 uint Opaque2Node::hash() const { return NO_HASH; }
1264 uint Opaque2Node::cmp( const Node &n ) const {
1265 return (&n == this); // Always fail except on self
1266 }
1267
1268
1269 //------------------------------Value------------------------------------------
1270 const Type *MoveL2DNode::Value( PhaseTransform *phase ) const {
1271 const Type *t = phase->type( in(1) );
1272 if( t == Type::TOP ) return Type::TOP;
1273 const TypeLong *tl = t->is_long();
1274 if( !tl->is_con() ) return bottom_type();
1275 JavaValue v;
1276 v.set_jlong(tl->get_con());
1277 return TypeD::make( v.get_jdouble() );
1278 }
1279
1280 //------------------------------Value------------------------------------------
1281 const Type *MoveI2FNode::Value( PhaseTransform *phase ) const {
1282 const Type *t = phase->type( in(1) );
1283 if( t == Type::TOP ) return Type::TOP;
1284 const TypeInt *ti = t->is_int();
1285 if( !ti->is_con() ) return bottom_type();
1286 JavaValue v;
1287 v.set_jint(ti->get_con());
1288 return TypeF::make( v.get_jfloat() );
1289 }
1290
1291 //------------------------------Value------------------------------------------
1292 const Type *MoveF2INode::Value( PhaseTransform *phase ) const {
1293 const Type *t = phase->type( in(1) );
1294 if( t == Type::TOP ) return Type::TOP;
1295 if( t == Type::FLOAT ) return TypeInt::INT;
1296 const TypeF *tf = t->is_float_constant();
1297 JavaValue v;
1298 v.set_jfloat(tf->getf());
1299 return TypeInt::make( v.get_jint() );
1300 }
1301
1302 //------------------------------Value------------------------------------------
1303 const Type *MoveD2LNode::Value( PhaseTransform *phase ) const {
1304 const Type *t = phase->type( in(1) );
1305 if( t == Type::TOP ) return Type::TOP;
1306 if( t == Type::DOUBLE ) return TypeLong::LONG;
1307 const TypeD *td = t->is_double_constant();
1308 JavaValue v;
1309 v.set_jdouble(td->getd());
1310 return TypeLong::make( v.get_jlong() );
1311 }
1312
1313 //------------------------------Value------------------------------------------
1314 const Type* CountLeadingZerosINode::Value(PhaseTransform* phase) const {
1315 const Type* t = phase->type(in(1));
1316 if (t == Type::TOP) return Type::TOP;
1317 const TypeInt* ti = t->isa_int();
1318 if (ti && ti->is_con()) {
1319 jint i = ti->get_con();
1320 // HD, Figure 5-6
1321 if (i == 0)
1322 return TypeInt::make(BitsPerInt);
1323 int n = 1;
1324 unsigned int x = i;
1325 if (x >> 16 == 0) { n += 16; x <<= 16; }
1326 if (x >> 24 == 0) { n += 8; x <<= 8; }
1327 if (x >> 28 == 0) { n += 4; x <<= 4; }
1328 if (x >> 30 == 0) { n += 2; x <<= 2; }
1329 n -= x >> 31;
1330 return TypeInt::make(n);
1331 }
1332 return TypeInt::INT;
1333 }
1334
1335 //------------------------------Value------------------------------------------
1336 const Type* CountLeadingZerosLNode::Value(PhaseTransform* phase) const {
1337 const Type* t = phase->type(in(1));
1338 if (t == Type::TOP) return Type::TOP;
1339 const TypeLong* tl = t->isa_long();
1340 if (tl && tl->is_con()) {
1341 jlong l = tl->get_con();
1342 // HD, Figure 5-6
1343 if (l == 0)
1344 return TypeInt::make(BitsPerLong);
1345 int n = 1;
1346 unsigned int x = (((julong) l) >> 32);
1347 if (x == 0) { n += 32; x = (int) l; }
1348 if (x >> 16 == 0) { n += 16; x <<= 16; }
1349 if (x >> 24 == 0) { n += 8; x <<= 8; }
1350 if (x >> 28 == 0) { n += 4; x <<= 4; }
1351 if (x >> 30 == 0) { n += 2; x <<= 2; }
1352 n -= x >> 31;
1353 return TypeInt::make(n);
1354 }
1355 return TypeInt::INT;
1356 }
1357
1358 //------------------------------Value------------------------------------------
1359 const Type* CountTrailingZerosINode::Value(PhaseTransform* phase) const {
1360 const Type* t = phase->type(in(1));
1361 if (t == Type::TOP) return Type::TOP;
1362 const TypeInt* ti = t->isa_int();
1363 if (ti && ti->is_con()) {
1364 jint i = ti->get_con();
1365 // HD, Figure 5-14
1366 int y;
1367 if (i == 0)
1368 return TypeInt::make(BitsPerInt);
1369 int n = 31;
1370 y = i << 16; if (y != 0) { n = n - 16; i = y; }
1371 y = i << 8; if (y != 0) { n = n - 8; i = y; }
1372 y = i << 4; if (y != 0) { n = n - 4; i = y; }
1373 y = i << 2; if (y != 0) { n = n - 2; i = y; }
1374 y = i << 1; if (y != 0) { n = n - 1; }
1375 return TypeInt::make(n);
1376 }
1377 return TypeInt::INT;
1378 }
1379
1380 //------------------------------Value------------------------------------------
1381 const Type* CountTrailingZerosLNode::Value(PhaseTransform* phase) const {
1382 const Type* t = phase->type(in(1));
1383 if (t == Type::TOP) return Type::TOP;
1384 const TypeLong* tl = t->isa_long();
1385 if (tl && tl->is_con()) {
1386 jlong l = tl->get_con();
1387 // HD, Figure 5-14
1388 int x, y;
1389 if (l == 0)
1390 return TypeInt::make(BitsPerLong);
1391 int n = 63;
1392 y = (int) l; if (y != 0) { n = n - 32; x = y; } else x = (((julong) l) >> 32);
1393 y = x << 16; if (y != 0) { n = n - 16; x = y; }
1394 y = x << 8; if (y != 0) { n = n - 8; x = y; }
1395 y = x << 4; if (y != 0) { n = n - 4; x = y; }
1396 y = x << 2; if (y != 0) { n = n - 2; x = y; }
1397 y = x << 1; if (y != 0) { n = n - 1; }
1398 return TypeInt::make(n);
1399 }
1400 return TypeInt::INT;
1401 }