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