graal-compiler: src/share/vm/opto/type.cpp comparison

comparison src/share/vm/opto/type.cpp @ 17799:752ba2e5f6d0

Merge

author	kvn
date	Tue, 25 Feb 2014 15:11:18 -0800
parents	a9becfeecd1b de95063c0e34
children	cd5d10655495 62c54fcc0a35

comparison

equal deleted inserted replaced

-:f040cf9fc9c0
+:752ba2e5f6d0
 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();
 }
 #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( const Type *t ) const {
+const Type *Type::meet_helper(const Type *t, bool include_speculative) const {
 if (isa_narrowoop() && t->isa_narrowoop()) {
-const Type* result = make_ptr()->meet(t->make_ptr());
+const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative);
 return result->make_narrowoop();
 }
 if (isa_narrowklass() && t->isa_narrowklass()) {
-const Type* result = make_ptr()->meet(t->make_ptr());
+const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative);
 return result->make_narrowklass();
 }
-const Type *mt = xmeet(t);
+const Type *this_t = maybe_remove_speculative(include_speculative);
+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), "meet not commutative" );
+assert(mt == t->xmeet(this_t), "meet not commutative");
 const Type* dual_join = mt->_dual;
 const Type *t2t    = dual_join->xmeet(t->_dual);
-const Type *t2this = dual_join->xmeet(   _dual);
+const Type *t2this = dual_join->xmeet(this_t->_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 != _dual) ) {
+if( !interface_vs_oop(t) && (t2t != t->_dual || t2this != this_t->_dual) ) {
 tty->print_cr("=== Meet Not Symmetric ===");
-tty->print("t   =                   ");         t->dump(); tty->cr();
+tty->print("t   =                   ");              t->dump(); tty->cr();
-tty->print("this=                   ");            dump(); tty->cr();
+tty->print("this=                   ");         this_t->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=              ");     _dual->dump(); tty->cr();
+tty->print("this_dual=              ");  this_t->_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( const Type *kills ) const {
+const Type *Type::filter_helper(const Type *kills, bool include_speculative) const {
-const Type* ft = join(kills);
+const Type* ft = join_helper(kills, include_speculative);
 if (ft->empty())
 return Type::TOP;           // Canonical empty value
 return ft;
 }
 return this;
 }
 //-----------------------------filter------------------------------------------
-const Type *TypeInt::filter( const Type *kills ) const {
+const Type *TypeInt::filter_helper(const Type *kills, bool include_speculative) const {
-const TypeInt* ft = join(kills)->isa_int();
+const TypeInt* ft = join_helper(kills, include_speculative)->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.
 return this;
 }
 //-----------------------------filter------------------------------------------
-const Type *TypeLong::filter( const Type *kills ) const {
+const Type *TypeLong::filter_helper(const Type *kills, bool include_speculative) const {
-const TypeLong* ft = join(kills)->isa_long();
+const TypeLong* ft = join_helper(kills, include_speculative)->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(TypePtr::NOTNULL);
+field_array[pos++] = get_const_type(recv)->join_speculative(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(a->_elem),
+return TypeAry::make(_elem->meet_speculative(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 {
 const Type* res = xmeet_helper(t);
 if (res->isa_oopptr() == NULL) {
 return res;
 }
-if (res->isa_oopptr() != NULL) {
+const TypeOopPtr* res_oopptr = res->is_oopptr();
+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();
 }
 }
 }
 case OopPtr: {                 // Meeting to other OopPtrs
 const TypeOopPtr *tp = t->is_oopptr();
 int instance_id = meet_instance_id(tp->instance_id());
-const TypeOopPtr* speculative = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 return make(meet_ptr(tp->ptr()), meet_offset(tp->offset()), instance_id, speculative);
 }
 case InstPtr:                  // For these, flip the call around to cut down
 case AryPtr:
 }
 //-----------------------------filter------------------------------------------
 // Do not allow interface-vs.-noninterface joins to collapse to top.
-const Type *TypeOopPtr::filter(const Type *kills) const {
+const Type *TypeOopPtr::filter_helper(const Type *kills, bool include_speculative) const {
-const Type* ft = join(kills);
+const Type* ft = join_helper(kills, include_speculative);
 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
 }
 /**
 * Return same type without a speculative part
 */
-const TypeOopPtr* TypeOopPtr::remove_speculative() const {
+const Type* TypeOopPtr::remove_speculative() const {
+if (_speculative == NULL) {
+return this;
+}
 return make(_ptr, _offset, _instance_id, NULL);
 }
 //------------------------------meet_instance_id--------------------------------
 int TypeOopPtr::meet_instance_id( int instance_id ) const {
 /**
 * meet of the speculative parts of 2 types
 *
 * @param other  type to meet with
 */
-const TypeOopPtr* TypeOopPtr::meet_speculative(const TypeOopPtr* other) const {
+const TypeOopPtr* TypeOopPtr::xmeet_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(other_spec)->is_oopptr();
+return this_spec->meet_speculative(other_spec)->is_oopptr();
 }
 /**
 * dual of the speculative part of the type
 */
 // 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 = meet_speculative(tinst);
+const TypeOopPtr* speculative = xmeet_speculative(tinst);
 const TypeInstPtr *loaded    = is_loaded() ? this  : tinst;
 const TypeInstPtr *unloaded  = is_loaded() ? tinst : this;
 if( loaded->klass()->equals(ciEnv::current()->Object_klass()) ) {
 //
 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 = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 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
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
-const TypeOopPtr* speculative = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 return make(ptr, klass(), klass_is_exact(),
 (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 = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 return TypeOopPtr::make(ptr, offset, instance_id, speculative);
 }
 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 = meet_speculative(tinst);
+const TypeOopPtr* speculative = xmeet_speculative(tinst);
 // 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
 //------------------------------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 TypeOopPtr *TypeInstPtr::remove_speculative() const {
+const Type *TypeInstPtr::remove_speculative() const {
+if (_speculative == NULL) {
+return this;
+}
 return make(_ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id, NULL);
 }
 //=============================================================================
 // Convenience common pre-built types.
 PTR ptr = meet_ptr(tp->ptr());
 switch (tp->ptr()) {
 case TopPTR:
 case AnyNull: {
 int instance_id = meet_instance_id(InstanceTop);
-const TypeOopPtr* speculative = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 return make(ptr, (ptr == Constant ? const_oop() : NULL),
 _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 = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 return TypeOopPtr::make(ptr, 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(tap->_ary)->is_ary();
+const TypeAry *tary = _ary->meet_speculative(tap->_ary)->is_ary();
 PTR ptr = meet_ptr(tap->ptr());
 int instance_id = meet_instance_id(tap->instance_id());
-const TypeOopPtr* speculative = meet_speculative(tap);
+const TypeOopPtr* speculative = xmeet_speculative(tap);
 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)
 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 = meet_speculative(tp);
+const TypeOopPtr* speculative = xmeet_speculative(tp);
 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
 //------------------------------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));
 }
-const TypeOopPtr *TypeAryPtr::remove_speculative() const {
+const Type *TypeAryPtr::remove_speculative() const {
-return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, _offset, _instance_id, NULL);
+return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _instance_id, NULL);
 }
 //=============================================================================
 //------------------------------hash-------------------------------------------
 const TypePtr* odual = _ptrtype->dual()->is_ptr();
 return make_same_narrowptr(odual);
 }
-const Type *TypeNarrowPtr::filter( const Type *kills ) const {
+const Type *TypeNarrowPtr::filter_helper(const Type *kills, bool include_speculative) const {
 if (isa_same_narrowptr(kills)) {
-const Type* ft =_ptrtype->filter(is_same_narrowptr(kills)->_ptrtype);
+const Type* ft =_ptrtype->filter_helper(is_same_narrowptr(kills)->_ptrtype, include_speculative);
 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(kills);
+const Type* ft = _ptrtype->join_helper(kills, include_speculative);
 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( const Type *kills ) const {
+const Type *TypeMetadataPtr::filter_helper(const Type *kills, bool include_speculative) const {
-const TypeMetadataPtr* ft = join(kills)->isa_metadataptr();
+const TypeMetadataPtr* ft = join_helper(kills, include_speculative)->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(const Type *kills) const {
+const Type *TypeKlassPtr::filter_helper(const Type *kills, bool include_speculative) const {
 // logic here mirrors the one from TypeOopPtr::filter. See comments
 // there.
-const Type* ft = join(kills);
+const Type* ft = join_helper(kills, include_speculative);
 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 > graal-compiler

comparison src/share/vm/opto/type.cpp @ 17799:752ba2e5f6d0