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

comparison src/share/vm/opto/type.cpp @ 221:1e026f8da827

6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode Summary: Remove DecodeNNode::decode() and EncodePNode::encode() methods. Reviewed-by: rasbold, never

author	kvn
date	Tue, 24 Jun 2008 10:43:29 -0700
parents	d4dbd9f91680
children	1dd146f17531

comparison

equal deleted inserted replaced

-:30369db7f5d2
+:1e026f8da827
 // Create a simple Type, with default empty symbol sets.  Then hashcons it
 // and look for an existing copy in the type dictionary.
 const Type *Type::make( enum TYPES t ) {
 return (new Type(t))->hashcons();
 }
+/*
+//------------------------------make_ptr---------------------------------------
+// Returns this ptr type or the equivalent ptr type for this compressed pointer.
+const TypePtr* Type::make_ptr() const {
+return (_base == NarrowOop) ? is_narrowoop()->make_oopptr() : is_ptr();
+}
+//------------------------------make_narrowoop---------------------------------
+// Returns this compressed pointer or the equivalent compressed version
+// of this pointer type.
+const TypeNarrowOop* Type::make_narrowoop() const {
+return (_base == NarrowOop) ? is_narrowoop() : TypeNarrowOop::make(is_ptr());
+}
+*/
 //------------------------------cmp--------------------------------------------
 int Type::cmp( const Type *const t1, const Type *const t2 ) {
 if( t1->_base != t2->_base )
 return 1;                   // Missed badly
 assert(t1 != t2 || t1->eq(t2), "eq must be reflexive");
 //------------------------------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
 }
 //------------------------------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.
 //------------------------------add_offset-------------------------------------
 const TypePtr *TypeOopPtr::add_offset( int offset ) const {
 return make( _ptr, xadd_offset(offset) );
 }
-const TypeNarrowOop* TypeOopPtr::make_narrowoop() const {
-return TypeNarrowOop::make(this);
-}
 int TypeOopPtr::meet_instance(int iid) const {
 if (iid == 0) {
 return (_instance_id < 0)  ? _instance_id : UNKNOWN_INSTANCE;
 } else if (_instance_id == UNKNOWN_INSTANCE) {
 return (iid < 0)  ? iid : UNKNOWN_INSTANCE;
 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 > hg > graal-jvmci-8

comparison src/share/vm/opto/type.cpp @ 221:1e026f8da827