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

comparison src/share/vm/opto/type.cpp @ 247:02a35ad4adf8

6723160: Nightly failure: Error: meet not symmetric Summary: Add missing _instance_id settings and other EA fixes. Reviewed-by: rasbold

author	kvn
date	Wed, 16 Jul 2008 16:04:39 -0700
parents	9c2ecc2ffb12
children	c3e045194476

comparison

equal deleted inserted replaced

-:9b66e6287f4a
+:02a35ad4adf8
 assert(_base == OopPtr, "subclass must override cast_to_ptr_type");
 if( ptr == _ptr ) return this;
 return make(ptr, _offset);
 }
-//-----------------------------cast_to_instance-------------------------------
+//-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const {
 // There are no instances of a general oop.
 // Return self unchanged.
 return this;
 }
 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 > 0 )
+assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
-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;
 } else if (k->is_loaded()) {
 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);
 }
-//-----------------------------cast_to_instance-------------------------------
+//-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeInstPtr::cast_to_instance_id(int instance_id) const {
 if( instance_id == _instance_id ) return this;
-bool exact = _klass_is_exact;
+return make(_ptr, klass(), _klass_is_exact, const_oop(), _offset, instance_id);
-PTR  ptr_t = _ptr;
-if ( instance_id > 0 ) { // instances are always exactly typed
-if (UseExactTypes) exact = true;
-ptr_t = NotNull;
-}
-return make(ptr_t, klass(), exact, const_oop(), _offset, instance_id);
 }
 //------------------------------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
 // centerline fall to interface)
 k = above_centerline(ptr) ? tinst_klass : ciEnv::current()->Object_klass();
 xk = above_centerline(ptr) ? tinst_xk : false;
 // Watch out for Constant vs. AnyNull interface.
 if (ptr == Constant)  ptr = NotNull;   // forget it was a constant
+instance_id = InstanceBot;
 }
 ciObject* o = NULL;  // the Constant value, if any
 if (ptr == Constant) {
 // Find out which constant.
 o = (this_klass == klass()) ? const_oop() : tinst->const_oop();
 // 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 );
 } // End of case InstPtr
 //------------------------------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 > 0 )
+assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
-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();
 }
 //------------------------------make-------------------------------------------
 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 > 0 )
+assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
-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-------------------------------
 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);
 }
-//-----------------------------cast_to_instance-------------------------------
+//-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeAryPtr::cast_to_instance_id(int instance_id) const {
 if( instance_id == _instance_id ) return this;
-bool exact = _klass_is_exact;
+return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, instance_id);
-PTR  ptr_t = _ptr;
-if ( instance_id > 0 ) { // instances are always exactly typed
-if (UseExactTypes) exact = true;
-ptr_t = NotNull;
-}
-return make(ptr_t, const_oop(), _ary, klass(), exact, _offset, instance_id);
 }
 //-----------------------------narrow_size_type-------------------------------
 // Local cache for arrayOopDesc::max_array_length(etype),
 // which is kind of slow (and cached elsewhere by other users).
 else if (tap->_klass == NULL || tap->_klass == _klass) {
 lazy_klass = _klass;
 } else {
 // Something like byte[int+] meets char[int+].
 // This must fall to bottom, not (int[-128..65535])[int+].
+instance_id = InstanceBot;
 tary = TypeAry::make(Type::BOTTOM, tary->_size);
 }
 }
 bool xk;
 switch (tap->ptr()) {
 ciObject* o = const_oop();
 if( _ptr == Constant ) {
 if( tap->const_oop() != NULL && !o->equals(tap->const_oop()) ) {
 ptr = NotNull;
 o = NULL;
+instance_id = InstanceBot;
 }
 } else if( above_centerline(_ptr) ) {
 o = tap->const_oop();
 }
 xk = true;

Mercurial > hg > truffle

comparison src/share/vm/opto/type.cpp @ 247:02a35ad4adf8