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

comparison src/share/vm/opto/type.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	484a359ff649
children	52b4284cb496

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 { Bad,             T_NARROWOOP,  "narrowoop:",    false, Op_RegN,              relocInfo::none          },  // NarrowOop
 { Bad,             T_NARROWKLASS,"narrowklass:",  false, Op_RegN,              relocInfo::none          },  // NarrowKlass
 { Bad,             T_ILLEGAL,    "tuple:",        false, Node::NotAMachineReg, relocInfo::none          },  // Tuple
 { Bad,             T_ARRAY,      "array:",        false, Node::NotAMachineReg, relocInfo::none          },  // Array
-#ifdef SPARC
+#ifndef SPARC
+{ Bad,             T_ILLEGAL,    "vectors:",      false, Op_VecS,              relocInfo::none          },  // VectorS
+{ Bad,             T_ILLEGAL,    "vectord:",      false, Op_VecD,              relocInfo::none          },  // VectorD
+{ Bad,             T_ILLEGAL,    "vectorx:",      false, Op_VecX,              relocInfo::none          },  // VectorX
+{ Bad,             T_ILLEGAL,    "vectory:",      false, Op_VecY,              relocInfo::none          },  // VectorY
+#else
 { Bad,             T_ILLEGAL,    "vectors:",      false, 0,                    relocInfo::none          },  // VectorS
 { Bad,             T_ILLEGAL,    "vectord:",      false, Op_RegD,              relocInfo::none          },  // VectorD
 { Bad,             T_ILLEGAL,    "vectorx:",      false, 0,                    relocInfo::none          },  // VectorX
 { Bad,             T_ILLEGAL,    "vectory:",      false, 0,                    relocInfo::none          },  // VectorY
-#elif defined(PPC64)
+#endif // IA32 || AMD64
-{ Bad,             T_ILLEGAL,    "vectors:",      false, 0,                    relocInfo::none          },  // VectorS
-{ Bad,             T_ILLEGAL,    "vectord:",      false, Op_RegL,              relocInfo::none          },  // VectorD
-{ Bad,             T_ILLEGAL,    "vectorx:",      false, 0,                    relocInfo::none          },  // VectorX
-{ Bad,             T_ILLEGAL,    "vectory:",      false, 0,                    relocInfo::none          },  // VectorY
-#else // all other
-{ Bad,             T_ILLEGAL,    "vectors:",      false, Op_VecS,              relocInfo::none          },  // VectorS
-{ Bad,             T_ILLEGAL,    "vectord:",      false, Op_VecD,              relocInfo::none          },  // VectorD
-{ Bad,             T_ILLEGAL,    "vectorx:",      false, Op_VecX,              relocInfo::none          },  // VectorX
-{ Bad,             T_ILLEGAL,    "vectory:",      false, Op_VecY,              relocInfo::none          },  // VectorY
-#endif
 { Bad,             T_ADDRESS,    "anyptr:",       false, Op_RegP,              relocInfo::none          },  // AnyPtr
 { Bad,             T_ADDRESS,    "rawptr:",       false, Op_RegP,              relocInfo::none          },  // RawPtr
 { Bad,             T_OBJECT,     "oop:",          true,  Op_RegP,              relocInfo::oop_type      },  // OopPtr
 { Bad,             T_OBJECT,     "inst:",         true,  Op_RegP,              relocInfo::oop_type      },  // InstPtr
 { Bad,             T_OBJECT,     "ary:",          true,  Op_RegP,              relocInfo::oop_type      },  // AryPtr
 return 1;                   // Missed badly
 assert(t1 != t2 || t1->eq(t2), "eq must be reflexive");
 return !t1->eq(t2);           // Return ZERO if equal
 }
-const Type* Type::maybe_remove_speculative(bool include_speculative) const {
-if (!include_speculative) {
-return remove_speculative();
-}
-return this;
-}
 //------------------------------hash-------------------------------------------
 int Type::uhash( const Type *const t ) {
 return t->hash();
 }
 TypeInt::SHORT   = TypeInt::make(-32768,32767, WidenMin); // Java shorts
 TypeInt::POS     = TypeInt::make(0,max_jint,   WidenMin); // Non-neg values
 TypeInt::POS1    = TypeInt::make(1,max_jint,   WidenMin); // Positive values
 TypeInt::INT     = TypeInt::make(min_jint,max_jint, WidenMax); // 32-bit integers
 TypeInt::SYMINT  = TypeInt::make(-max_jint,max_jint,WidenMin); // symmetric range
-TypeInt::TYPE_DOMAIN  = TypeInt::INT;
 // CmpL is overloaded both as the bytecode computation returning
 // a trinary (-1,0,+1) integer result AND as an efficient long
 // compare returning optimizer ideal-type flags.
 assert( TypeInt::CC_LT == TypeInt::MINUS_1, "types must match for CmpL to work" );
 assert( TypeInt::CC_GT == TypeInt::ONE,     "types must match for CmpL to work" );
 TypeLong::ONE     = TypeLong::make( 1);        //  1
 TypeLong::POS     = TypeLong::make(0,max_jlong, WidenMin); // Non-neg values
 TypeLong::LONG    = TypeLong::make(min_jlong,max_jlong,WidenMax); // 64-bit integers
 TypeLong::INT     = TypeLong::make((jlong)min_jint,(jlong)max_jint,WidenMin);
 TypeLong::UINT    = TypeLong::make(0,(jlong)max_juint,WidenMin);
-TypeLong::TYPE_DOMAIN  = TypeLong::LONG;
 const Type **fboth =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*));
 fboth[0] = Type::CONTROL;
 fboth[1] = Type::CONTROL;
 TypeTuple::IFBOTH = TypeTuple::make( 2, fboth );
 #endif
 //------------------------------meet-------------------------------------------
 // Compute the MEET of two types.  NOT virtual.  It enforces that meet is
 // commutative and the lattice is symmetric.
-const Type *Type::meet_helper(const Type *t, bool include_speculative) const {
+const Type *Type::meet( const Type *t ) const {
 if (isa_narrowoop() && t->isa_narrowoop()) {
-const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative);
+const Type* result = make_ptr()->meet(t->make_ptr());
 return result->make_narrowoop();
 }
 if (isa_narrowklass() && t->isa_narrowklass()) {
-const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative);
+const Type* result = make_ptr()->meet(t->make_ptr());
 return result->make_narrowklass();
 }
-const Type *this_t = maybe_remove_speculative(include_speculative);
+const Type *mt = xmeet(t);
-t = t->maybe_remove_speculative(include_speculative);
-const Type *mt = this_t->xmeet(t);
 if (isa_narrowoop() || t->isa_narrowoop()) return mt;
 if (isa_narrowklass() || t->isa_narrowklass()) return mt;
 #ifdef ASSERT
-assert(mt == t->xmeet(this_t), "meet not commutative");
+assert( mt == t->xmeet(this), "meet not commutative" );
 const Type* dual_join = mt->_dual;
 const Type *t2t    = dual_join->xmeet(t->_dual);
-const Type *t2this = dual_join->xmeet(this_t->_dual);
+const Type *t2this = dual_join->xmeet(   _dual);
 // Interface meet Oop is Not Symmetric:
 // Interface:AnyNull meet Oop:AnyNull == Interface:AnyNull
 // Interface:NotNull meet Oop:NotNull == java/lang/Object:NotNull
-if( !interface_vs_oop(t) && (t2t != t->_dual || t2this != this_t->_dual) ) {
+if( !interface_vs_oop(t) && (t2t != t->_dual || t2this != _dual) ) {
 tty->print_cr("=== Meet Not Symmetric ===");
-tty->print("t   =                   ");              t->dump(); tty->cr();
+tty->print("t   =                   ");         t->dump(); tty->cr();
-tty->print("this=                   ");         this_t->dump(); tty->cr();
+tty->print("this=                   ");            dump(); tty->cr();
-tty->print("mt=(t meet this)=       ");             mt->dump(); tty->cr();
+tty->print("mt=(t meet this)=       ");        mt->dump(); tty->cr();
-tty->print("t_dual=                 ");       t->_dual->dump(); tty->cr();
+tty->print("t_dual=                 ");  t->_dual->dump(); tty->cr();
-tty->print("this_dual=              ");  this_t->_dual->dump(); tty->cr();
+tty->print("this_dual=              ");     _dual->dump(); tty->cr();
-tty->print("mt_dual=                ");      mt->_dual->dump(); tty->cr();
+tty->print("mt_dual=                "); mt->_dual->dump(); tty->cr();
-tty->print("mt_dual meet t_dual=    "); t2t           ->dump(); tty->cr();
+tty->print("mt_dual meet t_dual=    "); t2t      ->dump(); tty->cr();
-tty->print("mt_dual meet this_dual= "); t2this        ->dump(); tty->cr();
+tty->print("mt_dual meet this_dual= "); t2this   ->dump(); tty->cr();
 fatal("meet not symmetric" );
 }
 #endif
 return mt;
 // The type is unchanged
 return this;
 }
 //-----------------------------filter------------------------------------------
-const Type *Type::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *Type::filter( const Type *kills ) const {
-const Type* ft = join_helper(kills, include_speculative);
+const Type* ft = join(kills);
 if (ft->empty())
 return Type::TOP;           // Canonical empty value
 return ft;
 }
 const TypeInt *TypeInt::SHORT;  // Java shorts, -32768-32767
 const TypeInt *TypeInt::POS;    // Positive 32-bit integers or zero
 const TypeInt *TypeInt::POS1;   // Positive 32-bit integers
 const TypeInt *TypeInt::INT;    // 32-bit integers
 const TypeInt *TypeInt::SYMINT; // symmetric range [-max_jint..max_jint]
-const TypeInt *TypeInt::TYPE_DOMAIN; // alias for TypeInt::INT
 //------------------------------TypeInt----------------------------------------
 TypeInt::TypeInt( jint lo, jint hi, int w ) : Type(Int), _lo(lo), _hi(hi), _widen(w) {
 }
 return this;
 }
 //-----------------------------filter------------------------------------------
-const Type *TypeInt::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeInt::filter( const Type *kills ) const {
-const TypeInt* ft = join_helper(kills, include_speculative)->isa_int();
+const TypeInt* ft = join(kills)->isa_int();
 if (ft == NULL || ft->empty())
 return Type::TOP;           // Canonical empty value
 if (ft->_widen < this->_widen) {
 // Do not allow the value of kill->_widen to affect the outcome.
 // The widen bits must be allowed to run freely through the graph.
 const TypeLong *TypeLong::ONE;  // 1
 const TypeLong *TypeLong::POS;  // >=0
 const TypeLong *TypeLong::LONG; // 64-bit integers
 const TypeLong *TypeLong::INT;  // 32-bit subrange
 const TypeLong *TypeLong::UINT; // 32-bit unsigned subrange
-const TypeLong *TypeLong::TYPE_DOMAIN; // alias for TypeLong::LONG
 //------------------------------TypeLong---------------------------------------
 TypeLong::TypeLong( jlong lo, jlong hi, int w ) : Type(Long), _lo(lo), _hi(hi), _widen(w) {
 }
 return this;
 }
 //-----------------------------filter------------------------------------------
-const Type *TypeLong::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeLong::filter( const Type *kills ) const {
-const TypeLong* ft = join_helper(kills, include_speculative)->isa_long();
+const TypeLong* ft = join(kills)->isa_long();
 if (ft == NULL || ft->empty())
 return Type::TOP;           // Canonical empty value
 if (ft->_widen < this->_widen) {
 // Do not allow the value of kill->_widen to affect the outcome.
 // The widen bits must be allowed to run freely through the graph.
 const Type **field_array;
 if (recv != NULL) {
 total_fields++;
 field_array = fields(total_fields);
 // Use get_const_type here because it respects UseUniqueSubclasses:
-field_array[pos++] = get_const_type(recv)->join_speculative(TypePtr::NOTNULL);
+field_array[pos++] = get_const_type(recv)->join(TypePtr::NOTNULL);
 } else {
 field_array = fields(total_fields);
 }
 int i = 0;
 default:                      // All else is a mistake
 typerr(t);
 case Array: {                 // Meeting 2 arrays?
 const TypeAry *a = t->is_ary();
-return TypeAry::make(_elem->meet_speculative(a->_elem),
+return TypeAry::make(_elem->meet(a->_elem),
 _size->xmeet(a->_size)->is_int(),
 _stable & a->_stable);
 }
 case Top:
 break;
 //------------------------------hash-------------------------------------------
 // Type-specific hashing function.
 int TypeAry::hash(void) const {
 return (intptr_t)_elem + (intptr_t)_size + (_stable ? 43 : 0);
-}
-/**
-* Return same type without a speculative part in the element
-*/
-const Type* TypeAry::remove_speculative() const {
-return make(_elem->remove_speculative(), _size, _stable);
 }
 //----------------------interface_vs_oop---------------------------------------
 #ifdef ASSERT
 bool TypeAry::interface_vs_oop(const Type *t) const {
 assert(Matcher::vector_size_supported(elem_bt, length), "length in range");
 int size = length * type2aelembytes(elem_bt);
 switch (Matcher::vector_ideal_reg(size)) {
 case Op_VecS:
 return (TypeVect*)(new TypeVectS(elem, length))->hashcons();
-case Op_RegL:
 case Op_VecD:
 case Op_RegD:
 return (TypeVect*)(new TypeVectD(elem, length))->hashcons();
 case Op_VecX:
 return (TypeVect*)(new TypeVectX(elem, length))->hashcons();
 //=============================================================================
 // Convenience common pre-built type.
 const TypeOopPtr *TypeOopPtr::BOTTOM;
 //------------------------------TypeOopPtr-------------------------------------
-TypeOopPtr::TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth)
+TypeOopPtr::TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id, const TypeOopPtr* speculative)
 : TypePtr(t, ptr, offset),
 _const_oop(o), _klass(k),
 _klass_is_exact(xk),
 _is_ptr_to_narrowoop(false),
 _is_ptr_to_narrowklass(false),
 _is_ptr_to_boxed_value(false),
 _instance_id(instance_id),
-_speculative(speculative),
+_speculative(speculative) {
-_inline_depth(inline_depth){
 if (Compile::current()->eliminate_boxing() && (t == InstPtr) &&
 (offset > 0) && xk && (k != 0) && k->is_instance_klass()) {
 _is_ptr_to_boxed_value = k->as_instance_klass()->is_boxed_value_offset(offset);
 }
 #ifdef _LP64
 #endif
 }
 //------------------------------make-------------------------------------------
 const TypeOopPtr *TypeOopPtr::make(PTR ptr,
-int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth) {
+int offset, int instance_id, const TypeOopPtr* speculative) {
 assert(ptr != Constant, "no constant generic pointers");
 ciKlass*  k = Compile::current()->env()->Object_klass();
 bool      xk = false;
 ciObject* o = NULL;
-return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, instance_id, speculative, inline_depth))->hashcons();
+return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, instance_id, speculative))->hashcons();
 }
 //------------------------------cast_to_ptr_type-------------------------------
 const Type *TypeOopPtr::cast_to_ptr_type(PTR ptr) const {
 assert(_base == OopPtr, "subclass must override cast_to_ptr_type");
 if( ptr == _ptr ) return this;
-return make(ptr, _offset, _instance_id, _speculative, _inline_depth);
+return make(ptr, _offset, _instance_id, _speculative);
 }
 //-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const {
 // There are no instances of a general oop.
 const Type* res = xmeet_helper(t);
 if (res->isa_oopptr() == NULL) {
 return res;
 }
-const TypeOopPtr* res_oopptr = res->is_oopptr();
+if (res->isa_oopptr() != NULL) {
-if (res_oopptr->speculative() != NULL) {
 // type->speculative() == NULL means that speculation is no better
 // than type, i.e. type->speculative() == type. So there are 2
 // ways to represent the fact that we have no useful speculative
 // data and we should use a single one to be able to test for
 // equality between types. Check whether type->speculative() ==
 // type and set speculative to NULL if it is the case.
+const TypeOopPtr* res_oopptr = res->is_oopptr();
 if (res_oopptr->remove_speculative() == res_oopptr->speculative()) {
 return res_oopptr->remove_speculative();
 }
 }
 // else fall through:
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
 const TypeOopPtr* speculative = _speculative;
-return make(ptr, offset, instance_id, speculative, _inline_depth);
+return make(ptr, offset, instance_id, speculative);
 }
 case BotPTR:
 case NotNull:
 return TypePtr::make(AnyPtr, ptr, offset);
 default: typerr(t);
 }
 case OopPtr: {                 // Meeting to other OopPtrs
 const TypeOopPtr *tp = t->is_oopptr();
 int instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-int depth = meet_inline_depth(tp->inline_depth());
+return make(meet_ptr(tp->ptr()), meet_offset(tp->offset()), instance_id, speculative);
-return make(meet_ptr(tp->ptr()), meet_offset(tp->offset()), instance_id, speculative, depth);
 }
 case InstPtr:                  // For these, flip the call around to cut down
 case AryPtr:
 return t->xmeet(this);      // Call in reverse direction
 //------------------------------xdual------------------------------------------
 // Dual of a pure heap pointer.  No relevant klass or oop information.
 const Type *TypeOopPtr::xdual() const {
 assert(klass() == Compile::current()->env()->Object_klass(), "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_id(), dual_speculative(), dual_inline_depth());
+return new TypeOopPtr(_base, dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id(), dual_speculative());
 }
 //--------------------------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) {
 if (require_constant) {
 if (!o->can_be_constant())  return NULL;
 } else if (!o->should_be_constant()) {
 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
 }
-const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0, InstanceBot, NULL, InlineDepthBottom, is_autobox_cache);
+const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0, InstanceBot, NULL, is_autobox_cache);
 return arr;
 } else if (klass->is_type_array_klass()) {
 // Element is an typeArray
 const Type* etype =
 (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type());
 }
 //-----------------------------filter------------------------------------------
 // Do not allow interface-vs.-noninterface joins to collapse to top.
-const Type *TypeOopPtr::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeOopPtr::filter(const Type *kills) const {
-const Type* ft = join_helper(kills, include_speculative);
+const Type* ft = join(kills);
 const TypeInstPtr* ftip = ft->isa_instptr();
 const TypeInstPtr* ktip = kills->isa_instptr();
 if (ft->empty()) {
 // Check for evil case of 'this' being a class and 'kills' expecting an
 // Structural equality check for Type representations
 bool TypeOopPtr::eq( const Type *t ) const {
 const TypeOopPtr *a = (const TypeOopPtr*)t;
 if (_klass_is_exact != a->_klass_is_exact ||
 _instance_id != a->_instance_id ||
-!eq_speculative(a) ||
+!eq_speculative(a))  return false;
-_inline_depth != a->_inline_depth)  return false;
 ciObject* one = const_oop();
 ciObject* two = a->const_oop();
 if (one == NULL || two == NULL) {
 return (one == two) && TypePtr::eq(t);
 } else {
 return
 (const_oop() ? const_oop()->hash() : 0) +
 _klass_is_exact +
 _instance_id +
 hash_speculative() +
-_inline_depth +
 TypePtr::hash();
 }
 //------------------------------dump2------------------------------------------
 #ifndef PRODUCT
 if (_instance_id == InstanceTop)
 st->print(",iid=top");
 else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
-dump_inline_depth(st);
 dump_speculative(st);
 }
 /**
 *dump the speculative part of the type
 st->print(" (speculative=");
 _speculative->dump_on(st);
 st->print(")");
 }
 }
-void TypeOopPtr::dump_inline_depth(outputStream *st) const {
-if (_inline_depth != InlineDepthBottom) {
-if (_inline_depth == InlineDepthTop) {
-st->print(" (inline_depth=InlineDepthTop)");
-} else {
-st->print(" (inline_depth=%d)", _inline_depth);
-}
-}
-}
 #endif
 //------------------------------singleton--------------------------------------
 // TRUE if Type is a singleton type, FALSE otherwise.   Singletons are simple
 // constants
 return (_offset == 0) && !below_centerline(_ptr);
 }
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeOopPtr::add_offset(intptr_t offset) const {
-return make(_ptr, xadd_offset(offset), _instance_id, add_offset_speculative(offset), _inline_depth);
+return make(_ptr, xadd_offset(offset), _instance_id, add_offset_speculative(offset));
 }
 /**
 * Return same type without a speculative part
 */
-const Type* TypeOopPtr::remove_speculative() const {
+const TypeOopPtr* TypeOopPtr::remove_speculative() const {
-if (_speculative == NULL) {
+return make(_ptr, _offset, _instance_id, NULL);
-return this;
-}
-assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth");
-return make(_ptr, _offset, _instance_id, NULL, _inline_depth);
-}
-/**
-* Return same type but with a different inline depth (used for speculation)
-*
-* @param depth  depth to meet with
-*/
-const TypeOopPtr* TypeOopPtr::with_inline_depth(int depth) const {
-if (!UseInlineDepthForSpeculativeTypes) {
-return this;
-}
-return make(_ptr, _offset, _instance_id, _speculative, depth);
-}
-/**
-* Check whether new profiling would improve speculative type
-*
-* @param   exact_kls    class from profiling
-* @param   inline_depth inlining depth of profile point
-*
-* @return  true if type profile is valuable
-*/
-bool TypeOopPtr::would_improve_type(ciKlass* exact_kls, int inline_depth) const {
-// no way to improve an already exact type
-if (klass_is_exact()) {
-return false;
-}
-// no profiling?
-if (exact_kls == NULL) {
-return false;
-}
-// no speculative type or non exact speculative type?
-if (speculative_type() == NULL) {
-return true;
-}
-// If the node already has an exact speculative type keep it,
-// unless it was provided by profiling that is at a deeper
-// inlining level. Profiling at a higher inlining depth is
-// expected to be less accurate.
-if (_speculative->inline_depth() == InlineDepthBottom) {
-return false;
-}
-assert(_speculative->inline_depth() != InlineDepthTop, "can't do the comparison");
-return inline_depth < _speculative->inline_depth();
 }
 //------------------------------meet_instance_id--------------------------------
 int TypeOopPtr::meet_instance_id( int instance_id ) const {
 // Either is 'TOP' instance?  Return the other instance!
 /**
 * meet of the speculative parts of 2 types
 *
 * @param other  type to meet with
 */
-const TypeOopPtr* TypeOopPtr::xmeet_speculative(const TypeOopPtr* other) const {
+const TypeOopPtr* TypeOopPtr::meet_speculative(const TypeOopPtr* other) const {
 bool this_has_spec = (_speculative != NULL);
 bool other_has_spec = (other->speculative() != NULL);
 if (!this_has_spec && !other_has_spec) {
 return NULL;
 if (!other_has_spec) {
 other_spec = other;
 }
-return this_spec->meet_speculative(other_spec)->is_oopptr();
+return this_spec->meet(other_spec)->is_oopptr();
 }
 /**
 * dual of the speculative part of the type
 */
 }
 return _speculative->hash();
 }
-/**
-* dual of the inline depth for this type (used for speculation)
-*/
-int TypeOopPtr::dual_inline_depth() const {
-return -inline_depth();
-}
-/**
-* meet of 2 inline depth (used for speculation)
-*
-* @param depth  depth to meet with
-*/
-int TypeOopPtr::meet_inline_depth(int depth) const {
-return MAX2(inline_depth(), depth);
-}
 //=============================================================================
 // Convenience common pre-built types.
 const TypeInstPtr *TypeInstPtr::NOTNULL;
 const TypeInstPtr *TypeInstPtr::BOTTOM;
 const TypeInstPtr *TypeInstPtr::MIRROR;
 const TypeInstPtr *TypeInstPtr::MARK;
 const TypeInstPtr *TypeInstPtr::KLASS;
 //------------------------------TypeInstPtr-------------------------------------
-TypeInstPtr::TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int off, int instance_id, const TypeOopPtr* speculative, int inline_depth)
+TypeInstPtr::TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int off, int instance_id, const TypeOopPtr* speculative)
-: TypeOopPtr(InstPtr, ptr, k, xk, o, off, instance_id, speculative, inline_depth), _name(k->name()) {
+: TypeOopPtr(InstPtr, ptr, k, xk, o, off, instance_id, speculative), _name(k->name()) {
 assert(k != NULL &&
 (k->is_loaded() || o == NULL),
 "cannot have constants with non-loaded klass");
 };
 ciKlass* k,
 bool xk,
 ciObject* o,
 int offset,
 int instance_id,
-const TypeOopPtr* speculative,
+const TypeOopPtr* speculative) {
-int inline_depth) {
 assert( !k->is_loaded() || k->is_instance_klass(), "Must be for instance");
 // Either const_oop() is NULL or else ptr is Constant
 assert( (!o && ptr != Constant) || (o && ptr == Constant),
 "constant pointers must have a value supplied" );
 // Ptr is never Null
 if (xk && ik->is_interface())  xk = false;  // no exact interface
 }
 // Now hash this baby
 TypeInstPtr *result =
-(TypeInstPtr*)(new TypeInstPtr(ptr, k, xk, o ,offset, instance_id, speculative, inline_depth))->hashcons();
+(TypeInstPtr*)(new TypeInstPtr(ptr, k, xk, o ,offset, instance_id, speculative))->hashcons();
 return result;
 }
 /**
 //------------------------------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, _instance_id, _speculative, _inline_depth);
+return make(ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id, _speculative);
 }
 //-----------------------------cast_to_exactness-------------------------------
 const Type *TypeInstPtr::cast_to_exactness(bool klass_is_exact) const {
 if (!UseExactTypes)  return this;
 if (!_klass->is_loaded())  return this;
 ciInstanceKlass* ik = _klass->as_instance_klass();
 if( (ik->is_final() || _const_oop) )  return this;  // cannot clear xk
 if( ik->is_interface() )              return this;  // cannot set xk
-return make(ptr(), klass(), klass_is_exact, const_oop(), _offset, _instance_id, _speculative, _inline_depth);
+return make(ptr(), klass(), klass_is_exact, const_oop(), _offset, _instance_id, _speculative);
 }
 //-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeInstPtr::cast_to_instance_id(int instance_id) const {
 if( instance_id == _instance_id ) return this;
-return make(_ptr, klass(), _klass_is_exact, const_oop(), _offset, instance_id, _speculative, _inline_depth);
+return make(_ptr, klass(), _klass_is_exact, const_oop(), _offset, instance_id, _speculative);
 }
 //------------------------------xmeet_unloaded---------------------------------
 // Compute the MEET of two InstPtrs when at least one is unloaded.
 // Assume classes are different since called after check for same name/class-loader
 const TypeInstPtr *TypeInstPtr::xmeet_unloaded(const TypeInstPtr *tinst) const {
 int off = meet_offset(tinst->offset());
 PTR ptr = meet_ptr(tinst->ptr());
 int instance_id = meet_instance_id(tinst->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tinst);
+const TypeOopPtr* speculative = meet_speculative(tinst);
-int depth = meet_inline_depth(tinst->inline_depth());
 const TypeInstPtr *loaded    = is_loaded() ? this  : tinst;
 const TypeInstPtr *unloaded  = is_loaded() ? tinst : this;
 if( loaded->klass()->equals(ciEnv::current()->Object_klass()) ) {
 //
 //  BOTTOM  | ........................Object-BOTTOM ..................|
 //
 assert(loaded->ptr() != TypePtr::Null, "insanity check");
 //
 if(      loaded->ptr() == TypePtr::TopPTR ) { return unloaded; }
-else if (loaded->ptr() == TypePtr::AnyNull) { return TypeInstPtr::make(ptr, unloaded->klass(), false, NULL, off, instance_id, speculative, depth); }
+else if (loaded->ptr() == TypePtr::AnyNull) { return TypeInstPtr::make(ptr, unloaded->klass(), false, NULL, off, instance_id, speculative); }
 else if (loaded->ptr() == TypePtr::BotPTR ) { return TypeInstPtr::BOTTOM; }
 else if (loaded->ptr() == TypePtr::Constant || loaded->ptr() == TypePtr::NotNull) {
 if (unloaded->ptr() == TypePtr::BotPTR  ) { return TypeInstPtr::BOTTOM;  }
 else                                      { return TypeInstPtr::NOTNULL; }
 }
 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 instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-int depth = meet_inline_depth(tp->inline_depth());
 switch (ptr) {
 case TopPTR:
 case AnyNull:                // Fall 'down' to dual of object klass
 // For instances when a subclass meets a superclass we fall
 // below the centerline when the superclass is exact. We need to
 // do the same here.
 if (klass()->equals(ciEnv::current()->Object_klass()) && !klass_is_exact()) {
-return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id, speculative, depth);
+return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id, speculative);
 } else {
 // cannot subclass, so the meet has to fall badly below the centerline
 ptr = NotNull;
 instance_id = InstanceBot;
-return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id, speculative, depth);
+return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id, speculative);
 }
 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
 // below the centerline when the superclass is exact. We need
 // to do the same here.
 if (klass()->equals(ciEnv::current()->Object_klass()) && !klass_is_exact()) {
 // that is, tp's array type is a subtype of my klass
 return TypeAryPtr::make(ptr, (ptr == Constant ? tp->const_oop() : NULL),
-tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id, speculative, depth);
+tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id, speculative);
 }
 }
 // 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;
 instance_id = InstanceBot;
-return make(ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id, speculative, depth);
+return make(ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id, speculative);
 default: typerr(t);
 }
 }
 case OopPtr: {                // Meeting to OopPtrs
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-int depth = meet_inline_depth(tp->inline_depth());
 return make(ptr, klass(), klass_is_exact(),
-(ptr == Constant ? const_oop() : NULL), offset, instance_id, speculative, depth);
+(ptr == Constant ? const_oop() : NULL), offset, instance_id, speculative);
 }
 case NotNull:
 case BotPTR: {
 int instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-int depth = meet_inline_depth(tp->inline_depth());
+return TypeOopPtr::make(ptr, offset, instance_id, speculative);
-return TypeOopPtr::make(ptr, offset, instance_id, speculative, depth);
 }
 default: typerr(t);
 }
 }
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
 const TypeOopPtr* speculative = _speculative;
 return make(ptr, klass(), klass_is_exact(),
-(ptr == Constant ? const_oop() : NULL), offset, instance_id, speculative, _inline_depth);
+(ptr == Constant ? const_oop() : NULL), offset, instance_id, speculative);
 }
 case NotNull:
 case BotPTR:
 return TypePtr::make(AnyPtr, ptr, offset);
 default: typerr(t);
 // 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_id(tinst->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tinst);
+const TypeOopPtr* speculative = meet_speculative(tinst);
-int depth = meet_inline_depth(tinst->inline_depth());
 // 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
 if (ptr != Constant && klass()->equals(tinst->klass()) && klass_is_exact() == tinst->klass_is_exact()) {
-return make(ptr, klass(), klass_is_exact(), NULL, off, instance_id, speculative, depth);
+return make(ptr, klass(), klass_is_exact(), NULL, off, instance_id, speculative);
 }
 // Classes require inspection in the Java klass hierarchy.  Must be loaded.
 ciKlass* tinst_klass = tinst->klass();
 ciKlass* this_klass  = this->klass();
 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, instance_id, speculative, depth);
+return make(ptr, k, xk, o, off, instance_id, speculative);
 }
 // Either oop vs oop or interface vs interface or interface vs Object
 // !!! Here's how the symmetry requirement breaks down into invariants:
 else if (above_centerline(tinst ->_ptr))
 o = this_oop;
 else
 ptr = NotNull;
 }
-return make(ptr, this_klass, this_xk, o, off, instance_id, speculative, depth);
+return make(ptr, this_klass, this_xk, o, off, instance_id, speculative);
 } // Else classes are not equal
 // Since klasses are different, we require a LCA in the Java
 // class hierarchy - which means we have to fall to at least NotNull.
 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant )
 ptr = NotNull;
 instance_id = InstanceBot;
 // Now we find the LCA of Java classes
 ciKlass* k = this_klass->least_common_ancestor(tinst_klass);
-return make(ptr, k, false, NULL, off, instance_id, speculative, depth);
+return make(ptr, k, false, NULL, off, instance_id, speculative);
 } // End of case InstPtr
 } // End of switch
 return this;                  // Return the double constant
 }
 //------------------------------xdual------------------------------------------
 // Dual: do NOT dual on klasses.  This means I do NOT understand the Java
 // inheritance mechanism.
 const Type *TypeInstPtr::xdual() const {
-return new TypeInstPtr(dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id(), dual_speculative(), dual_inline_depth());
+return new TypeInstPtr(dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id(), dual_speculative());
 }
 //------------------------------eq---------------------------------------------
 // Structural equality check for Type representations
 bool TypeInstPtr::eq( const Type *t ) const {
 if (_instance_id == InstanceTop)
 st->print(",iid=top");
 else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
-dump_inline_depth(st);
 dump_speculative(st);
 }
 #endif
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeInstPtr::add_offset(intptr_t offset) const {
 return make(_ptr, klass(), klass_is_exact(), const_oop(), xadd_offset(offset), _instance_id, add_offset_speculative(offset));
 }
-const Type *TypeInstPtr::remove_speculative() const {
+const TypeOopPtr *TypeInstPtr::remove_speculative() const {
-if (_speculative == NULL) {
+return make(_ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id, NULL);
-return this;
-}
-assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth");
-return make(_ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id, NULL, _inline_depth);
-}
-const TypeOopPtr *TypeInstPtr::with_inline_depth(int depth) const {
-if (!UseInlineDepthForSpeculativeTypes) {
-return this;
-}
-return make(_ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id, _speculative, depth);
 }
 //=============================================================================
 // Convenience common pre-built types.
 const TypeAryPtr *TypeAryPtr::RANGE;
 const TypeAryPtr *TypeAryPtr::LONGS;
 const TypeAryPtr *TypeAryPtr::FLOATS;
 const TypeAryPtr *TypeAryPtr::DOUBLES;
 //------------------------------make-------------------------------------------
-const TypeAryPtr *TypeAryPtr::make(PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth) {
+const TypeAryPtr *TypeAryPtr::make(PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id, const TypeOopPtr* speculative) {
 assert(!(k == NULL && ary->_elem->isa_int()),
 "integral arrays must be pre-equipped with a class");
 if (!xk)  xk = ary->ary_must_be_exact();
 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
 if (!UseExactTypes)  xk = (ptr == Constant);
-return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id, false, speculative, inline_depth))->hashcons();
+return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id, false, speculative))->hashcons();
 }
 //------------------------------make-------------------------------------------
-const TypeAryPtr *TypeAryPtr::make(PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id, const TypeOopPtr* speculative, int inline_depth, bool is_autobox_cache) {
+const TypeAryPtr *TypeAryPtr::make(PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id, const TypeOopPtr* speculative, bool is_autobox_cache) {
 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();
 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
 if (!UseExactTypes)  xk = (ptr == Constant);
-return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id, is_autobox_cache, speculative, inline_depth))->hashcons();
+return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id, is_autobox_cache, speculative))->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, _instance_id, _speculative, _inline_depth);
+return make(ptr, const_oop(), _ary, klass(), klass_is_exact(), _offset, _instance_id, _speculative);
 }
 //-----------------------------cast_to_exactness-------------------------------
 const Type *TypeAryPtr::cast_to_exactness(bool klass_is_exact) const {
 if( klass_is_exact == _klass_is_exact ) return this;
 if (!UseExactTypes)  return this;
 if (_ary->ary_must_be_exact())  return this;  // cannot clear xk
-return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _instance_id, _speculative, _inline_depth);
+return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _instance_id, _speculative);
 }
 //-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeAryPtr::cast_to_instance_id(int instance_id) const {
 if( instance_id == _instance_id ) return this;
-return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, instance_id, _speculative, _inline_depth);
+return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, instance_id, _speculative);
 }
 //-----------------------------narrow_size_type-------------------------------
 // Local cache for arrayOopDesc::max_array_length(etype),
 // which is kind of slow (and cached elsewhere by other users).
 const TypeAryPtr* TypeAryPtr::cast_to_size(const TypeInt* new_size) const {
 assert(new_size != NULL, "");
 new_size = narrow_size_type(new_size);
 if (new_size == size())  return this;
 const TypeAry* new_ary = TypeAry::make(elem(), new_size, is_stable());
-return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id, _speculative, _inline_depth);
+return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id, _speculative);
 }
 //------------------------------cast_to_stable---------------------------------
 const TypeAryPtr* TypeAryPtr::cast_to_stable(bool stable, int stable_dimension) const {
 case OopPtr: {                // Meeting to OopPtrs
 // Found a OopPtr type vs self-AryPtr type
 const TypeOopPtr *tp = t->is_oopptr();
 int offset = meet_offset(tp->offset());
 PTR ptr = meet_ptr(tp->ptr());
-int depth = meet_inline_depth(tp->inline_depth());
 switch (tp->ptr()) {
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
 return make(ptr, (ptr == Constant ? const_oop() : NULL),
-_ary, _klass, _klass_is_exact, offset, instance_id, speculative, depth);
+_ary, _klass, _klass_is_exact, offset, instance_id, speculative);
 }
 case BotPTR:
 case NotNull: {
 int instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-return TypeOopPtr::make(ptr, offset, instance_id, speculative, depth);
+return TypeOopPtr::make(ptr, offset, instance_id, speculative);
 }
 default: ShouldNotReachHere();
 }
 }
 // else fall through to AnyNull
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
 const TypeOopPtr* speculative = _speculative;
 return make(ptr, (ptr == Constant ? const_oop() : NULL),
-_ary, _klass, _klass_is_exact, offset, instance_id, speculative, _inline_depth);
+_ary, _klass, _klass_is_exact, offset, instance_id, speculative);
 }
 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_speculative(tap->_ary)->is_ary();
+const TypeAry *tary = _ary->meet(tap->_ary)->is_ary();
 PTR ptr = meet_ptr(tap->ptr());
 int instance_id = meet_instance_id(tap->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tap);
+const TypeOopPtr* speculative = meet_speculative(tap);
-int depth = meet_inline_depth(tap->inline_depth());
 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)
 // This must fall to bottom, not (int[-128..65535])[int+].
 instance_id = InstanceBot;
 tary = TypeAry::make(Type::BOTTOM, tary->_size, tary->_stable);
 }
 } else // Non integral arrays.
 // Must fall to bottom if exact klasses in upper lattice
 // are not equal or super klass is exact.
-if ((above_centerline(ptr) || ptr == Constant) && klass() != tap->klass() &&
+if ( above_centerline(ptr) && klass() != tap->klass() &&
 // meet with top[] and bottom[] are processed further down:
-tap->_klass != NULL  && this->_klass != NULL   &&
+tap ->_klass != NULL  && this->_klass != NULL   &&
 // both are exact and not equal:
-((tap->_klass_is_exact && this->_klass_is_exact) ||
+((tap ->_klass_is_exact && this->_klass_is_exact) ||
 // 'tap'  is exact and super or unrelated:
-(tap->_klass_is_exact && !tap->klass()->is_subtype_of(klass())) ||
+(tap ->_klass_is_exact && !tap->klass()->is_subtype_of(klass())) ||
 // 'this' is exact and super or unrelated:
 (this->_klass_is_exact && !klass()->is_subtype_of(tap->klass())))) {
 tary = TypeAry::make(Type::BOTTOM, tary->_size, tary->_stable);
 return make(NotNull, NULL, tary, lazy_klass, false, off, InstanceBot);
 }
 bool xk = false;
 if (below_centerline(this->_ptr)) {
 xk = this->_klass_is_exact;
 } else {
 xk = (tap->_klass_is_exact | this->_klass_is_exact);
 }
-return make(ptr, const_oop(), tary, lazy_klass, xk, off, instance_id, speculative, depth);
+return make(ptr, const_oop(), tary, lazy_klass, xk, off, instance_id, speculative);
 case Constant: {
 ciObject* o = const_oop();
 if( _ptr == Constant ) {
 if( tap->const_oop() != NULL && !o->equals(tap->const_oop()) ) {
 xk = (klass() == tap->klass());
 xk = true;
 } else {
 // Only precise for identical arrays
 xk = this->_klass_is_exact && (klass() == tap->klass());
 }
-return TypeAryPtr::make(ptr, o, tary, lazy_klass, xk, off, instance_id, speculative, depth);
+return TypeAryPtr::make(ptr, o, tary, lazy_klass, xk, off, instance_id, speculative);
 }
 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  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, instance_id, speculative, depth);
+return TypeAryPtr::make(ptr, NULL, tary, lazy_klass, xk, off, instance_id, speculative);
 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 instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = xmeet_speculative(tp);
+const TypeOopPtr* speculative = meet_speculative(tp);
-int depth = meet_inline_depth(tp->inline_depth());
 switch (ptr) {
 case TopPTR:
 case AnyNull:                // Fall 'down' to dual of object klass
 // For instances when a subclass meets a superclass we fall
 // below the centerline when the superclass is exact. We need to
 // do the same here.
 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && !tp->klass_is_exact()) {
-return TypeAryPtr::make(ptr, _ary, _klass, _klass_is_exact, offset, instance_id, speculative, depth);
+return TypeAryPtr::make(ptr, _ary, _klass, _klass_is_exact, offset, instance_id, speculative);
 } else {
 // cannot subclass, so the meet has to fall badly below the centerline
 ptr = NotNull;
 instance_id = InstanceBot;
-return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id, speculative, depth);
+return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id, speculative);
 }
 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
 // below the centerline when the superclass is exact. We need
 // to do the same here.
 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && !tp->klass_is_exact()) {
 // that is, my array type is a subtype of 'tp' klass
 return make(ptr, (ptr == Constant ? const_oop() : NULL),
-_ary, _klass, _klass_is_exact, offset, instance_id, speculative, depth);
+_ary, _klass, _klass_is_exact, offset, instance_id, speculative);
 }
 }
 // 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;
 instance_id = InstanceBot;
-return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id, speculative, depth);
+return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id, speculative);
 default: typerr(t);
 }
 }
 }
 return this;                  // Lint noise
 }
 //------------------------------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_id(), is_autobox_cache(), dual_speculative(), dual_inline_depth());
+return new TypeAryPtr(dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id(), is_autobox_cache(), dual_speculative());
 }
 //----------------------interface_vs_oop---------------------------------------
 #ifdef ASSERT
 bool TypeAryPtr::interface_vs_oop(const Type *t) const {
 if (_instance_id == InstanceTop)
 st->print(",iid=top");
 else if (_instance_id != InstanceBot)
 st->print(",iid=%d",_instance_id);
-dump_inline_depth(st);
 dump_speculative(st);
 }
 #endif
 bool TypeAryPtr::empty(void) const {
 return TypeOopPtr::empty();
 }
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeAryPtr::add_offset(intptr_t offset) const {
-return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _instance_id, add_offset_speculative(offset), _inline_depth);
+return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _instance_id, add_offset_speculative(offset));
 }
-const Type *TypeAryPtr::remove_speculative() const {
+const TypeOopPtr *TypeAryPtr::remove_speculative() const {
-if (_speculative == NULL) {
+return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, _offset, _instance_id, NULL);
-return this;
-}
-assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth");
-return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _instance_id, NULL, _inline_depth);
-}
-const TypeOopPtr *TypeAryPtr::with_inline_depth(int depth) const {
-if (!UseInlineDepthForSpeculativeTypes) {
-return this;
-}
-return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _instance_id, _speculative, depth);
 }
 //=============================================================================
 //------------------------------hash-------------------------------------------
 const TypePtr* odual = _ptrtype->dual()->is_ptr();
 return make_same_narrowptr(odual);
 }
-const Type *TypeNarrowPtr::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeNarrowPtr::filter( const Type *kills ) const {
 if (isa_same_narrowptr(kills)) {
-const Type* ft =_ptrtype->filter_helper(is_same_narrowptr(kills)->_ptrtype, include_speculative);
+const Type* ft =_ptrtype->filter(is_same_narrowptr(kills)->_ptrtype);
 if (ft->empty())
 return Type::TOP;           // Canonical empty value
 if (ft->isa_ptr()) {
 return make_hash_same_narrowptr(ft->isa_ptr());
 }
 return ft;
 } else if (kills->isa_ptr()) {
-const Type* ft = _ptrtype->join_helper(kills, include_speculative);
+const Type* ft = _ptrtype->join(kills);
 if (ft->empty())
 return Type::TOP;           // Canonical empty value
 return ft;
 } else {
 return Type::TOP;
 return make( _ptr, _metadata, xadd_offset(offset));
 }
 //-----------------------------filter------------------------------------------
 // Do not allow interface-vs.-noninterface joins to collapse to top.
-const Type *TypeMetadataPtr::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeMetadataPtr::filter( const Type *kills ) const {
-const TypeMetadataPtr* ft = join_helper(kills, include_speculative)->isa_metadataptr();
+const TypeMetadataPtr* ft = join(kills)->isa_metadataptr();
 if (ft == NULL || ft->empty())
 return Type::TOP;           // Canonical empty value
 return ft;
 }
 // TopPTR, Null, AnyNull, Constant are all singletons
 return (_offset == 0) && !below_centerline(_ptr);
 }
 // Do not allow interface-vs.-noninterface joins to collapse to top.
-const Type *TypeKlassPtr::filter_helper(const Type *kills, bool include_speculative) const {
+const Type *TypeKlassPtr::filter(const Type *kills) const {
 // logic here mirrors the one from TypeOopPtr::filter. See comments
 // there.
-const Type* ft = join_helper(kills, include_speculative);
+const Type* ft = join(kills);
 const TypeKlassPtr* ftkp = ft->isa_klassptr();
 const TypeKlassPtr* ktkp = kills->isa_klassptr();
 if (ft->empty()) {
 if (!empty() && ktkp != NULL && ktkp->klass()->is_loaded() && ktkp->klass()->is_interface())

Mercurial > hg > truffle

comparison src/share/vm/opto/type.cpp @ 14909:4ca6dc0799b6