jdk8-mips64-public/hotspot: comparison src/share/vm/opto/type.cpp

-:de141433919f
+:9c2ecc2ffb12
 //------------------------------meet-------------------------------------------
 // Compute the MEET of two types.  NOT virtual.  It enforces that meet is
 // commutative and the lattice is symmetric.
 const Type *Type::meet( const Type *t ) const {
 if (isa_narrowoop() && t->isa_narrowoop()) {
-const Type* result = is_narrowoop()->make_oopptr()->meet(t->is_narrowoop()->make_oopptr());
+const Type* result = make_ptr()->meet(t->make_ptr());
-if (result->isa_oopptr()) {
+return result->make_narrowoop();
-return result->isa_oopptr()->make_narrowoop();
-} else if (result == TypePtr::NULL_PTR) {
-return TypeNarrowOop::NULL_PTR;
-} else {
-return result;
-}
 }
 const Type *mt = xmeet(t);
 if (isa_narrowoop() || t->isa_narrowoop()) return mt;
 #ifdef ASSERT
 if( this_inst && this_inst->is_loaded() && t_inst && t_inst->is_loaded() ) {
 bool this_interface = this_inst->klass()->is_interface();
 bool    t_interface =    t_inst->klass()->is_interface();
 interface_vs_oop = this_interface ^ t_interface;
 }
-const Type *tdual = t->_dual;
-const Type *thisdual = _dual;
+if( !interface_vs_oop && (t2t != t->_dual || t2this != _dual) ) {
-// strip out instances
-if (t2t->isa_oopptr() != NULL) {
-t2t = t2t->isa_oopptr()->cast_to_instance(TypeOopPtr::UNKNOWN_INSTANCE);
-}
-if (t2this->isa_oopptr() != NULL) {
-t2this = t2this->isa_oopptr()->cast_to_instance(TypeOopPtr::UNKNOWN_INSTANCE);
-}
-if (tdual->isa_oopptr() != NULL) {
-tdual = tdual->isa_oopptr()->cast_to_instance(TypeOopPtr::UNKNOWN_INSTANCE);
-}
-if (thisdual->isa_oopptr() != NULL) {
-thisdual = thisdual->isa_oopptr()->cast_to_instance(TypeOopPtr::UNKNOWN_INSTANCE);
-}
-if( !interface_vs_oop && (t2t != tdual || t2this != thisdual) ) {
 tty->print_cr("=== Meet Not Symmetric ===");
 tty->print("t   =                   ");         t->dump(); tty->cr();
 tty->print("this=                   ");            dump(); tty->cr();
 tty->print("mt=(t meet this)=       ");        mt->dump(); tty->cr();
 }
 //------------------------------make-------------------------------------------
 const TypeAry *TypeAry::make( const Type *elem, const TypeInt *size) {
 if (UseCompressedOops && elem->isa_oopptr()) {
-elem = elem->is_oopptr()->make_narrowoop();
+elem = elem->make_narrowoop();
 }
 size = normalize_array_size(size);
 return (TypeAry*)(new TypeAry(elem,size))->hashcons();
 }
 // if the element type is either a primitive or a final instance class.
 // In such cases, an array built on this ary must have no subclasses.
 if (_elem == BOTTOM)      return false;  // general array not exact
 if (_elem == TOP   )      return false;  // inverted general array not exact
 const TypeOopPtr*  toop = NULL;
-if (UseCompressedOops) {
+if (UseCompressedOops && _elem->isa_narrowoop()) {
-const TypeNarrowOop* noop = _elem->isa_narrowoop();
+toop = _elem->make_ptr()->isa_oopptr();
-if (noop) toop = noop->make_oopptr()->isa_oopptr();
 } else {
 toop = _elem->isa_oopptr();
 }
 if (!toop)                return true;   // a primitive type, like int
 ciKlass* tklass = toop->klass();
 if (tklass == NULL)       return false;  // unloaded class
 if (!tklass->is_loaded()) return false;  // unloaded class
 const TypeInstPtr* tinst;
 if (_elem->isa_narrowoop())
-tinst = _elem->is_narrowoop()->make_oopptr()->isa_instptr();
+tinst = _elem->make_ptr()->isa_instptr();
 else
 tinst = _elem->isa_instptr();
-if (tinst)                return tklass->as_instance_klass()->is_final();
+if (tinst)
+return tklass->as_instance_klass()->is_final();
 const TypeAryPtr*  tap;
 if (_elem->isa_narrowoop())
-tap = _elem->is_narrowoop()->make_oopptr()->isa_aryptr();
+tap = _elem->make_ptr()->isa_aryptr();
 else
 tap = _elem->isa_aryptr();
-if (tap)                  return tap->ary()->ary_must_be_exact();
+if (tap)
+return tap->ary()->ary_must_be_exact();
 return false;
 }
 //=============================================================================
 // Convenience common pre-built types.
 int offset) {
 assert(ptr != Constant, "no constant generic pointers");
 ciKlass*  k = ciKlassKlass::make();
 bool      xk = false;
 ciObject* o = NULL;
-return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, UNKNOWN_INSTANCE))->hashcons();
+return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, InstanceBot))->hashcons();
 }
 //------------------------------cast_to_ptr_type-------------------------------
 const Type *TypeOopPtr::cast_to_ptr_type(PTR ptr) const {
 if( ptr == _ptr ) return this;
 return make(ptr, _offset);
 }
 //-----------------------------cast_to_instance-------------------------------
-const TypeOopPtr *TypeOopPtr::cast_to_instance(int instance_id) const {
+const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const {
 // There are no instances of a general oop.
 // Return self unchanged.
 return this;
 }
 //------------------------------xdual------------------------------------------
 // Dual of a pure heap pointer.  No relevant klass or oop information.
 const Type *TypeOopPtr::xdual() const {
 assert(klass() == ciKlassKlass::make(), "no klasses here");
 assert(const_oop() == NULL,             "no constants here");
-return new TypeOopPtr(_base, dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance()  );
+return new TypeOopPtr(_base, dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id()  );
 }
 //--------------------------make_from_klass_common-----------------------------
 // Computes the element-type given a klass.
 const TypeOopPtr* TypeOopPtr::make_from_klass_common(ciKlass *klass, bool klass_change, bool try_for_exact) {
 case OffsetTop: st->print("+top"); break;
 case OffsetBot: st->print("+any"); break;
 case         0: break;
 default:        st->print("+%d",_offset); break;
 }
-if (_instance_id != UNKNOWN_INSTANCE)
+if (_instance_id == InstanceTop)
+st->print(",iid=top");
+else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
 }
 #endif
 //------------------------------singleton--------------------------------------
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeOopPtr::add_offset( int offset ) const {
 return make( _ptr, xadd_offset(offset) );
 }
-const TypeNarrowOop* TypeOopPtr::make_narrowoop() const {
+//------------------------------meet_instance_id--------------------------------
-return TypeNarrowOop::make(this);
+int TypeOopPtr::meet_instance_id( int instance_id ) const {
-}
+// Either is 'TOP' instance?  Return the other instance!
+if( _instance_id == InstanceTop ) return  instance_id;
-int TypeOopPtr::meet_instance(int iid) const {
+if(  instance_id == InstanceTop ) return _instance_id;
-if (iid == 0) {
+// If either is different, return 'BOTTOM' instance
-return (_instance_id < 0)  ? _instance_id : UNKNOWN_INSTANCE;
+if( _instance_id != instance_id ) return InstanceBot;
-} else if (_instance_id == UNKNOWN_INSTANCE) {
+return _instance_id;
-return (iid < 0)  ? iid : UNKNOWN_INSTANCE;
+}
-} else {
-return (_instance_id == iid) ? iid : UNKNOWN_INSTANCE;
+//------------------------------dual_instance_id--------------------------------
-}
+int TypeOopPtr::dual_instance_id( ) const {
-}
+if( _instance_id == InstanceTop ) return InstanceBot; // Map TOP into BOTTOM
+if( _instance_id == InstanceBot ) return InstanceTop; // Map BOTTOM into TOP
+return _instance_id;              // Map everything else into self
+}
 //=============================================================================
 // Convenience common pre-built types.
 const TypeInstPtr *TypeInstPtr::NOTNULL;
 const TypeInstPtr *TypeInstPtr::BOTTOM;
 assert( (!o && ptr != Constant) || (o && ptr == Constant),
 "constant pointers must have a value supplied" );
 // Ptr is never Null
 assert( ptr != Null, "NULL pointers are not typed" );
-if (instance_id != UNKNOWN_INSTANCE)
+if ( instance_id > 0 )
 xk = true;  // instances are always exactly typed
 if (!UseExactTypes)  xk = false;
 if (ptr == Constant) {
 // Note:  This case includes meta-object constants, such as methods.
 xk = true;
 //------------------------------cast_to_ptr_type-------------------------------
 const Type *TypeInstPtr::cast_to_ptr_type(PTR ptr) const {
 if( ptr == _ptr ) return this;
 // Reconstruct _sig info here since not a problem with later lazy
 // construction, _sig will show up on demand.
-return make(ptr, klass(), klass_is_exact(), const_oop(), _offset);
+return make(ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id);
 }
 //-----------------------------cast_to_exactness-------------------------------
 const Type *TypeInstPtr::cast_to_exactness(bool klass_is_exact) const {
 if( ik->is_interface() )              return this;  // cannot set xk
 return make(ptr(), klass(), klass_is_exact, const_oop(), _offset, _instance_id);
 }
 //-----------------------------cast_to_instance-------------------------------
-const TypeOopPtr *TypeInstPtr::cast_to_instance(int instance_id) const {
+const TypeOopPtr *TypeInstPtr::cast_to_instance_id(int instance_id) const {
-if( instance_id == _instance_id) return this;
+if( instance_id == _instance_id ) return this;
-bool exact = true;
+bool exact = _klass_is_exact;
-PTR  ptr_t = NotNull;
+PTR  ptr_t = _ptr;
-if (instance_id == UNKNOWN_INSTANCE) {
+if ( instance_id > 0 ) { // instances are always exactly typed
-exact = _klass_is_exact;
+if (UseExactTypes) exact = true;
-ptr_t = _ptr;
+ptr_t = NotNull;
 }
 return make(ptr_t, klass(), exact, const_oop(), _offset, instance_id);
 }
 //------------------------------xmeet_unloaded---------------------------------
 case AryPtr: {                // All arrays inherit from Object class
 const TypeAryPtr *tp = t->is_aryptr();
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
-int iid = meet_instance(tp->instance_id());
+int instance_id = meet_instance_id(tp->instance_id());
 switch (ptr) {
 case TopPTR:
 case AnyNull:                // Fall 'down' to dual of object klass
 if (klass()->equals(ciEnv::current()->Object_klass())) {
-return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, iid);
+return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id);
 } else {
 // cannot subclass, so the meet has to fall badly below the centerline
 ptr = NotNull;
-return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, iid);
+instance_id = InstanceBot;
+return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id);
 }
 case Constant:
 case NotNull:
 case BotPTR:                // Fall down to object klass
 // LCA is object_klass, but if we subclass from the top we can do better
 if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull )
 // If 'this' (InstPtr) is above the centerline and it is Object class
 // then we can subclass in the Java class heirarchy.
 if (klass()->equals(ciEnv::current()->Object_klass())) {
 // that is, tp's array type is a subtype of my klass
-return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, iid);
+return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id);
 }
 }
 // The other case cannot happen, since I cannot be a subtype of an array.
 // The meet falls down to Object class below centerline.
 if( ptr == Constant )
 ptr = NotNull;
-return make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, iid );
+instance_id = InstanceBot;
+return make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id );
 default: typerr(t);
 }
 }
 case OopPtr: {                // Meeting to OopPtrs
 const TypePtr *tp = t->is_oopptr();
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case TopPTR:
-case AnyNull:
+case AnyNull: {
+int instance_id = meet_instance_id(InstanceTop);
 return make(ptr, klass(), klass_is_exact(),
-(ptr == Constant ? const_oop() : NULL), offset);
+(ptr == Constant ? const_oop() : NULL), offset, instance_id);
+}
 case NotNull:
 case BotPTR:
 return TypeOopPtr::make(ptr, offset);
 default: typerr(t);
 }
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case Null:
 if( ptr == Null ) return TypePtr::make( AnyPtr, ptr, offset );
+// else fall through to AnyNull
 case TopPTR:
-case AnyNull:
+case AnyNull: {
+int instance_id = meet_instance_id(InstanceTop);
 return make( ptr, klass(), klass_is_exact(),
-(ptr == Constant ? const_oop() : NULL), offset );
+(ptr == Constant ? const_oop() : NULL), offset, instance_id);
+}
 case NotNull:
 case BotPTR:
 return TypePtr::make( AnyPtr, ptr, offset );
 default: typerr(t);
 }
 case InstPtr: {                // Meeting 2 Oops?
 // Found an InstPtr sub-type vs self-InstPtr type
 const TypeInstPtr *tinst = t->is_instptr();
 int off = meet_offset( tinst->offset() );
 PTR ptr = meet_ptr( tinst->ptr() );
-int instance_id = meet_instance(tinst->instance_id());
+int instance_id = meet_instance_id(tinst->instance_id());
 // Check for easy case; klasses are equal (and perhaps not loaded!)
 // If we have constants, then we created oops so classes are loaded
 // and we can handle the constants further down.  This case handles
 // both-not-loaded or both-loaded classes
 ciObject* o = NULL;  // the Constant value, if any
 if (ptr == Constant) {
 // Find out which constant.
 o = (this_klass == klass()) ? const_oop() : tinst->const_oop();
 }
-return make( ptr, k, xk, o, off );
+return make( ptr, k, xk, o, off, instance_id );
 }
 // Either oop vs oop or interface vs interface or interface vs Object
 // !!! Here's how the symmetry requirement breaks down into invariants:
 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant )
 ptr = NotNull;
 // Now we find the LCA of Java classes
 ciKlass* k = this_klass->least_common_ancestor(tinst_klass);
-return make( ptr, k, false, NULL, off );
+return make( ptr, k, false, NULL, off, instance_id );
 } // End of case InstPtr
 case KlassPtr:
 return TypeInstPtr::BOTTOM;
 //------------------------------xdual------------------------------------------
 // Dual: do NOT dual on klasses.  This means I do NOT understand the Java
 // inheritence mechanism.
 const Type *TypeInstPtr::xdual() const {
-return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance()  );
+return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id()  );
 }
 //------------------------------eq---------------------------------------------
 // Structural equality check for Type representations
 bool TypeInstPtr::eq( const Type *t ) const {
 else if( _offset == OffsetTop ) st->print("+unknown");
 else st->print("+%d", _offset);
 }
 st->print(" *");
-if (_instance_id != UNKNOWN_INSTANCE)
+if (_instance_id == InstanceTop)
+st->print(",iid=top");
+else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
 }
 #endif
 //------------------------------add_offset-------------------------------------
 //------------------------------make-------------------------------------------
 const TypeAryPtr *TypeAryPtr::make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) {
 assert(!(k == NULL && ary->_elem->isa_int()),
 "integral arrays must be pre-equipped with a class");
 if (!xk)  xk = ary->ary_must_be_exact();
-if (instance_id != UNKNOWN_INSTANCE)
+if ( instance_id > 0 )
 xk = true;  // instances are always exactly typed
 if (!UseExactTypes)  xk = (ptr == Constant);
 return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id))->hashcons();
 }
 const TypeAryPtr *TypeAryPtr::make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) {
 assert(!(k == NULL && ary->_elem->isa_int()),
 "integral arrays must be pre-equipped with a class");
 assert( (ptr==Constant && o) || (ptr!=Constant && !o), "" );
 if (!xk)  xk = (o != NULL) || ary->ary_must_be_exact();
-if (instance_id != UNKNOWN_INSTANCE)
+if ( instance_id > 0 )
 xk = true;  // instances are always exactly typed
 if (!UseExactTypes)  xk = (ptr == Constant);
 return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id))->hashcons();
 }
 //------------------------------cast_to_ptr_type-------------------------------
 const Type *TypeAryPtr::cast_to_ptr_type(PTR ptr) const {
 if( ptr == _ptr ) return this;
-return make(ptr, const_oop(), _ary, klass(), klass_is_exact(), _offset);
+return make(ptr, const_oop(), _ary, klass(), klass_is_exact(), _offset, _instance_id);
 }
 //-----------------------------cast_to_exactness-------------------------------
 const Type *TypeAryPtr::cast_to_exactness(bool klass_is_exact) const {
 if (_ary->ary_must_be_exact())  return this;  // cannot clear xk
 return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _instance_id);
 }
 //-----------------------------cast_to_instance-------------------------------
-const TypeOopPtr *TypeAryPtr::cast_to_instance(int instance_id) const {
+const TypeOopPtr *TypeAryPtr::cast_to_instance_id(int instance_id) const {
-if( instance_id == _instance_id) return this;
+if( instance_id == _instance_id ) return this;
-bool exact = true;
+bool exact = _klass_is_exact;
-PTR  ptr_t = NotNull;
+PTR  ptr_t = _ptr;
-if (instance_id == UNKNOWN_INSTANCE) {
+if ( instance_id > 0 ) { // instances are always exactly typed
-exact = _klass_is_exact;
+if (UseExactTypes) exact = true;
-ptr_t = _ptr;
+ptr_t = NotNull;
 }
 return make(ptr_t, const_oop(), _ary, klass(), exact, _offset, instance_id);
 }
 //-----------------------------narrow_size_type-------------------------------
 new_size = narrow_size_type(new_size, elem()->basic_type());
 if (new_size == NULL)       // Negative length arrays will produce weird
 new_size = TypeInt::ZERO; // intermediate dead fast-path goo
 if (new_size == size())  return this;
 const TypeAry* new_ary = TypeAry::make(elem(), new_size);
-return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset);
+return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id);
 }
 //------------------------------eq---------------------------------------------
 // Structural equality check for Type representations
 const TypePtr *tp = t->is_oopptr();
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case TopPTR:
-case AnyNull:
+case AnyNull: {
-return make(ptr, (ptr == Constant ? const_oop() : NULL), _ary, _klass, _klass_is_exact, offset);
+int instance_id = meet_instance_id(InstanceTop);
+return make(ptr, (ptr == Constant ? const_oop() : NULL),
+_ary, _klass, _klass_is_exact, offset, instance_id);
+}
 case BotPTR:
 case NotNull:
 return TypeOopPtr::make(ptr, offset);
 default: ShouldNotReachHere();
 }
 case BotPTR:
 case NotNull:
 return TypePtr::make(AnyPtr, ptr, offset);
 case Null:
 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset);
-case AnyNull:
+// else fall through to AnyNull
-return make( ptr, (ptr == Constant ? const_oop() : NULL), _ary, _klass, _klass_is_exact, offset );
+case AnyNull: {
+int instance_id = meet_instance_id(InstanceTop);
+return make( ptr, (ptr == Constant ? const_oop() : NULL),
+_ary, _klass, _klass_is_exact, offset, instance_id);
+}
 default: ShouldNotReachHere();
 }
 }
 case RawPtr: return TypePtr::BOTTOM;
 case AryPtr: {                // Meeting 2 references?
 const TypeAryPtr *tap = t->is_aryptr();
 int off = meet_offset(tap->offset());
 const TypeAry *tary = _ary->meet(tap->_ary)->is_ary();
 PTR ptr = meet_ptr(tap->ptr());
-int iid = meet_instance(tap->instance_id());
+int instance_id = meet_instance_id(tap->instance_id());
 ciKlass* lazy_klass = NULL;
 if (tary->_elem->isa_int()) {
 // Integral array element types have irrelevant lattice relations.
 // It is the klass that determines array layout, not the element type.
 if (_klass == NULL)
 switch (tap->ptr()) {
 case AnyNull:
 case TopPTR:
 // Compute new klass on demand, do not use tap->_klass
 xk = (tap->_klass_is_exact | this->_klass_is_exact);
-return make( ptr, const_oop(), tary, lazy_klass, xk, off, iid );
+return make( ptr, const_oop(), tary, lazy_klass, xk, off, instance_id );
 case Constant: {
 ciObject* o = const_oop();
 if( _ptr == Constant ) {
 if( tap->const_oop() != NULL && !o->equals(tap->const_oop()) ) {
 ptr = NotNull;
 }
 } else if( above_centerline(_ptr) ) {
 o = tap->const_oop();
 }
 xk = true;
-return TypeAryPtr::make( ptr, o, tary, tap->_klass, xk, off, iid );
+return TypeAryPtr::make( ptr, o, tary, tap->_klass, xk, off, instance_id );
 }
 case NotNull:
 case BotPTR:
 // Compute new klass on demand, do not use tap->_klass
 if (above_centerline(this->_ptr))
 xk = tap->_klass_is_exact;
 else if (above_centerline(tap->_ptr))
 xk = this->_klass_is_exact;
 else  xk = (tap->_klass_is_exact & this->_klass_is_exact) &&
 (klass() == tap->klass()); // Only precise for identical arrays
-return TypeAryPtr::make( ptr, NULL, tary, lazy_klass, xk, off, iid );
+return TypeAryPtr::make( ptr, NULL, tary, lazy_klass, xk, off, instance_id );
 default: ShouldNotReachHere();
 }
 }
 // All arrays inherit from Object class
 case InstPtr: {
 const TypeInstPtr *tp = t->is_instptr();
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
-int iid = meet_instance(tp->instance_id());
+int instance_id = meet_instance_id(tp->instance_id());
 switch (ptr) {
 case TopPTR:
 case AnyNull:                // Fall 'down' to dual of object klass
 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) {
-return TypeAryPtr::make( ptr, _ary, _klass, _klass_is_exact, offset, iid );
+return TypeAryPtr::make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id );
 } else {
 // cannot subclass, so the meet has to fall badly below the centerline
 ptr = NotNull;
-return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, iid);
+instance_id = InstanceBot;
+return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id);
 }
 case Constant:
 case NotNull:
 case BotPTR:                // Fall down to object klass
 // LCA is object_klass, but if we subclass from the top we can do better
 if (above_centerline(tp->ptr())) {
 // If 'tp'  is above the centerline and it is Object class
 // then we can subclass in the Java class heirarchy.
 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) {
 // that is, my array type is a subtype of 'tp' klass
-return make( ptr, _ary, _klass, _klass_is_exact, offset, iid );
+return make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id );
 }
 }
 // The other case cannot happen, since t cannot be a subtype of an array.
 // The meet falls down to Object class below centerline.
 if( ptr == Constant )
 ptr = NotNull;
-return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, iid);
+instance_id = InstanceBot;
+return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id);
 default: typerr(t);
 }
 }
 case KlassPtr:
 }
 //------------------------------xdual------------------------------------------
 // Dual: compute field-by-field dual
 const Type *TypeAryPtr::xdual() const {
-return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance() );
+return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id() );
 }
 //------------------------------dump2------------------------------------------
 #ifndef PRODUCT
 void TypeAryPtr::dump2( Dict &d, uint depth, outputStream *st ) const {
 int elem_size = type2aelembytes(basic_elem_type);
 st->print("[%d]", (_offset - array_base)/elem_size);
 }
 }
 st->print(" *");
-if (_instance_id != UNKNOWN_INSTANCE)
+if (_instance_id == InstanceTop)
+st->print(",iid=top");
+else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
 }
 #endif
 bool TypeAryPtr::empty(void) const {
 return Type::BOTTOM;
 case Top:
 return this;
 case NarrowOop: {
-const Type* result = _ooptype->xmeet(t->is_narrowoop()->make_oopptr());
+const Type* result = _ooptype->xmeet(t->make_ptr());
 if (result->isa_ptr()) {
 return TypeNarrowOop::make(result->is_ptr());
 }
 return result;
 }
 ciKlass* k_ary = NULL;
 const TypeInstPtr *tinst;
 const TypeAryPtr *tary;
 const Type* el = elem();
 if (el->isa_narrowoop()) {
-el = el->is_narrowoop()->make_oopptr();
+el = el->make_ptr();
 }
 // Get element klass
 if ((tinst = el->isa_instptr()) != NULL) {
 // Compute array klass from element klass

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/type.cpp

src/share/vm/opto/type.cpp