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