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

comparison src/share/vm/opto/type.cpp @ 1000:a1423fe86a18

Merge

author	trims
date	Fri, 09 Oct 2009 15:18:52 -0700
parents	6a8ccac44f41
children	03b336640699

comparison

equal deleted inserted replaced

-:6ddec5389232
+:a1423fe86a18
 TypeInstPtr::MIRROR  = TypeInstPtr::make(TypePtr::NotNull, current->env()->Class_klass());
 TypeInstPtr::MARK    = TypeInstPtr::make(TypePtr::BotPTR,  current->env()->Object_klass(),
 false, 0, oopDesc::mark_offset_in_bytes());
 TypeInstPtr::KLASS   = TypeInstPtr::make(TypePtr::BotPTR,  current->env()->Object_klass(),
 false, 0, oopDesc::klass_offset_in_bytes());
-TypeOopPtr::BOTTOM  = TypeOopPtr::make(TypePtr::BotPTR, OffsetBot);
+TypeOopPtr::BOTTOM  = TypeOopPtr::make(TypePtr::BotPTR, OffsetBot, TypeOopPtr::InstanceBot);
 TypeNarrowOop::NULL_PTR = TypeNarrowOop::make( TypePtr::NULL_PTR );
 TypeNarrowOop::BOTTOM   = TypeNarrowOop::make( TypeInstPtr::BOTTOM );
 mreg2type[Op_Node] = Type::BOTTOM;
 //----------------------interface_vs_oop---------------------------------------
 #ifdef ASSERT
 bool Type::interface_vs_oop(const Type *t) const {
 bool result = false;
-const TypeInstPtr* this_inst = this->isa_instptr();
+const TypePtr* this_ptr = this->make_ptr(); // In case it is narrow_oop
-const TypeInstPtr*    t_inst =    t->isa_instptr();
+const TypePtr*    t_ptr =    t->make_ptr();
+if( this_ptr == NULL || t_ptr == NULL )
+return result;
+const TypeInstPtr* this_inst = this_ptr->isa_instptr();
+const TypeInstPtr*    t_inst =    t_ptr->isa_instptr();
 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();
 result = this_interface ^ t_interface;
 }
 //------------------------------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);
+return make(ptr, _offset, _instance_id);
 }
 //-----------------------------cast_to_instance_id----------------------------
 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const {
 // There are no instances of a general oop.
 switch (tp->ptr()) {
 case Null:
 if (ptr == Null)  return TypePtr::make(AnyPtr, ptr, offset);
 // else fall through:
 case TopPTR:
-case AnyNull:
+case AnyNull: {
-return make(ptr, offset);
+int instance_id = meet_instance_id(InstanceTop);
+return make(ptr, offset, instance_id);
+}
 case BotPTR:
 case NotNull:
 return TypePtr::make(AnyPtr, ptr, offset);
 default: typerr(t);
 }
 }
 }
 //------------------------------make_from_constant-----------------------------
 // Make a java pointer from an oop constant
-const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o) {
+const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) {
 if (o->is_method_data() || o->is_method()) {
 // Treat much like a typeArray of bytes, like below, but fake the type...
-assert(o->has_encoding(), "must be a perm space object");
 const Type* etype = (Type*)get_const_basic_type(T_BYTE);
 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS);
 ciKlass *klass = ciTypeArrayKlass::make((BasicType) T_BYTE);
-assert(o->has_encoding(), "method data oops should be tenured");
+assert(o->can_be_constant(), "method data oops should be tenured");
 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
 return arr;
 } else {
 assert(o->is_java_object(), "must be java language object");
 assert(!o->is_null_object(), "null object not yet handled here.");
 ciKlass *klass = o->klass();
 if (klass->is_instance_klass()) {
 // Element is an instance
-if (!o->has_encoding()) {  // not a perm-space constant
+if (require_constant) {
-// %%% remove this restriction by rewriting non-perm ConPNodes in a later phase
+if (!o->can_be_constant())  return NULL;
+} else if (!o->should_be_constant()) {
 return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0);
 }
 return TypeInstPtr::make(o);
 } else if (klass->is_obj_array_klass()) {
 // Element is an object array. Recursively call ourself.
 TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass());
 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
 // We used to pass NotNull in here, asserting that the sub-arrays
 // are all not-null.  This is not true in generally, as code can
 // slam NULLs down in the subarrays.
-if (!o->has_encoding()) {  // not a perm-space constant
+if (require_constant) {
-// %%% remove this restriction by rewriting non-perm ConPNodes in a later phase
+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);
 return arr;
 } else if (klass->is_type_array_klass()) {
 const Type* etype =
 (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type());
 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
 // We used to pass NotNull in here, asserting that the array pointer
 // is not-null. That was not true in general.
-if (!o->has_encoding()) {  // not a perm-space constant
+if (require_constant) {
-// %%% remove this restriction by rewriting non-perm ConPNodes in a later phase
+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);
 return arr;
 }
 // but this assertion here is to help prevent its occurence.
 tty->print_cr("Found oop constant with non-zero offset");
 ShouldNotReachHere();
 }
-return (intptr_t)const_oop()->encoding();
+return (intptr_t)const_oop()->constant_encoding();
 }
 //-----------------------------filter------------------------------------------
 // Do not allow interface-vs.-noninterface joins to collapse to top.
 return (_offset == 0) && !below_centerline(_ptr);
 }
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeOopPtr::add_offset( intptr_t offset ) const {
-return make( _ptr, xadd_offset(offset) );
+return make( _ptr, xadd_offset(offset), _instance_id);
 }
 //------------------------------meet_instance_id--------------------------------
 int TypeOopPtr::meet_instance_id( int instance_id ) const {
 // Either is 'TOP' instance?  Return the other instance!
 // 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 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() ); }
+else if (loaded->ptr() == TypePtr::AnyNull) { return TypeInstPtr::make( ptr, unloaded->klass(), false, NULL, off, instance_id ); }
 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; }
 }
 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()) ) {
+xk = (klass() == tap->klass());
 ptr = NotNull;
 o = NULL;
 instance_id = InstanceBot;
+} else {
+xk = true;
 }
 } else if( above_centerline(_ptr) ) {
 o = tap->const_oop();
+xk = true;
+} else {
+xk = this->_klass_is_exact;
 }
-xk = true;
 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

Mercurial > hg > truffle

comparison src/share/vm/opto/type.cpp @ 1000:a1423fe86a18