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:

    77 (1) Do nothing.  This leads to a bug where we hoist a Load from a CMoveP or a

    78 StrComp above a guarding null check.  I've seen both cases in normal -Xcomp

    79 testing.

    80 

    81 (2) Plug the control edge from 1 of the 2 oops in.  Apparent problem here is

    82 to figure out which test post-dominates.  The real problem is that it doesn't

    83 matter which one you pick.  After you pick up, the dominating-test elider in

    84 IGVN can remove the test and allow you to hoist up to the dominating test on

    85 the chosen oop bypassing the test on the not-chosen oop.  Seen in testing.

    86 Oops.

    87 

    88 (3) Leave the CastPP's in.  This makes the graph more accurate in some sense;

    89 we get to keep around the knowledge that an oop is not-null after some test.

    90 Alas, the CastPP's interfere with GVN (some values are the regular oop, some

    91 are the CastPP of the oop, all merge at Phi's which cannot collapse, etc).

    92 This cost us 10% on SpecJVM, even when I removed some of the more trivial

    93 cases in the optimizer.  Removing more useless Phi's started allowing Loads to

    94 illegally float above null checks.  I gave up on this approach.

    95 

    96 (4) Add BOTH control edges to both tests.  Alas, too much code knows that

    97 control edges are in slot-zero ONLY.  Many quick asserts fail; no way to do

    98 this one.  Note that I really want to allow the CMoveP to float and add both

    99 control edges to the dependent Load op - meaning I can select early but I

   100 cannot Load until I pass both tests.

   101 

   102 (5) Do not hoist CMoveP and StrComp.  To this end I added the v-call

   103 depends_only_on_test().  No obvious performance loss on Spec, but we are

   104 clearly conservative on CMoveP (also so on StrComp but that's unlikely to

   105 matter ever).

   106 

   107 */

   108 

   109 

   110 //------------------------------Ideal------------------------------------------

   111 // Return a node which is more "ideal" than the current node.

   112 // Move constants to the right.

   113 Node *CMoveNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   114   if( in(0) && remove_dead_region(phase, can_reshape) ) return this;

   115   // Don't bother trying to transform a dead node

   116   if( in(0) && in(0)->is_top() )  return NULL;

   117   assert( !phase->eqv(in(Condition), this) &&

   118           !phase->eqv(in(IfFalse), this) &&

   119           !phase->eqv(in(IfTrue), this), "dead loop in CMoveNode::Ideal" );

   120   if( phase->type(in(Condition)) == Type::TOP )

   121     return NULL; // return NULL when Condition is dead

   122 

   123   if( in(IfFalse)->is_Con() && !in(IfTrue)->is_Con() ) {

   124     if( in(Condition)->is_Bool() ) {

   125       BoolNode* b  = in(Condition)->as_Bool();

   126       BoolNode* b2 = b->negate(phase);

   127       return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );

   128     }

   129   }

   130   return NULL;

   131 }

   132 

   133 //------------------------------is_cmove_id------------------------------------

   134 // Helper function to check for CMOVE identity.  Shared with PhiNode::Identity

   135 Node *CMoveNode::is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ) {

   136   // Check for Cmp'ing and CMove'ing same values

   137   if( (phase->eqv(cmp->in(1),f) &&

   138        phase->eqv(cmp->in(2),t)) ||

   139       // Swapped Cmp is OK

   140       (phase->eqv(cmp->in(2),f) &&

   141        phase->eqv(cmp->in(1),t)) ) {

   142     // Give up this identity check for floating points because it may choose incorrect

   143     // value around 0.0 and -0.0

   144     if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD )

   145       return NULL;

   146     // Check for "(t==f)?t:f;" and replace with "f"

   147     if( b->_test._test == BoolTest::eq )

   148       return f;

   149     // Allow the inverted case as well

   150     // Check for "(t!=f)?t:f;" and replace with "t"

   151     if( b->_test._test == BoolTest::ne )

   152       return t;

   153   }

   154   return NULL;

   155 }

   156 

   157 //------------------------------Identity---------------------------------------

   158 // Conditional-move is an identity if both inputs are the same, or the test

   159 // true or false.

   160 Node *CMoveNode::Identity( PhaseTransform *phase ) {

   161   if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs?

   162     return in(IfFalse);         // Then it doesn't matter

   163   if( phase->type(in(Condition)) == TypeInt::ZERO )

   164     return in(IfFalse);         // Always pick left(false) input

   165   if( phase->type(in(Condition)) == TypeInt::ONE )

   166     return in(IfTrue);          // Always pick right(true) input

   167 

   168   // Check for CMove'ing a constant after comparing against the constant.

   169   // Happens all the time now, since if we compare equality vs a constant in

   170   // the parser, we "know" the variable is constant on one path and we force

   171   // it.  Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a

   172   // conditional move: "x = (x==0)?0:x;".  Yucko.  This fix is slightly more

   173   // general in that we don't need constants.

   174   if( in(Condition)->is_Bool() ) {

   175     BoolNode *b = in(Condition)->as_Bool();

   176     Node *cmp = b->in(1);

   177     if( cmp->is_Cmp() ) {

   178       Node *id = is_cmove_id( phase, cmp, in(IfTrue), in(IfFalse), b );

   179       if( id ) return id;

   180     }

   181   }

   182 

   183   return this;

   184 }

   185 

   186 //------------------------------Value------------------------------------------

   187 // Result is the meet of inputs

   188 const Type *CMoveNode::Value( PhaseTransform *phase ) const {

   189   if( phase->type(in(Condition)) == Type::TOP )

   190     return Type::TOP;

   191   return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue)));

   192 }

   193 

   194 //------------------------------make-------------------------------------------

   195 // Make a correctly-flavored CMove.  Since _type is directly determined

   196 // from the inputs we do not need to specify it here.

   197 CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) {

   198   switch( t->basic_type() ) {

   199   case T_INT:     return new (C) CMoveINode( bol, left, right, t->is_int() );

   200   case T_FLOAT:   return new (C) CMoveFNode( bol, left, right, t );

   201   case T_DOUBLE:  return new (C) CMoveDNode( bol, left, right, t );

   202   case T_LONG:    return new (C) CMoveLNode( bol, left, right, t->is_long() );

   203   case T_OBJECT:  return new (C) CMovePNode( c, bol, left, right, t->is_oopptr() );

   204   case T_ADDRESS: return new (C) CMovePNode( c, bol, left, right, t->is_ptr() );

   205   case T_NARROWOOP: return new (C) CMoveNNode( c, bol, left, right, t );

   206   default:

   207     ShouldNotReachHere();

   208     return NULL;

   209   }

   210 }

   211 

   212 //=============================================================================

   213 //------------------------------Ideal------------------------------------------

   214 // Return a node which is more "ideal" than the current node.

   215 // Check for conversions to boolean

   216 Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) {

   217   // Try generic ideal's first

   218   Node *x = CMoveNode::Ideal(phase, can_reshape);

   219   if( x ) return x;

   220 

   221   // If zero is on the left (false-case, no-move-case) it must mean another

   222   // constant is on the right (otherwise the shared CMove::Ideal code would

   223   // have moved the constant to the right).  This situation is bad for Intel

   224   // and a don't-care for Sparc.  It's bad for Intel because the zero has to

   225   // be manifested in a register with a XOR which kills flags, which are live

   226   // on input to the CMoveI, leading to a situation which causes excessive

   227   // spilling on Intel.  For Sparc, if the zero in on the left the Sparc will

   228   // zero a register via G0 and conditionally-move the other constant.  If the

   229   // zero is on the right, the Sparc will load the first constant with a

   230   // 13-bit set-lo and conditionally move G0.  See bug 4677505.

   231   if( phase->type(in(IfFalse)) == TypeInt::ZERO && !(phase->type(in(IfTrue)) == TypeInt::ZERO) ) {

   232     if( in(Condition)->is_Bool() ) {

   233       BoolNode* b  = in(Condition)->as_Bool();

   234       BoolNode* b2 = b->negate(phase);

   235       return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );

   236     }

   237   }

   238 

   239   // Now check for booleans

   240   int flip = 0;

   241 

   242   // Check for picking from zero/one

   243   if( phase->type(in(IfFalse)) == TypeInt::ZERO && phase->type(in(IfTrue)) == TypeInt::ONE ) {

   244     flip = 1 - flip;

   245   } else if( phase->type(in(IfFalse)) == TypeInt::ONE && phase->type(in(IfTrue)) == TypeInt::ZERO ) {

   246   } else return NULL;

   247 

   248   // Check for eq/ne test

   249   if( !in(1)->is_Bool() ) return NULL;

   250   BoolNode *bol = in(1)->as_Bool();

   251   if( bol->_test._test == BoolTest::eq ) {

   252   } else if( bol->_test._test == BoolTest::ne ) {

   253     flip = 1-flip;

   254   } else return NULL;

   255 

   256   // Check for vs 0 or 1

   257   if( !bol->in(1)->is_Cmp() ) return NULL;

   258   const CmpNode *cmp = bol->in(1)->as_Cmp();

   259   if( phase->type(cmp->in(2)) == TypeInt::ZERO ) {

   260   } else if( phase->type(cmp->in(2)) == TypeInt::ONE ) {

   261     // Allow cmp-vs-1 if the other input is bounded by 0-1

   262     if( phase->type(cmp->in(1)) != TypeInt::BOOL )

   263       return NULL;

   264     flip = 1 - flip;

   265   } else return NULL;

   266 

   267   // Convert to a bool (flipped)

   268   // Build int->bool conversion

   269 #ifndef PRODUCT

   270   if( PrintOpto ) tty->print_cr("CMOV to I2B");

   271 #endif

   272   Node *n = new (phase->C) Conv2BNode( cmp->in(1) );

   273   if( flip )

   274     n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) );

   275 

   276   return n;

   277 }

   278 

   279 //=============================================================================

   280 //------------------------------Ideal------------------------------------------

   281 // Return a node which is more "ideal" than the current node.

   282 // Check for absolute value

   283 Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   284   // Try generic ideal's first

   285   Node *x = CMoveNode::Ideal(phase, can_reshape);

   286   if( x ) return x;

   287 

   288   int  cmp_zero_idx = 0;        // Index of compare input where to look for zero

   289   int  phi_x_idx = 0;           // Index of phi input where to find naked x

   290 

   291   // Find the Bool

   292   if( !in(1)->is_Bool() ) return NULL;

   293   BoolNode *bol = in(1)->as_Bool();

   294   // Check bool sense

   295   switch( bol->_test._test ) {

   296   case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue;  break;

   297   case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;

   298   case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue;  break;

   299   case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;

   300   default:           return NULL;                           break;

   301   }

   302 

   303   // Find zero input of CmpF; the other input is being abs'd

   304   Node *cmpf = bol->in(1);

   305   if( cmpf->Opcode() != Op_CmpF ) return NULL;

   306   Node *X = NULL;

   307   bool flip = false;

   308   if( phase->type(cmpf->in(cmp_zero_idx)) == TypeF::ZERO ) {

   309     X = cmpf->in(3 - cmp_zero_idx);

   310   } else if (phase->type(cmpf->in(3 - cmp_zero_idx)) == TypeF::ZERO) {

   311     // The test is inverted, we should invert the result...

   312     X = cmpf->in(cmp_zero_idx);

   313     flip = true;

   314   } else {

   315     return NULL;

   316   }

   317 

   318   // If X is found on the appropriate phi input, find the subtract on the other

   319   if( X != in(phi_x_idx) ) return NULL;

   320   int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;

   321   Node *sub = in(phi_sub_idx);

   322 

   323   // Allow only SubF(0,X) and fail out for all others; NegF is not OK

   324   if( sub->Opcode() != Op_SubF ||

   325       sub->in(2) != X ||

   326       phase->type(sub->in(1)) != TypeF::ZERO ) return NULL;

   327 

   328   Node *abs = new (phase->C) AbsFNode( X );

   329   if( flip )

   330     abs = new (phase->C) SubFNode(sub->in(1), phase->transform(abs));

   331 

   332   return abs;

   333 }

   334 

   335 //=============================================================================

   336 //------------------------------Ideal------------------------------------------

   337 // Return a node which is more "ideal" than the current node.

   338 // Check for absolute value

   339 Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   340   // Try generic ideal's first

   341   Node *x = CMoveNode::Ideal(phase, can_reshape);

   342   if( x ) return x;

   343 

   344   int  cmp_zero_idx = 0;        // Index of compare input where to look for zero

   345   int  phi_x_idx = 0;           // Index of phi input where to find naked x

   346 

   347   // Find the Bool

   348   if( !in(1)->is_Bool() ) return NULL;

   349   BoolNode *bol = in(1)->as_Bool();

   350   // Check bool sense

   351   switch( bol->_test._test ) {

   352   case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue;  break;

   353   case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;

   354   case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue;  break;

   355   case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;

   356   default:           return NULL;                           break;

   357   }

   358 

   359   // Find zero input of CmpD; the other input is being abs'd

   360   Node *cmpd = bol->in(1);

   361   if( cmpd->Opcode() != Op_CmpD ) return NULL;

   362   Node *X = NULL;

   363   bool flip = false;

   364   if( phase->type(cmpd->in(cmp_zero_idx)) == TypeD::ZERO ) {

   365     X = cmpd->in(3 - cmp_zero_idx);

   366   } else if (phase->type(cmpd->in(3 - cmp_zero_idx)) == TypeD::ZERO) {

   367     // The test is inverted, we should invert the result...

   368     X = cmpd->in(cmp_zero_idx);

   369     flip = true;

   370   } else {

   371     return NULL;

   372   }

   373 

   374   // If X is found on the appropriate phi input, find the subtract on the other

   375   if( X != in(phi_x_idx) ) return NULL;

   376   int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;

   377   Node *sub = in(phi_sub_idx);

   378 

   379   // Allow only SubD(0,X) and fail out for all others; NegD is not OK

   380   if( sub->Opcode() != Op_SubD ||

   381       sub->in(2) != X ||

   382       phase->type(sub->in(1)) != TypeD::ZERO ) return NULL;

   383 

   384   Node *abs = new (phase->C) AbsDNode( X );

   385   if( flip )

   386     abs = new (phase->C) SubDNode(sub->in(1), phase->transform(abs));

   387 

   388   return abs;

   389 }

   390 

   391 

   392 //=============================================================================

   393 // If input is already higher or equal to cast type, then this is an identity.

   394 Node *ConstraintCastNode::Identity( PhaseTransform *phase ) {

   395   return phase->type(in(1))->higher_equal_speculative(_type) ? in(1) : this;

   396 }

   397 

   398 //------------------------------Value------------------------------------------

   399 // Take 'join' of input and cast-up type

   400 const Type *ConstraintCastNode::Value( PhaseTransform *phase ) const {

   401   if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;

   402   const Type* ft = phase->type(in(1))->filter_speculative(_type);

   403 

   404 #ifdef ASSERT

   405   // Previous versions of this function had some special case logic,

   406   // which is no longer necessary.  Make sure of the required effects.

   407   switch (Opcode()) {

   408   case Op_CastII:

   409     {

   410       const Type* t1 = phase->type(in(1));

   411       if( t1 == Type::TOP )  assert(ft == Type::TOP, "special case #1");

   412       const Type* rt = t1->join_speculative(_type);

   413       if (rt->empty())       assert(ft == Type::TOP, "special case #2");

   414       break;

   415     }

   416   case Op_CastPP:

   417     if (phase->type(in(1)) == TypePtr::NULL_PTR &&

   418         _type->isa_ptr() && _type->is_ptr()->_ptr == TypePtr::NotNull)

   419       assert(ft == Type::TOP, "special case #3");

   420     break;

   421   }

   422 #endif //ASSERT

   423 

   424   return ft;

   425 }

   426 

   427 //------------------------------Ideal------------------------------------------

   428 // Return a node which is more "ideal" than the current node.  Strip out

   429 // control copies

   430 Node *ConstraintCastNode::Ideal(PhaseGVN *phase, bool can_reshape){

   431   return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;

   432 }

   433 

   434 //------------------------------Ideal_DU_postCCP-------------------------------

   435 // Throw away cast after constant propagation

   436 Node *ConstraintCastNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {

   437   const Type *t = ccp->type(in(1));

   438   ccp->hash_delete(this);

   439   set_type(t);                   // Turn into ID function

   440   ccp->hash_insert(this);

   441   return this;

   442 }

   443 

   444 

   445 //=============================================================================

   446 

   447 //------------------------------Ideal_DU_postCCP-------------------------------

   448 // If not converting int->oop, throw away cast after constant propagation

   449 Node *CastPPNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {

   450   const Type *t = ccp->type(in(1));

   451   if (!t->isa_oop_ptr() || ((in(1)->is_DecodeN()) && Matcher::gen_narrow_oop_implicit_null_checks())) {

   452     return NULL; // do not transform raw pointers or narrow oops

   453   }

   454   return ConstraintCastNode::Ideal_DU_postCCP(ccp);

   455 }

   456 

   457 

   458 

   459 //=============================================================================

   460 //------------------------------Identity---------------------------------------

   461 // If input is already higher or equal to cast type, then this is an identity.

   462 Node *CheckCastPPNode::Identity( PhaseTransform *phase ) {

   463   // Toned down to rescue meeting at a Phi 3 different oops all implementing

   464   // the same interface.  CompileTheWorld starting at 502, kd12rc1.zip.

   465   return (phase->type(in(1)) == phase->type(this)) ? in(1) : this;

   466 }

   467 

   468 //------------------------------Value------------------------------------------

   469 // Take 'join' of input and cast-up type, unless working with an Interface

   470 const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {

   471   if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;

   472 

   473   const Type *inn = phase->type(in(1));

   474   if( inn == Type::TOP ) return Type::TOP;  // No information yet

   475 

   476   const TypePtr *in_type   = inn->isa_ptr();

   477   const TypePtr *my_type   = _type->isa_ptr();

   478   const Type *result = _type;

   479   if( in_type != NULL && my_type != NULL ) {

   480     TypePtr::PTR   in_ptr    = in_type->ptr();

   481     if( in_ptr == TypePtr::Null ) {

   482       result = in_type;

   483     } else if( in_ptr == TypePtr::Constant ) {

   484       // Casting a constant oop to an interface?

   485       // (i.e., a String to a Comparable?)

   486       // Then return the interface.

   487       const TypeOopPtr *jptr = my_type->isa_oopptr();

   488       assert( jptr, "" );

   489       result =  (jptr->klass()->is_interface() || !in_type->higher_equal(_type))

   490         ? my_type->cast_to_ptr_type( TypePtr::NotNull )

   491         : in_type;

   492     } else {

   493       result =  my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) );

   494     }

   495   }

   496 

   497   // This is the code from TypePtr::xmeet() that prevents us from

   498   // having 2 ways to represent the same type. We have to replicate it

   499   // here because we don't go through meet/join.

   500   if (result->remove_speculative() == result->speculative()) {

   501     result = result->remove_speculative();

   502   }

   503 

   504   // Same as above: because we don't go through meet/join, remove the

   505   // speculative type if we know we won't use it.

   506   return result->cleanup_speculative();

   507 

   508   // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES.

   509   // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR!

   510 

   511   //

   512   // Remove this code after overnight run indicates no performance

   513   // loss from not performing JOIN at CheckCastPPNode

   514   //

   515   // const TypeInstPtr *in_oop = in->isa_instptr();

   516   // const TypeInstPtr *my_oop = _type->isa_instptr();

   517   // // If either input is an 'interface', return destination type

   518   // assert (in_oop == NULL || in_oop->klass() != NULL, "");

   519   // assert (my_oop == NULL || my_oop->klass() != NULL, "");

   520   // if( (in_oop && in_oop->klass()->is_interface())

   521   //   ||(my_oop && my_oop->klass()->is_interface()) ) {

   522   //   TypePtr::PTR  in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR;

   523   //   // Preserve cast away nullness for interfaces

   524   //   if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) {

   525   //     return my_oop->cast_to_ptr_type(TypePtr::NotNull);

   526   //   }

   527   //   return _type;

   528   // }

   529   //

   530   // // Neither the input nor the destination type is an interface,

   531   //

   532   // // history: JOIN used to cause weird corner case bugs

   533   // //          return (in == TypeOopPtr::NULL_PTR) ? in : _type;

   534   // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops.

   535   // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr

   536   // const Type *join = in->join(_type);

   537   // // Check if join preserved NotNull'ness for pointers

   538   // if( join->isa_ptr() && _type->isa_ptr() ) {

   539   //   TypePtr::PTR join_ptr = join->is_ptr()->_ptr;

   540   //   TypePtr::PTR type_ptr = _type->is_ptr()->_ptr;

   541   //   // If there isn't any NotNull'ness to preserve

   542   //   // OR if join preserved NotNull'ness then return it

   543   //   if( type_ptr == TypePtr::BotPTR  || type_ptr == TypePtr::Null ||

   544   //       join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) {

   545   //     return join;

   546   //   }

   547   //   // ELSE return same old type as before

   548   //   return _type;

   549   // }

   550   // // Not joining two pointers

   551   // return join;

   552 }

   553 

   554 //------------------------------Ideal------------------------------------------

   555 // Return a node which is more "ideal" than the current node.  Strip out

   556 // control copies

   557 Node *CheckCastPPNode::Ideal(PhaseGVN *phase, bool can_reshape){

   558   return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;

   559 }

   560 

   561 

   562 Node* DecodeNNode::Identity(PhaseTransform* phase) {

   563   const Type *t = phase->type( in(1) );

   564   if( t == Type::TOP ) return in(1);

   565 

   566   if (in(1)->is_EncodeP()) {

   567     // (DecodeN (EncodeP p)) -> p

   568     return in(1)->in(1);

   569   }

   570   return this;

   571 }

   572 

   573 const Type *DecodeNNode::Value( PhaseTransform *phase ) const {

   574   const Type *t = phase->type( in(1) );

   575   if (t == Type::TOP) return Type::TOP;

   576   if (t == TypeNarrowOop::NULL_PTR) return TypePtr::NULL_PTR;

   577 

   578   assert(t->isa_narrowoop(), "only  narrowoop here");

   579   return t->make_ptr();

   580 }

   581 

   582 Node* EncodePNode::Identity(PhaseTransform* phase) {

   583   const Type *t = phase->type( in(1) );

   584   if( t == Type::TOP ) return in(1);

   585 

   586   if (in(1)->is_DecodeN()) {

   587     // (EncodeP (DecodeN p)) -> p

   588     return in(1)->in(1);

   589   }

   590   return this;

   591 }

   592 

   593 const Type *EncodePNode::Value( PhaseTransform *phase ) const {

   594   const Type *t = phase->type( in(1) );

   595   if (t == Type::TOP) return Type::TOP;

   596   if (t == TypePtr::NULL_PTR) return TypeNarrowOop::NULL_PTR;

   597 

   598   assert(t->isa_oop_ptr(), "only oopptr here");

   599   return t->make_narrowoop();

   600 }

   601 

   602 

   603 Node *EncodeNarrowPtrNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {

   604   return MemNode::Ideal_common_DU_postCCP(ccp, this, in(1));

   605 }

   606 

   607 Node* DecodeNKlassNode::Identity(PhaseTransform* phase) {

   608   const Type *t = phase->type( in(1) );

   609   if( t == Type::TOP ) return in(1);

   610 

   611   if (in(1)->is_EncodePKlass()) {

   612     // (DecodeNKlass (EncodePKlass p)) -> p

   613     return in(1)->in(1);

   614   }

   615   return this;

   616 }

   617 

   618 const Type *DecodeNKlassNode::Value( PhaseTransform *phase ) const {

   619   const Type *t = phase->type( in(1) );

   620   if (t == Type::TOP) return Type::TOP;

   621   assert(t != TypeNarrowKlass::NULL_PTR, "null klass?");

   622 

   623   assert(t->isa_narrowklass(), "only narrow klass ptr here");

   624   return t->make_ptr();

   625 }

   626 

   627 Node* EncodePKlassNode::Identity(PhaseTransform* phase) {

   628   const Type *t = phase->type( in(1) );

   629   if( t == Type::TOP ) return in(1);

   630 

   631   if (in(1)->is_DecodeNKlass()) {

   632     // (EncodePKlass (DecodeNKlass p)) -> p

   633     return in(1)->in(1);

   634   }

   635   return this;

   636 }

   637 

   638 const Type *EncodePKlassNode::Value( PhaseTransform *phase ) const {

   639   const Type *t = phase->type( in(1) );

   640   if (t == Type::TOP) return Type::TOP;

   641   assert (t != TypePtr::NULL_PTR, "null klass?");

   642 

   643   assert(UseCompressedClassPointers && t->isa_klassptr(), "only klass ptr here");

   644   return t->make_narrowklass();

   645 }

   646 

   647 

   648 //=============================================================================

   649 //------------------------------Identity---------------------------------------

   650 Node *Conv2BNode::Identity( PhaseTransform *phase ) {

   651   const Type *t = phase->type( in(1) );

   652   if( t == Type::TOP ) return in(1);

   653   if( t == TypeInt::ZERO ) return in(1);

   654   if( t == TypeInt::ONE ) return in(1);

   655   if( t == TypeInt::BOOL ) return in(1);

   656   return this;

   657 }

   658 

   659 //------------------------------Value------------------------------------------

   660 const Type *Conv2BNode::Value( PhaseTransform *phase ) const {

   661   const Type *t = phase->type( in(1) );

   662   if( t == Type::TOP ) return Type::TOP;

   663   if( t == TypeInt::ZERO ) return TypeInt::ZERO;

   664   if( t == TypePtr::NULL_PTR ) return TypeInt::ZERO;

   665   const TypePtr *tp = t->isa_ptr();

   666   if( tp != NULL ) {

   667     if( tp->ptr() == TypePtr::AnyNull ) return Type::TOP;

   668     if( tp->ptr() == TypePtr::Constant) return TypeInt::ONE;

   669     if (tp->ptr() == TypePtr::NotNull)  return TypeInt::ONE;

   670     return TypeInt::BOOL;

   671   }

   672   if (t->base() != Type::Int) return TypeInt::BOOL;

   673   const TypeInt *ti = t->is_int();

   674   if( ti->_hi < 0 || ti->_lo > 0 ) return TypeInt::ONE;

   675   return TypeInt::BOOL;

   676 }

   677 

   678 

   679 // The conversions operations are all Alpha sorted.  Please keep it that way!

   680 //=============================================================================

   681 //------------------------------Value------------------------------------------

   682 const Type *ConvD2FNode::Value( PhaseTransform *phase ) const {

   683   const Type *t = phase->type( in(1) );

   684   if( t == Type::TOP ) return Type::TOP;

   685   if( t == Type::DOUBLE ) return Type::FLOAT;

   686   const TypeD *td = t->is_double_constant();

   687   return TypeF::make( (float)td->getd() );

   688 }

   689 

   690 //------------------------------Identity---------------------------------------

   691 // Float's can be converted to doubles with no loss of bits.  Hence

   692 // converting a float to a double and back to a float is a NOP.

   693 Node *ConvD2FNode::Identity(PhaseTransform *phase) {

   694   return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this;

   695 }

   696 

   697 //=============================================================================

   698 //------------------------------Value------------------------------------------

   699 const Type *ConvD2INode::Value( PhaseTransform *phase ) const {

   700   const Type *t = phase->type( in(1) );

   701   if( t == Type::TOP ) return Type::TOP;

   702   if( t == Type::DOUBLE ) return TypeInt::INT;

   703   const TypeD *td = t->is_double_constant();

   704   return TypeInt::make( SharedRuntime::d2i( td->getd() ) );

   705 }

   706 

   707 //------------------------------Ideal------------------------------------------

   708 // If converting to an int type, skip any rounding nodes

   709 Node *ConvD2INode::Ideal(PhaseGVN *phase, bool can_reshape) {

   710   if( in(1)->Opcode() == Op_RoundDouble )

   711     set_req(1,in(1)->in(1));

   712   return NULL;

   713 }

   714 

   715 //------------------------------Identity---------------------------------------

   716 // Int's can be converted to doubles with no loss of bits.  Hence

   717 // converting an integer to a double and back to an integer is a NOP.

   718 Node *ConvD2INode::Identity(PhaseTransform *phase) {

   719   return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this;

   720 }

   721 

   722 //=============================================================================

   723 //------------------------------Value------------------------------------------

   724 const Type *ConvD2LNode::Value( PhaseTransform *phase ) const {

   725   const Type *t = phase->type( in(1) );

   726   if( t == Type::TOP ) return Type::TOP;

   727   if( t == Type::DOUBLE ) return TypeLong::LONG;

   728   const TypeD *td = t->is_double_constant();

   729   return TypeLong::make( SharedRuntime::d2l( td->getd() ) );

   730 }

   731 

   732 //------------------------------Identity---------------------------------------

   733 Node *ConvD2LNode::Identity(PhaseTransform *phase) {

   734   // Remove ConvD2L->ConvL2D->ConvD2L sequences.

   735   if( in(1)       ->Opcode() == Op_ConvL2D &&

   736       in(1)->in(1)->Opcode() == Op_ConvD2L )

   737     return in(1)->in(1);

   738   return this;

   739 }

   740 

   741 //------------------------------Ideal------------------------------------------

   742 // If converting to an int type, skip any rounding nodes

   743 Node *ConvD2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   744   if( in(1)->Opcode() == Op_RoundDouble )

   745     set_req(1,in(1)->in(1));

   746   return NULL;

   747 }

   748 

   749 //=============================================================================

   750 //------------------------------Value------------------------------------------

   751 const Type *ConvF2DNode::Value( PhaseTransform *phase ) const {

   752   const Type *t = phase->type( in(1) );

   753   if( t == Type::TOP ) return Type::TOP;

   754   if( t == Type::FLOAT ) return Type::DOUBLE;

   755   const TypeF *tf = t->is_float_constant();

   756   return TypeD::make( (double)tf->getf() );

   757 }

   758 

   759 //=============================================================================

   760 //------------------------------Value------------------------------------------

   761 const Type *ConvF2INode::Value( PhaseTransform *phase ) const {

   762   const Type *t = phase->type( in(1) );

   763   if( t == Type::TOP )       return Type::TOP;

   764   if( t == Type::FLOAT ) return TypeInt::INT;

   765   const TypeF *tf = t->is_float_constant();

   766   return TypeInt::make( SharedRuntime::f2i( tf->getf() ) );

   767 }

   768 

   769 //------------------------------Identity---------------------------------------

   770 Node *ConvF2INode::Identity(PhaseTransform *phase) {

   771   // Remove ConvF2I->ConvI2F->ConvF2I sequences.

   772   if( in(1)       ->Opcode() == Op_ConvI2F &&

   773       in(1)->in(1)->Opcode() == Op_ConvF2I )

   774     return in(1)->in(1);

   775   return this;

   776 }

   777 

   778 //------------------------------Ideal------------------------------------------

   779 // If converting to an int type, skip any rounding nodes

   780 Node *ConvF2INode::Ideal(PhaseGVN *phase, bool can_reshape) {

   781   if( in(1)->Opcode() == Op_RoundFloat )

   782     set_req(1,in(1)->in(1));

   783   return NULL;

   784 }

   785 

   786 //=============================================================================

   787 //------------------------------Value------------------------------------------

   788 const Type *ConvF2LNode::Value( PhaseTransform *phase ) const {

   789   const Type *t = phase->type( in(1) );

   790   if( t == Type::TOP )       return Type::TOP;

   791   if( t == Type::FLOAT ) return TypeLong::LONG;

   792   const TypeF *tf = t->is_float_constant();

   793   return TypeLong::make( SharedRuntime::f2l( tf->getf() ) );

   794 }

   795 

   796 //------------------------------Identity---------------------------------------

   797 Node *ConvF2LNode::Identity(PhaseTransform *phase) {

   798   // Remove ConvF2L->ConvL2F->ConvF2L sequences.

   799   if( in(1)       ->Opcode() == Op_ConvL2F &&

   800       in(1)->in(1)->Opcode() == Op_ConvF2L )

   801     return in(1)->in(1);

   802   return this;

   803 }

   804 

   805 //------------------------------Ideal------------------------------------------

   806 // If converting to an int type, skip any rounding nodes

   807 Node *ConvF2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   808   if( in(1)->Opcode() == Op_RoundFloat )

   809     set_req(1,in(1)->in(1));

   810   return NULL;

   811 }

   812 

   813 //=============================================================================

   814 //------------------------------Value------------------------------------------

   815 const Type *ConvI2DNode::Value( PhaseTransform *phase ) const {

   816   const Type *t = phase->type( in(1) );

   817   if( t == Type::TOP ) return Type::TOP;

   818   const TypeInt *ti = t->is_int();

   819   if( ti->is_con() ) return TypeD::make( (double)ti->get_con() );

   820   return bottom_type();

   821 }

   822 

   823 //=============================================================================

   824 //------------------------------Value------------------------------------------

   825 const Type *ConvI2FNode::Value( PhaseTransform *phase ) const {

   826   const Type *t = phase->type( in(1) );

   827   if( t == Type::TOP ) return Type::TOP;

   828   const TypeInt *ti = t->is_int();

   829   if( ti->is_con() ) return TypeF::make( (float)ti->get_con() );

   830   return bottom_type();

   831 }

   832 

   833 //------------------------------Identity---------------------------------------

   834 Node *ConvI2FNode::Identity(PhaseTransform *phase) {

   835   // Remove ConvI2F->ConvF2I->ConvI2F sequences.

   836   if( in(1)       ->Opcode() == Op_ConvF2I &&

   837       in(1)->in(1)->Opcode() == Op_ConvI2F )

   838     return in(1)->in(1);

   839   return this;

   840 }

   841 

   842 //=============================================================================

   843 //------------------------------Value------------------------------------------

   844 const Type *ConvI2LNode::Value( PhaseTransform *phase ) const {

   845   const Type *t = phase->type( in(1) );

   846   if( t == Type::TOP ) return Type::TOP;

   847   const TypeInt *ti = t->is_int();

   848   const Type* tl = TypeLong::make(ti->_lo, ti->_hi, ti->_widen);

   849   // Join my declared type against my incoming type.

   850   tl = tl->filter(_type);

   851   return tl;

   852 }

   853 

   854 #ifdef _LP64

   855 static inline bool long_ranges_overlap(jlong lo1, jlong hi1,

   856                                        jlong lo2, jlong hi2) {

   857   // Two ranges overlap iff one range's low point falls in the other range.

   858   return (lo2 <= lo1 && lo1 <= hi2) || (lo1 <= lo2 && lo2 <= hi1);

   859 }

   860 #endif

   861 

   862 //------------------------------Ideal------------------------------------------

   863 Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {

   864   const TypeLong* this_type = this->type()->is_long();

   865   Node* this_changed = NULL;

   866 

   867   // If _major_progress, then more loop optimizations follow.  Do NOT

   868   // remove this node's type assertion until no more loop ops can happen.

   869   // The progress bit is set in the major loop optimizations THEN comes the

   870   // call to IterGVN and any chance of hitting this code.  Cf. Opaque1Node.

   871   if (can_reshape && !phase->C->major_progress()) {

   872     const TypeInt* in_type = phase->type(in(1))->isa_int();

   873     if (in_type != NULL && this_type != NULL &&

   874         (in_type->_lo != this_type->_lo ||

   875          in_type->_hi != this_type->_hi)) {

   876       // Although this WORSENS the type, it increases GVN opportunities,

   877       // because I2L nodes with the same input will common up, regardless

   878       // of slightly differing type assertions.  Such slight differences

   879       // arise routinely as a result of loop unrolling, so this is a

   880       // post-unrolling graph cleanup.  Choose a type which depends only

   881       // on my input.  (Exception:  Keep a range assertion of >=0 or <0.)

   882       jlong lo1 = this_type->_lo;

   883       jlong hi1 = this_type->_hi;

   884       int   w1  = this_type->_widen;

   885       if (lo1 != (jint)lo1 ||

   886           hi1 != (jint)hi1 ||

   887           lo1 > hi1) {

   888         // Overflow leads to wraparound, wraparound leads to range saturation.

   889         lo1 = min_jint; hi1 = max_jint;

   890       } else if (lo1 >= 0) {

   891         // Keep a range assertion of >=0.

   892         lo1 = 0;        hi1 = max_jint;

   893       } else if (hi1 < 0) {

   894         // Keep a range assertion of <0.

   895         lo1 = min_jint; hi1 = -1;

   896       } else {

   897         lo1 = min_jint; hi1 = max_jint;

   898       }

   899       const TypeLong* wtype = TypeLong::make(MAX2((jlong)in_type->_lo, lo1),

   900                                              MIN2((jlong)in_type->_hi, hi1),

   901                                              MAX2((int)in_type->_widen, w1));

   902       if (wtype != type()) {

   903         set_type(wtype);

   904         // Note: this_type still has old type value, for the logic below.

   905         this_changed = this;

   906       }

   907     }

   908   }

   909 

   910 #ifdef _LP64

   911   // Convert ConvI2L(AddI(x, y)) to AddL(ConvI2L(x), ConvI2L(y)) ,

   912   // but only if x and y have subranges that cannot cause 32-bit overflow,

   913   // under the assumption that x+y is in my own subrange this->type().

   914 

   915   // This assumption is based on a constraint (i.e., type assertion)

   916   // established in Parse::array_addressing or perhaps elsewhere.

   917   // This constraint has been adjoined to the "natural" type of

   918   // the incoming argument in(0).  We know (because of runtime

   919   // checks) - that the result value I2L(x+y) is in the joined range.

   920   // Hence we can restrict the incoming terms (x, y) to values such

   921   // that their sum also lands in that range.

   922 

   923   // This optimization is useful only on 64-bit systems, where we hope

   924   // the addition will end up subsumed in an addressing mode.

   925   // It is necessary to do this when optimizing an unrolled array

   926   // copy loop such as x[i++] = y[i++].

   927 

   928   // On 32-bit systems, it's better to perform as much 32-bit math as

   929   // possible before the I2L conversion, because 32-bit math is cheaper.

   930   // There's no common reason to "leak" a constant offset through the I2L.

   931   // Addressing arithmetic will not absorb it as part of a 64-bit AddL.

   932 

   933   Node* z = in(1);

   934   int op = z->Opcode();

   935   if (op == Op_AddI || op == Op_SubI) {

   936     Node* x = z->in(1);

   937     Node* y = z->in(2);

   938     assert (x != z && y != z, "dead loop in ConvI2LNode::Ideal");

   939     if (phase->type(x) == Type::TOP)  return this_changed;

   940     if (phase->type(y) == Type::TOP)  return this_changed;

   941     const TypeInt*  tx = phase->type(x)->is_int();

   942     const TypeInt*  ty = phase->type(y)->is_int();

   943     const TypeLong* tz = this_type;

   944     jlong xlo = tx->_lo;

   945     jlong xhi = tx->_hi;

   946     jlong ylo = ty->_lo;

   947     jlong yhi = ty->_hi;

   948     jlong zlo = tz->_lo;

   949     jlong zhi = tz->_hi;

   950     jlong vbit = CONST64(1) << BitsPerInt;

   951     int widen =  MAX2(tx->_widen, ty->_widen);

   952     if (op == Op_SubI) {

   953       jlong ylo0 = ylo;

   954       ylo = -yhi;

   955       yhi = -ylo0;

   956     }

   957     // See if x+y can cause positive overflow into z+2**32

   958     if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo+vbit, zhi+vbit)) {

   959       return this_changed;

   960     }

   961     // See if x+y can cause negative overflow into z-2**32

   962     if (long_ranges_overlap(xlo+ylo, xhi+yhi, zlo-vbit, zhi-vbit)) {

   963       return this_changed;

   964     }

   965     // Now it's always safe to assume x+y does not overflow.

   966     // This is true even if some pairs x,y might cause overflow, as long

   967     // as that overflow value cannot fall into [zlo,zhi].

   968 

   969     // Confident that the arithmetic is "as if infinite precision",

   970     // we can now use z's range to put constraints on those of x and y.

   971     // The "natural" range of x [xlo,xhi] can perhaps be narrowed to a

   972     // more "restricted" range by intersecting [xlo,xhi] with the

   973     // range obtained by subtracting y's range from the asserted range

   974     // of the I2L conversion.  Here's the interval arithmetic algebra:

   975     //    x == z-y == [zlo,zhi]-[ylo,yhi] == [zlo,zhi]+[-yhi,-ylo]

   976     //    => x in [zlo-yhi, zhi-ylo]

   977     //    => x in [zlo-yhi, zhi-ylo] INTERSECT [xlo,xhi]

   978     //    => x in [xlo MAX zlo-yhi, xhi MIN zhi-ylo]

   979     jlong rxlo = MAX2(xlo, zlo - yhi);

   980     jlong rxhi = MIN2(xhi, zhi - ylo);

   981     // And similarly, x changing place with y:

   982     jlong rylo = MAX2(ylo, zlo - xhi);

   983     jlong ryhi = MIN2(yhi, zhi - xlo);

   984     if (rxlo > rxhi || rylo > ryhi) {

   985       return this_changed;  // x or y is dying; don't mess w/ it

   986     }

   987     if (op == Op_SubI) {

   988       jlong rylo0 = rylo;

   989       rylo = -ryhi;

   990       ryhi = -rylo0;

   991     }

   992 

   993     Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );

   994     Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );

   995     switch (op) {

   996     case Op_AddI:  return new (phase->C) AddLNode(cx, cy);

   997     case Op_SubI:  return new (phase->C) SubLNode(cx, cy);

   998     default:       ShouldNotReachHere();

   999     }

  1000   }

  1001 #endif //_LP64

  1002 

  1003   return this_changed;

  1004 }

  1005 

  1006 //=============================================================================

  1007 //------------------------------Value------------------------------------------

  1008 const Type *ConvL2DNode::Value( PhaseTransform *phase ) const {

  1009   const Type *t = phase->type( in(1) );

  1010   if( t == Type::TOP ) return Type::TOP;

  1011   const TypeLong *tl = t->is_long();

  1012   if( tl->is_con() ) return TypeD::make( (double)tl->get_con() );

  1013   return bottom_type();

  1014 }

  1015 

  1016 //=============================================================================

  1017 //------------------------------Value------------------------------------------

  1018 const Type *ConvL2FNode::Value( PhaseTransform *phase ) const {

  1019   const Type *t = phase->type( in(1) );

  1020   if( t == Type::TOP ) return Type::TOP;

  1021   const TypeLong *tl = t->is_long();

  1022   if( tl->is_con() ) return TypeF::make( (float)tl->get_con() );

  1023   return bottom_type();

  1024 }

  1025 

  1026 //=============================================================================

  1027 //----------------------------Identity-----------------------------------------

  1028 Node *ConvL2INode::Identity( PhaseTransform *phase ) {

  1029   // Convert L2I(I2L(x)) => x

  1030   if (in(1)->Opcode() == Op_ConvI2L)  return in(1)->in(1);

  1031   return this;

  1032 }

  1033 

  1034 //------------------------------Value------------------------------------------

  1035 const Type *ConvL2INode::Value( PhaseTransform *phase ) const {

  1036   const Type *t = phase->type( in(1) );

  1037   if( t == Type::TOP ) return Type::TOP;

  1038   const TypeLong *tl = t->is_long();

  1039   if (tl->is_con())

  1040     // Easy case.

  1041     return TypeInt::make((jint)tl->get_con());

  1042   return bottom_type();

  1043 }

  1044 

  1045 //------------------------------Ideal------------------------------------------

  1046 // Return a node which is more "ideal" than the current node.

  1047 // Blow off prior masking to int

  1048 Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) {

  1049   Node *andl = in(1);

  1050   uint andl_op = andl->Opcode();

  1051   if( andl_op == Op_AndL ) {

  1052     // Blow off prior masking to int

  1053     if( phase->type(andl->in(2)) == TypeLong::make( 0xFFFFFFFF ) ) {

  1054       set_req(1,andl->in(1));

  1055       return this;

  1056     }

  1057   }

  1058 

  1059   // Swap with a prior add: convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y))

  1060   // This replaces an 'AddL' with an 'AddI'.

  1061   if( andl_op == Op_AddL ) {

  1062     // Don't do this for nodes which have more than one user since

  1063     // we'll end up computing the long add anyway.

  1064     if (andl->outcnt() > 1) return NULL;

  1065 

  1066     Node* x = andl->in(1);

  1067     Node* y = andl->in(2);

  1068     assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );

  1069     if (phase->type(x) == Type::TOP)  return NULL;

  1070     if (phase->type(y) == Type::TOP)  return NULL;

  1071     Node *add1 = phase->transform(new (phase->C) ConvL2INode(x));

  1072     Node *add2 = phase->transform(new (phase->C) ConvL2INode(y));

  1073     return new (phase->C) AddINode(add1,add2);

  1074   }

  1075 

  1076   // Disable optimization: LoadL->ConvL2I ==> LoadI.

  1077   // It causes problems (sizes of Load and Store nodes do not match)

  1078   // in objects initialization code and Escape Analysis.

  1079   return NULL;

  1080 }

  1081 

  1082 //=============================================================================

  1083 //------------------------------Value------------------------------------------

  1084 const Type *CastX2PNode::Value( PhaseTransform *phase ) const {

  1085   const Type* t = phase->type(in(1));

  1086   if (t == Type::TOP) return Type::TOP;

  1087   if (t->base() == Type_X && t->singleton()) {

  1088     uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con();

  1089     if (bits == 0)   return TypePtr::NULL_PTR;

  1090     return TypeRawPtr::make((address) bits);

  1091   }

  1092   return CastX2PNode::bottom_type();

  1093 }

  1094 

  1095 //------------------------------Idealize---------------------------------------

  1096 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) {

  1097   if (t == Type::TOP)  return false;

  1098   const TypeX* tl = t->is_intptr_t();

  1099   jint lo = min_jint;

  1100   jint hi = max_jint;

  1101   if (but_not_min_int)  ++lo;  // caller wants to negate the value w/o overflow

  1102   return (tl->_lo >= lo) && (tl->_hi <= hi);

  1103 }

  1104 

  1105 static inline Node* addP_of_X2P(PhaseGVN *phase,

  1106                                 Node* base,

  1107                                 Node* dispX,

  1108                                 bool negate = false) {

  1109   if (negate) {

  1110     dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX));

  1111   }

  1112   return new (phase->C) AddPNode(phase->C->top(),

  1113                           phase->transform(new (phase->C) CastX2PNode(base)),

  1114                           phase->transform(dispX));

  1115 }

  1116 

  1117 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {

  1118   // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int

  1119   int op = in(1)->Opcode();

  1120   Node* x;

  1121   Node* y;

  1122   switch (op) {

  1123   case Op_SubX:

  1124     x = in(1)->in(1);

  1125     // Avoid ideal transformations ping-pong between this and AddP for raw pointers.

  1126     if (phase->find_intptr_t_con(x, -1) == 0)

  1127       break;

  1128     y = in(1)->in(2);

  1129     if (fits_in_int(phase->type(y), true)) {

  1130       return addP_of_X2P(phase, x, y, true);

  1131     }

  1132     break;

  1133   case Op_AddX:

  1134     x = in(1)->in(1);

  1135     y = in(1)->in(2);

  1136     if (fits_in_int(phase->type(y))) {

  1137       return addP_of_X2P(phase, x, y);

  1138     }

  1139     if (fits_in_int(phase->type(x))) {

  1140       return addP_of_X2P(phase, y, x);

  1141     }

  1142     break;

  1143   }

  1144   return NULL;

  1145 }

  1146 

  1147 //------------------------------Identity---------------------------------------

  1148 Node *CastX2PNode::Identity( PhaseTransform *phase ) {

  1149   if (in(1)->Opcode() == Op_CastP2X)  return in(1)->in(1);

  1150   return this;

  1151 }

  1152 

  1153 //=============================================================================

  1154 //------------------------------Value------------------------------------------

  1155 const Type *CastP2XNode::Value( PhaseTransform *phase ) const {

  1156   const Type* t = phase->type(in(1));

  1157   if (t == Type::TOP) return Type::TOP;

  1158   if (t->base() == Type::RawPtr && t->singleton()) {

  1159     uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con();

  1160     return TypeX::make(bits);

  1161   }

  1162   return CastP2XNode::bottom_type();

  1163 }

  1164 

  1165 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) {

  1166   return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;

  1167 }

  1168 

  1169 //------------------------------Identity---------------------------------------

  1170 Node *CastP2XNode::Identity( PhaseTransform *phase ) {

  1171   if (in(1)->Opcode() == Op_CastX2P)  return in(1)->in(1);

  1172   return this;

  1173 }

  1174 

  1175 

  1176 //=============================================================================

  1177 //------------------------------Identity---------------------------------------

  1178 // Remove redundant roundings

  1179 Node *RoundFloatNode::Identity( PhaseTransform *phase ) {

  1180   assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");

  1181   // Do not round constants

  1182   if (phase->type(in(1))->base() == Type::FloatCon)  return in(1);

  1183   int op = in(1)->Opcode();

  1184   // Redundant rounding

  1185   if( op == Op_RoundFloat ) return in(1);

  1186   // Already rounded

  1187   if( op == Op_Parm ) return in(1);

  1188   if( op == Op_LoadF ) return in(1);

  1189   return this;

  1190 }

  1191 

  1192 //------------------------------Value------------------------------------------

  1193 const Type *RoundFloatNode::Value( PhaseTransform *phase ) const {

  1194   return phase->type( in(1) );

  1195 }

  1196 

  1197 //=============================================================================

  1198 //------------------------------Identity---------------------------------------