1 /*
   2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "opto/addnode.hpp"
  27 #include "opto/callnode.hpp"
  28 #include "opto/castnode.hpp"
  29 #include "opto/connode.hpp"
  30 #include "opto/graphKit.hpp"
  31 #include "opto/matcher.hpp"
  32 #include "opto/phaseX.hpp"
  33 #include "opto/rootnode.hpp"
  34 #include "opto/subnode.hpp"
  35 #include "opto/type.hpp"
  36 #include "opto/valuetypenode.hpp"
  37 
  38 //=============================================================================
  39 // If input is already higher or equal to cast type, then this is an identity.
  40 Node* ConstraintCastNode::Identity(PhaseGVN* phase) {
  41   Node* dom = dominating_cast(phase, phase);
  42   if (dom != NULL) {
  43     return dom;
  44   }
  45   if (_carry_dependency) {
  46     return this;
  47   }
  48   return phase->type(in(1))->higher_equal_speculative(_type) ? in(1) : this;
  49 }
  50 
  51 //------------------------------Value------------------------------------------
  52 // Take 'join' of input and cast-up type
  53 const Type* ConstraintCastNode::Value(PhaseGVN* phase) const {
  54   if (in(0) && phase->type(in(0)) == Type::TOP) return Type::TOP;
  55   const Type* ft = phase->type(in(1))->filter_speculative(_type);
  56 
  57 #ifdef ASSERT
  58   // Previous versions of this function had some special case logic,
  59   // which is no longer necessary.  Make sure of the required effects.
  60   switch (Opcode()) {
  61     case Op_CastII:
  62     {
  63       const Type* t1 = phase->type(in(1));
  64       if( t1 == Type::TOP )  assert(ft == Type::TOP, "special case #1");
  65       const Type* rt = t1->join_speculative(_type);
  66       if (rt->empty())       assert(ft == Type::TOP, "special case #2");
  67       break;
  68     }
  69     case Op_CastPP:
  70     if (phase->type(in(1)) == TypePtr::NULL_PTR &&
  71         _type->isa_ptr() && _type->is_ptr()->_ptr == TypePtr::NotNull)
  72     assert(ft == Type::TOP, "special case #3");
  73     break;
  74   }
  75 #endif //ASSERT
  76 
  77   return ft;
  78 }
  79 
  80 //------------------------------Ideal------------------------------------------
  81 // Return a node which is more "ideal" than the current node.  Strip out
  82 // control copies
  83 Node *ConstraintCastNode::Ideal(PhaseGVN *phase, bool can_reshape) {
  84   return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
  85 }
  86 
  87 bool ConstraintCastNode::cmp(const Node &n) const {
  88   return TypeNode::cmp(n) && ((ConstraintCastNode&)n)._carry_dependency == _carry_dependency;
  89 }
  90 
  91 uint ConstraintCastNode::size_of() const {
  92   return sizeof(*this);
  93 }
  94 
  95 Node* ConstraintCastNode::make_cast(int opcode, Node* c, Node *n, const Type *t, bool carry_dependency) {
  96   switch(opcode) {
  97   case Op_CastII: {
  98     Node* cast = new CastIINode(n, t, carry_dependency);
  99     cast->set_req(0, c);
 100     return cast;
 101   }
 102   case Op_CastPP: {
 103     Node* cast = new CastPPNode(n, t, carry_dependency);
 104     cast->set_req(0, c);
 105     return cast;
 106   }
 107   case Op_CheckCastPP: return new CheckCastPPNode(c, n, t, carry_dependency);
 108   default:
 109     fatal("Bad opcode %d", opcode);
 110   }
 111   return NULL;
 112 }
 113 
 114 TypeNode* ConstraintCastNode::dominating_cast(PhaseGVN* gvn, PhaseTransform* pt) const {
 115   Node* val = in(1);
 116   Node* ctl = in(0);
 117   int opc = Opcode();
 118   if (ctl == NULL) {
 119     return NULL;
 120   }
 121   // Range check CastIIs may all end up under a single range check and
 122   // in that case only the narrower CastII would be kept by the code
 123   // below which would be incorrect.
 124   if (is_CastII() && as_CastII()->has_range_check()) {
 125     return NULL;
 126   }
 127   if (type()->isa_rawptr() && (gvn->type_or_null(val) == NULL || gvn->type(val)->isa_oopptr())) {
 128     return NULL;
 129   }
 130   for (DUIterator_Fast imax, i = val->fast_outs(imax); i < imax; i++) {
 131     Node* u = val->fast_out(i);
 132     if (u != this &&
 133         u->outcnt() > 0 &&
 134         u->Opcode() == opc &&
 135         u->in(0) != NULL &&
 136         u->bottom_type()->higher_equal(type())) {
 137       if (pt->is_dominator(u->in(0), ctl)) {
 138         return u->as_Type();
 139       }
 140       if (is_CheckCastPP() && u->in(1)->is_Proj() && u->in(1)->in(0)->is_Allocate() &&
 141           u->in(0)->is_Proj() && u->in(0)->in(0)->is_Initialize() &&
 142           u->in(1)->in(0)->as_Allocate()->initialization() == u->in(0)->in(0)) {
 143         // CheckCastPP following an allocation always dominates all
 144         // use of the allocation result
 145         return u->as_Type();
 146       }
 147     }
 148   }
 149   return NULL;
 150 }
 151 
 152 #ifndef PRODUCT
 153 void ConstraintCastNode::dump_spec(outputStream *st) const {
 154   TypeNode::dump_spec(st);
 155   if (_carry_dependency) {
 156     st->print(" carry dependency");
 157   }
 158 }
 159 #endif
 160 
 161 const Type* CastIINode::Value(PhaseGVN* phase) const {
 162   const Type *res = ConstraintCastNode::Value(phase);
 163 
 164   // Try to improve the type of the CastII if we recognize a CmpI/If
 165   // pattern.
 166   if (_carry_dependency) {
 167     if (in(0) != NULL && in(0)->in(0) != NULL && in(0)->in(0)->is_If()) {
 168       assert(in(0)->is_IfFalse() || in(0)->is_IfTrue(), "should be If proj");
 169       Node* proj = in(0);
 170       if (proj->in(0)->in(1)->is_Bool()) {
 171         Node* b = proj->in(0)->in(1);
 172         if (b->in(1)->Opcode() == Op_CmpI) {
 173           Node* cmp = b->in(1);
 174           if (cmp->in(1) == in(1) && phase->type(cmp->in(2))->isa_int()) {
 175             const TypeInt* in2_t = phase->type(cmp->in(2))->is_int();
 176             const Type* t = TypeInt::INT;
 177             BoolTest test = b->as_Bool()->_test;
 178             if (proj->is_IfFalse()) {
 179               test = test.negate();
 180             }
 181             BoolTest::mask m = test._test;
 182             jlong lo_long = min_jint;
 183             jlong hi_long = max_jint;
 184             if (m == BoolTest::le || m == BoolTest::lt) {
 185               hi_long = in2_t->_hi;
 186               if (m == BoolTest::lt) {
 187                 hi_long -= 1;
 188               }
 189             } else if (m == BoolTest::ge || m == BoolTest::gt) {
 190               lo_long = in2_t->_lo;
 191               if (m == BoolTest::gt) {
 192                 lo_long += 1;
 193               }
 194             } else if (m == BoolTest::eq) {
 195               lo_long = in2_t->_lo;
 196               hi_long = in2_t->_hi;
 197             } else if (m == BoolTest::ne) {
 198               // can't do any better
 199             } else {
 200               stringStream ss;
 201               test.dump_on(&ss);
 202               fatal("unexpected comparison %s", ss.as_string());
 203             }
 204             int lo_int = (int)lo_long;
 205             int hi_int = (int)hi_long;
 206 
 207             if (lo_long != (jlong)lo_int) {
 208               lo_int = min_jint;
 209             }
 210             if (hi_long != (jlong)hi_int) {
 211               hi_int = max_jint;
 212             }
 213 
 214             t = TypeInt::make(lo_int, hi_int, Type::WidenMax);
 215 
 216             res = res->filter_speculative(t);
 217 
 218             return res;
 219           }
 220         }
 221       }
 222     }
 223   }
 224   return res;
 225 }
 226 
 227 Node *CastIINode::Ideal(PhaseGVN *phase, bool can_reshape) {
 228   Node* progress = ConstraintCastNode::Ideal(phase, can_reshape);
 229   if (progress != NULL) {
 230     return progress;
 231   }
 232 
 233   // Similar to ConvI2LNode::Ideal() for the same reasons
 234   // Do not narrow the type of range check dependent CastIINodes to
 235   // avoid corruption of the graph if a CastII is replaced by TOP but
 236   // the corresponding range check is not removed.
 237   if (can_reshape && !_range_check_dependency && !phase->C->major_progress()) {
 238     const TypeInt* this_type = this->type()->is_int();
 239     const TypeInt* in_type = phase->type(in(1))->isa_int();
 240     if (in_type != NULL && this_type != NULL &&
 241         (in_type->_lo != this_type->_lo ||
 242          in_type->_hi != this_type->_hi)) {
 243       jint lo1 = this_type->_lo;
 244       jint hi1 = this_type->_hi;
 245       int w1  = this_type->_widen;
 246 
 247       if (lo1 >= 0) {
 248         // Keep a range assertion of >=0.
 249         lo1 = 0;        hi1 = max_jint;
 250       } else if (hi1 < 0) {
 251         // Keep a range assertion of <0.
 252         lo1 = min_jint; hi1 = -1;
 253       } else {
 254         lo1 = min_jint; hi1 = max_jint;
 255       }
 256       const TypeInt* wtype = TypeInt::make(MAX2(in_type->_lo, lo1),
 257                                            MIN2(in_type->_hi, hi1),
 258                                            MAX2((int)in_type->_widen, w1));
 259       if (wtype != type()) {
 260         set_type(wtype);
 261         return this;
 262       }
 263     }
 264   }
 265   return NULL;
 266 }
 267 
 268 bool CastIINode::cmp(const Node &n) const {
 269   return ConstraintCastNode::cmp(n) && ((CastIINode&)n)._range_check_dependency == _range_check_dependency;
 270 }
 271 
 272 uint CastIINode::size_of() const {
 273   return sizeof(*this);
 274 }
 275 
 276 #ifndef PRODUCT
 277 void CastIINode::dump_spec(outputStream* st) const {
 278   ConstraintCastNode::dump_spec(st);
 279   if (_range_check_dependency) {
 280     st->print(" range check dependency");
 281   }
 282 }
 283 #endif
 284 
 285 //=============================================================================
 286 //------------------------------Identity---------------------------------------
 287 // If input is already higher or equal to cast type, then this is an identity.
 288 Node* CheckCastPPNode::Identity(PhaseGVN* phase) {
 289   if (in(1)->is_ValueTypeBase() && _type->isa_oopptr() && phase->type(in(1))->value_klass()->is_subtype_of(_type->is_oopptr()->klass())) {
 290     return in(1);
 291   }
 292   Node* dom = dominating_cast(phase, phase);
 293   if (dom != NULL) {
 294     return dom;
 295   }
 296   if (_carry_dependency) {
 297     return this;
 298   }
 299   // Toned down to rescue meeting at a Phi 3 different oops all implementing
 300   // the same interface.
 301   return (phase->type(in(1)) == phase->type(this)) ? in(1) : this;
 302 }
 303 
 304 //------------------------------Value------------------------------------------
 305 // Take 'join' of input and cast-up type, unless working with an Interface
 306 const Type* CheckCastPPNode::Value(PhaseGVN* phase) const {
 307   if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
 308 
 309   const Type *inn = phase->type(in(1));
 310   if( inn == Type::TOP ) return Type::TOP;  // No information yet
 311 
 312   const TypePtr *in_type   = inn->isa_ptr();
 313   const TypePtr *my_type   = _type->isa_ptr();
 314   const Type *result = _type;
 315   if( in_type != NULL && my_type != NULL ) {
 316     TypePtr::PTR   in_ptr    = in_type->ptr();
 317     if (in_ptr == TypePtr::Null) {
 318       result = in_type;
 319     } else if (in_ptr == TypePtr::Constant) {
 320       if (my_type->isa_rawptr()) {
 321         result = my_type;
 322       } else {
 323         const TypeOopPtr *jptr = my_type->isa_oopptr();
 324         assert(jptr, "");
 325         result = !in_type->higher_equal(_type)
 326           ? my_type->cast_to_ptr_type(TypePtr::NotNull)
 327           : in_type;
 328       }
 329     } else {
 330       result =  my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) );
 331     }
 332   }
 333 
 334   // This is the code from TypePtr::xmeet() that prevents us from
 335   // having 2 ways to represent the same type. We have to replicate it
 336   // here because we don't go through meet/join.
 337   if (result->remove_speculative() == result->speculative()) {
 338     result = result->remove_speculative();
 339   }
 340 
 341   // Same as above: because we don't go through meet/join, remove the
 342   // speculative type if we know we won't use it.
 343   return result->cleanup_speculative();
 344 
 345   // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES.
 346   // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR!
 347 
 348   //
 349   // Remove this code after overnight run indicates no performance
 350   // loss from not performing JOIN at CheckCastPPNode
 351   //
 352   // const TypeInstPtr *in_oop = in->isa_instptr();
 353   // const TypeInstPtr *my_oop = _type->isa_instptr();
 354   // // If either input is an 'interface', return destination type
 355   // assert (in_oop == NULL || in_oop->klass() != NULL, "");
 356   // assert (my_oop == NULL || my_oop->klass() != NULL, "");
 357   // if( (in_oop && in_oop->klass()->is_interface())
 358   //   ||(my_oop && my_oop->klass()->is_interface()) ) {
 359   //   TypePtr::PTR  in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR;
 360   //   // Preserve cast away nullness for interfaces
 361   //   if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) {
 362   //     return my_oop->cast_to_ptr_type(TypePtr::NotNull);
 363   //   }
 364   //   return _type;
 365   // }
 366   //
 367   // // Neither the input nor the destination type is an interface,
 368   //
 369   // // history: JOIN used to cause weird corner case bugs
 370   // //          return (in == TypeOopPtr::NULL_PTR) ? in : _type;
 371   // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops.
 372   // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr
 373   // const Type *join = in->join(_type);
 374   // // Check if join preserved NotNull'ness for pointers
 375   // if( join->isa_ptr() && _type->isa_ptr() ) {
 376   //   TypePtr::PTR join_ptr = join->is_ptr()->_ptr;
 377   //   TypePtr::PTR type_ptr = _type->is_ptr()->_ptr;
 378   //   // If there isn't any NotNull'ness to preserve
 379   //   // OR if join preserved NotNull'ness then return it
 380   //   if( type_ptr == TypePtr::BotPTR  || type_ptr == TypePtr::Null ||
 381   //       join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) {
 382   //     return join;
 383   //   }
 384   //   // ELSE return same old type as before
 385   //   return _type;
 386   // }
 387   // // Not joining two pointers
 388   // return join;
 389 }
 390 
 391 //=============================================================================
 392 //------------------------------Value------------------------------------------
 393 const Type* CastX2PNode::Value(PhaseGVN* phase) const {
 394   const Type* t = phase->type(in(1));
 395   if (t == Type::TOP) return Type::TOP;
 396   if (t->base() == Type_X && t->singleton()) {
 397     uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con();
 398     if (bits == 0)   return TypePtr::NULL_PTR;
 399     return TypeRawPtr::make((address) bits);
 400   }
 401   return CastX2PNode::bottom_type();
 402 }
 403 
 404 //------------------------------Idealize---------------------------------------
 405 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) {
 406   if (t == Type::TOP)  return false;
 407   const TypeX* tl = t->is_intptr_t();
 408   jint lo = min_jint;
 409   jint hi = max_jint;
 410   if (but_not_min_int)  ++lo;  // caller wants to negate the value w/o overflow
 411   return (tl->_lo >= lo) && (tl->_hi <= hi);
 412 }
 413 
 414 static inline Node* addP_of_X2P(PhaseGVN *phase,
 415                                 Node* base,
 416                                 Node* dispX,
 417                                 bool negate = false) {
 418   if (negate) {
 419     dispX = phase->transform(new SubXNode(phase->MakeConX(0), dispX));
 420   }
 421   return new AddPNode(phase->C->top(),
 422                       phase->transform(new CastX2PNode(base)),
 423                       dispX);
 424 }
 425 
 426 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 427   // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int
 428   int op = in(1)->Opcode();
 429   Node* x;
 430   Node* y;
 431   switch (op) {
 432     case Op_SubX:
 433     x = in(1)->in(1);
 434     // Avoid ideal transformations ping-pong between this and AddP for raw pointers.
 435     if (phase->find_intptr_t_con(x, -1) == 0)
 436     break;
 437     y = in(1)->in(2);
 438     if (fits_in_int(phase->type(y), true)) {
 439       return addP_of_X2P(phase, x, y, true);
 440     }
 441     break;
 442     case Op_AddX:
 443     x = in(1)->in(1);
 444     y = in(1)->in(2);
 445     if (fits_in_int(phase->type(y))) {
 446       return addP_of_X2P(phase, x, y);
 447     }
 448     if (fits_in_int(phase->type(x))) {
 449       return addP_of_X2P(phase, y, x);
 450     }
 451     break;
 452   }
 453   return NULL;
 454 }
 455 
 456 //------------------------------Identity---------------------------------------
 457 Node* CastX2PNode::Identity(PhaseGVN* phase) {
 458   if (in(1)->Opcode() == Op_CastP2X)  return in(1)->in(1);
 459   return this;
 460 }
 461 
 462 //=============================================================================
 463 //------------------------------Value------------------------------------------
 464 const Type* CastP2XNode::Value(PhaseGVN* phase) const {
 465   const Type* t = phase->type(in(1));
 466   if (t == Type::TOP) return Type::TOP;
 467   if (t->base() == Type::RawPtr && t->singleton()) {
 468     uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con();
 469     return TypeX::make(bits);
 470   }
 471 
 472   if (t->is_zero_type() || !t->maybe_null()) {
 473     for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) {
 474       Node* u = fast_out(i);
 475       if (u->Opcode() == Op_OrL) {
 476         for (DUIterator_Fast jmax, j = u->fast_outs(jmax); j < jmax; j++) {
 477           Node* cmp = u->fast_out(j);
 478           if (cmp->Opcode() == Op_CmpL) {
 479             // Give CmpL a chance to get optimized
 480             phase->record_for_igvn(cmp);
 481           }
 482         }
 483       }
 484     }
 485   }
 486 
 487   return CastP2XNode::bottom_type();
 488 }
 489 
 490 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 491   return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
 492 }
 493 
 494 //------------------------------Identity---------------------------------------
 495 Node* CastP2XNode::Identity(PhaseGVN* phase) {
 496   if (in(1)->Opcode() == Op_CastX2P)  return in(1)->in(1);
 497   return this;
 498 }