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

comparison src/share/vm/opto/type.cpp @ 113:ba764ed4b6f2

6420645: Create a vm that uses compressed oops for up to 32gb heapsizes Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold

author	coleenp
date	Sun, 13 Apr 2008 17:43:42 -0400
parents	b8f5ba577b02
children	885ed790ecf0

comparison

equal deleted inserted replaced

-:a49a647afe9a
+:ba764ed4b6f2
 T_ILLEGAL,    // Control
 T_VOID,       // Top
 T_INT,        // Int
 T_LONG,       // Long
 T_VOID,       // Half
+T_NARROWOOP,  // NarrowOop
 T_ILLEGAL,    // Tuple
 T_ARRAY,      // Array
 T_ADDRESS,    // AnyPtr   // shows up in factory methods for NULL_PTR
 TypePtr::BOTTOM  = TypePtr::make( AnyPtr, TypePtr::BotPTR, OffsetBot );
 TypeRawPtr::BOTTOM = TypeRawPtr::make( TypePtr::BotPTR );
 TypeRawPtr::NOTNULL= TypeRawPtr::make( TypePtr::NotNull );
-mreg2type[Op_Node] = Type::BOTTOM;
-mreg2type[Op_Set ] = 0;
-mreg2type[Op_RegI] = TypeInt::INT;
-mreg2type[Op_RegP] = TypePtr::BOTTOM;
-mreg2type[Op_RegF] = Type::FLOAT;
-mreg2type[Op_RegD] = Type::DOUBLE;
-mreg2type[Op_RegL] = TypeLong::LONG;
-mreg2type[Op_RegFlags] = TypeInt::CC;
 const Type **fmembar = TypeTuple::fields(0);
 TypeTuple::MEMBAR = TypeTuple::make(TypeFunc::Parms+0, fmembar);
 const Type **fsc = (const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*));
 fsc[0] = TypeInt::CC;
 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);
+TypeNarrowOop::NULL_PTR = TypeNarrowOop::make( TypePtr::NULL_PTR );
+TypeNarrowOop::BOTTOM   = TypeNarrowOop::make( TypeInstPtr::BOTTOM );
+mreg2type[Op_Node] = Type::BOTTOM;
+mreg2type[Op_Set ] = 0;
+mreg2type[Op_RegN] = TypeNarrowOop::BOTTOM;
+mreg2type[Op_RegI] = TypeInt::INT;
+mreg2type[Op_RegP] = TypePtr::BOTTOM;
+mreg2type[Op_RegF] = Type::FLOAT;
+mreg2type[Op_RegD] = Type::DOUBLE;
+mreg2type[Op_RegL] = TypeLong::LONG;
+mreg2type[Op_RegFlags] = TypeInt::CC;
 TypeAryPtr::RANGE   = TypeAryPtr::make( TypePtr::BotPTR, TypeAry::make(Type::BOTTOM,TypeInt::POS), current->env()->Object_klass(), false, arrayOopDesc::length_offset_in_bytes());
 // There is no shared klass for Object[].  See note in TypeAryPtr::klass().
 TypeAryPtr::OOPS    = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInstPtr::BOTTOM,TypeInt::POS), NULL /*ciArrayKlass::make(o)*/,  false,  Type::OffsetBot);
 TypeAryPtr::BYTES   = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::BYTE      ,TypeInt::POS), ciTypeArrayKlass::make(T_BYTE),   true,  Type::OffsetBot);
 TypeAryPtr::INTS    = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::INT       ,TypeInt::POS), ciTypeArrayKlass::make(T_INT),    true,  Type::OffsetBot);
 TypeAryPtr::LONGS   = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeLong::LONG     ,TypeInt::POS), ciTypeArrayKlass::make(T_LONG),   true,  Type::OffsetBot);
 TypeAryPtr::FLOATS  = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::FLOAT        ,TypeInt::POS), ciTypeArrayKlass::make(T_FLOAT),  true,  Type::OffsetBot);
 TypeAryPtr::DOUBLES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::DOUBLE       ,TypeInt::POS), ciTypeArrayKlass::make(T_DOUBLE), true,  Type::OffsetBot);
+TypeAryPtr::_array_body_type[T_NARROWOOP] = NULL; // what should this be?
 TypeAryPtr::_array_body_type[T_OBJECT]  = TypeAryPtr::OOPS;
 TypeAryPtr::_array_body_type[T_ARRAY]   = TypeAryPtr::OOPS;   // arrays are stored in oop arrays
 TypeAryPtr::_array_body_type[T_BYTE]    = TypeAryPtr::BYTES;
 TypeAryPtr::_array_body_type[T_BOOLEAN] = TypeAryPtr::BYTES;  // boolean[] is a byte array
 TypeAryPtr::_array_body_type[T_SHORT]   = TypeAryPtr::SHORTS;
 const Type **longpair = TypeTuple::fields(2);
 longpair[0] = TypeLong::LONG;
 longpair[1] = TypeLong::LONG;
 TypeTuple::LONG_PAIR = TypeTuple::make(2, longpair);
+_const_basic_type[T_NARROWOOP] = TypeNarrowOop::BOTTOM;
 _const_basic_type[T_BOOLEAN] = TypeInt::BOOL;
 _const_basic_type[T_CHAR]    = TypeInt::CHAR;
 _const_basic_type[T_BYTE]    = TypeInt::BYTE;
 _const_basic_type[T_SHORT]   = TypeInt::SHORT;
 _const_basic_type[T_INT]     = TypeInt::INT;
 _const_basic_type[T_ARRAY]   = TypeInstPtr::BOTTOM; // there is no separate bottom for arrays
 _const_basic_type[T_VOID]    = TypePtr::NULL_PTR;   // reflection represents void this way
 _const_basic_type[T_ADDRESS] = TypeRawPtr::BOTTOM;  // both interpreter return addresses & random raw ptrs
 _const_basic_type[T_CONFLICT]= Type::BOTTOM;        // why not?
+_zero_type[T_NARROWOOP] = TypeNarrowOop::NULL_PTR;
 _zero_type[T_BOOLEAN] = TypeInt::ZERO;     // false == 0
 _zero_type[T_CHAR]    = TypeInt::ZERO;     // '\0' == 0
 _zero_type[T_BYTE]    = TypeInt::ZERO;     // 0x00 == 0
 _zero_type[T_SHORT]   = TypeInt::ZERO;     // 0x0000 == 0
 _zero_type[T_INT]     = TypeInt::ZERO;
 DictI i(_shared_type_dict);
 for( ; i.test(); ++i ) {
 Type* t = (Type*)i._value;
 tdic->Insert(t,t);  // New Type, insert into Type table
 }
+#ifdef ASSERT
+verify_lastype();
+#endif
 }
 //------------------------------hashcons---------------------------------------
 // Do the hash-cons trick.  If the Type already exists in the type table,
 // delete the current Type and return the existing Type.  Otherwise stick the
 //------------------------------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());
+if (result->isa_oopptr()) {
+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
 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(   _dual);
 return t->xmeet(this);
 case AryPtr:
 return t->xmeet(this);
+case NarrowOop:
+return t->xmeet(this);
 case Bad:                     // Type check
 default:                      // Bogus type not in lattice
 typerr(t);
 return Type::BOTTOM;
 Control,      // Control
 Bottom,       // Top
 Bad,          // Int - handled in v-call
 Bad,          // Long - handled in v-call
 Half,         // Half
+Bad,          // NarrowOop - handled in v-call
 Bad,          // Tuple - handled in v-call
 Bad,          // Array - handled in v-call
 Bad,          // AnyPtr - handled in v-call
 //------------------------------dump-------------------------------------------
 void Type::dump_on(outputStream *st) const {
 ResourceMark rm;
 Dict d(cmpkey,hashkey);       // Stop recursive type dumping
 dump2(d,1, st);
+if (isa_ptr() && is_ptr()->is_narrow()) {
+st->print(" [narrow]");
+}
 }
 //------------------------------data-------------------------------------------
 const char * const Type::msg[Type::lastype] = {
-"bad","control","top","int:","long:","half",
+"bad","control","top","int:","long:","half", "narrowoop:",
 "tuple:", "aryptr",
 "anyptr:", "rawptr:", "java:", "inst:", "ary:", "klass:",
 "func", "abIO", "return_address", "memory",
 "float_top", "ftcon:", "float",
 "double_top", "dblcon:", "double",
 }
 //------------------------------isa_oop_ptr------------------------------------
 // Return true if type is an oop pointer type.  False for raw pointers.
 static char isa_oop_ptr_tbl[Type::lastype] = {
-0,0,0,0,0,0,0/*tuple*/, 0/*ary*/,
+0,0,0,0,0,0,0/*narrowoop*/,0/*tuple*/, 0/*ary*/,
 0/*anyptr*/,0/*rawptr*/,1/*OopPtr*/,1/*InstPtr*/,1/*AryPtr*/,1/*KlassPtr*/,
 0/*func*/,0,0/*return_address*/,0,
 /*floats*/0,0,0, /*doubles*/0,0,0,
 0
 };
 case FloatCon:
 case FloatBot:
 case DoubleTop:
 case DoubleCon:
 case DoubleBot:
+case NarrowOop:
 case Bottom:                  // Ye Olde Default
 return Type::BOTTOM;
 default:                      // All else is a mistake
 typerr(t);
 case Top:                     // No change
 return size;
 }
 //------------------------------make-------------------------------------------
 const TypeAry *TypeAry::make( const Type *elem, const TypeInt *size) {
+if (UseCompressedOops && elem->isa_oopptr()) {
+elem = elem->is_oopptr()->make_narrowoop();
+}
 size = normalize_array_size(size);
 return (TypeAry*)(new TypeAry(elem,size))->hashcons();
 }
 //------------------------------meet-------------------------------------------
 // This logic looks at the element type of an array, and returns true
 // 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 = _elem->isa_oopptr();
+const TypeOopPtr*  toop = NULL;
+if (UseCompressedOops) {
+const TypeNarrowOop* noop = _elem->isa_narrowoop();
+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 = _elem->isa_instptr();
+const TypeInstPtr* tinst;
+if (_elem->isa_narrowoop())
+tinst = _elem->is_narrowoop()->make_oopptr()->isa_instptr();
+else
+tinst = _elem->isa_instptr();
 if (tinst)                return tklass->as_instance_klass()->is_final();
-const TypeAryPtr*  tap = _elem->isa_aryptr();
+const TypeAryPtr*  tap;
+if (_elem->isa_narrowoop())
+tap = _elem->is_narrowoop()->make_oopptr()->isa_aryptr();
+else
+tap = _elem->isa_aryptr();
 if (tap)                  return tap->ary()->ary_must_be_exact();
 return false;
 }
 //=============================================================================
 case FloatCon:
 case FloatBot:
 case DoubleTop:
 case DoubleCon:
 case DoubleBot:
+case NarrowOop:
 case Bottom:                  // Ye Olde Default
 return Type::BOTTOM;
 case Top:
 return this;
 //------------------------------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;
 case FloatCon:
 case FloatBot:
 case DoubleTop:
 case DoubleCon:
 case DoubleBot:
+case NarrowOop:
 case Bottom:                  // Ye Olde Default
 return Type::BOTTOM;
 case Top:
 return this;
 static jint max_array_length(BasicType etype) {
 jint& cache = max_array_length_cache[etype];
 jint res = cache;
 if (res == 0) {
 switch (etype) {
+case T_NARROWOOP:
+etype = T_OBJECT;
+break;
 case T_CONFLICT:
 case T_ILLEGAL:
 case T_VOID:
 etype = T_BYTE;           // will produce conservatively high value
 }
 case FloatCon:
 case FloatBot:
 case DoubleTop:
 case DoubleCon:
 case DoubleBot:
+case NarrowOop:
 case Bottom:                  // Ye Olde Default
 return Type::BOTTOM;
 case Top:
 return this;
 return make( _ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _instance_id );
 }
 //=============================================================================
+const TypeNarrowOop *TypeNarrowOop::BOTTOM;
+const TypeNarrowOop *TypeNarrowOop::NULL_PTR;
+const TypeNarrowOop* TypeNarrowOop::make(const TypePtr* type) {
+return (const TypeNarrowOop*)(new TypeNarrowOop(type))->hashcons();
+}
+//------------------------------hash-------------------------------------------
+// Type-specific hashing function.
+int TypeNarrowOop::hash(void) const {
+return _ooptype->hash() + 7;
+}
+bool TypeNarrowOop::eq( const Type *t ) const {
+const TypeNarrowOop* tc = t->isa_narrowoop();
+if (tc != NULL) {
+if (_ooptype->base() != tc->_ooptype->base()) {
+return false;
+}
+return tc->_ooptype->eq(_ooptype);
+}
+return false;
+}
+bool TypeNarrowOop::singleton(void) const {    // TRUE if type is a singleton
+return _ooptype->singleton();
+}
+bool TypeNarrowOop::empty(void) const {
+return _ooptype->empty();
+}
+//------------------------------meet-------------------------------------------
+// Compute the MEET of two types.  It returns a new Type object.
+const Type *TypeNarrowOop::xmeet( const Type *t ) const {
+// Perform a fast test for common case; meeting the same types together.
+if( this == t ) return this;  // Meeting same type-rep?
+// Current "this->_base" is OopPtr
+switch (t->base()) {          // switch on original type
+case Int:                     // Mixing ints & oops happens when javac
+case Long:                    // reuses local variables
+case FloatTop:
+case FloatCon:
+case FloatBot:
+case DoubleTop:
+case DoubleCon:
+case DoubleBot:
+case Bottom:                  // Ye Olde Default
+return Type::BOTTOM;
+case Top:
+return this;
+case NarrowOop: {
+const Type* result = _ooptype->xmeet(t->is_narrowoop()->make_oopptr());
+if (result->isa_ptr()) {
+return TypeNarrowOop::make(result->is_ptr());
+}
+return result;
+}
+default:                      // All else is a mistake
+typerr(t);
+case RawPtr:
+case AnyPtr:
+case OopPtr:
+case InstPtr:
+case KlassPtr:
+case AryPtr:
+typerr(t);
+return Type::BOTTOM;
+} // End of switch
+}
+const Type *TypeNarrowOop::xdual() const {    // Compute dual right now.
+const TypePtr* odual = _ooptype->dual()->is_ptr();
+return new TypeNarrowOop(odual);
+}
+const Type *TypeNarrowOop::filter( const Type *kills ) const {
+if (kills->isa_narrowoop()) {
+const Type* ft =_ooptype->filter(kills->is_narrowoop()->_ooptype);
+if (ft->empty())
+return Type::TOP;           // Canonical empty value
+if (ft->isa_ptr()) {
+return make(ft->isa_ptr());
+}
+return ft;
+} else if (kills->isa_ptr()) {
+const Type* ft = _ooptype->join(kills);
+if (ft->empty())
+return Type::TOP;           // Canonical empty value
+return ft;
+} else {
+return Type::TOP;
+}
+}
+intptr_t TypeNarrowOop::get_con() const {
+return _ooptype->get_con();
+}
+#ifndef PRODUCT
+void TypeNarrowOop::dump2( Dict & d, uint depth, outputStream *st ) const {
+tty->print("narrowoop: ");
+_ooptype->dump2(d, depth, st);
+}
+#endif
+//=============================================================================
 // Convenience common pre-built types.
 // Not-null object klass or below
 const TypeKlassPtr *TypeKlassPtr::OBJECT;
 const TypeKlassPtr *TypeKlassPtr::OBJECT_OR_NULL;
 // Oops, need to compute _klass and cache it
 ciKlass* k_ary = NULL;
 const TypeInstPtr *tinst;
 const TypeAryPtr *tary;
+const Type* el = elem();
+if (el->isa_narrowoop()) {
+el = el->is_narrowoop()->make_oopptr();
+}
 // Get element klass
-if ((tinst = elem()->isa_instptr()) != NULL) {
+if ((tinst = el->isa_instptr()) != NULL) {
 // Compute array klass from element klass
 k_ary = ciObjArrayKlass::make(tinst->klass());
-} else if ((tary = elem()->isa_aryptr()) != NULL) {
+} else if ((tary = el->isa_aryptr()) != NULL) {
 // Compute array klass from element klass
 ciKlass* k_elem = tary->klass();
 // If element type is something like bottom[], k_elem will be null.
 if (k_elem != NULL)
 k_ary = ciObjArrayKlass::make(k_elem);
-} else if ((elem()->base() == Type::Top) ||
+} else if ((el->base() == Type::Top) ||
-(elem()->base() == Type::Bottom)) {
+(el->base() == Type::Bottom)) {
 // element type of Bottom occurs from meet of basic type
 // and object; Top occurs when doing join on Bottom.
 // Leave k_ary at NULL.
 } else {
 // Cannot compute array klass directly from basic type,
 // since subtypes of TypeInt all have basic type T_INT.
-assert(!elem()->isa_int(),
+assert(!el->isa_int(),
 "integral arrays must be pre-equipped with a class");
 // Compute array klass directly from basic type
-k_ary = ciTypeArrayKlass::make(elem()->basic_type());
+k_ary = ciTypeArrayKlass::make(el->basic_type());
 }
 if( this != TypeAryPtr::OOPS )
 // The _klass field acts as a cache of the underlying
 // ciKlass for this array type.  In order to set the field,
 }
 //------------------------------print_flattened--------------------------------
 // Print a 'flattened' signature
 static const char * const flat_type_msg[Type::lastype] = {
-"bad","control","top","int","long","_",
+"bad","control","top","int","long","_", "narrowoop",
 "tuple:", "array:",
 "ptr", "rawptr", "ptr", "ptr", "ptr", "ptr",
 "func", "abIO", "return_address", "mem",
 "float_top", "ftcon:", "flt",
 "double_top", "dblcon:", "dbl",

Mercurial > hg > truffle

comparison src/share/vm/opto/type.cpp @ 113:ba764ed4b6f2