jdk-sandbox: comparison hotspot/src/share/vm/opto/type.cpp

equal deleted inserted replaced

-:239cc27c7524
+:7cb9f982ea81
 assert(type != ciTypeFlow::StateVector::double2_type(), "");
 assert(!type->is_return_address(), "");
 return Type::get_const_type(type);
 }
+}
+//-----------------------make_from_constant------------------------------------
+const Type* Type::make_from_constant(ciConstant constant,
+bool require_constant, bool is_autobox_cache) {
+switch (constant.basic_type()) {
+case T_BOOLEAN:  return TypeInt::make(constant.as_boolean());
+case T_CHAR:     return TypeInt::make(constant.as_char());
+case T_BYTE:     return TypeInt::make(constant.as_byte());
+case T_SHORT:    return TypeInt::make(constant.as_short());
+case T_INT:      return TypeInt::make(constant.as_int());
+case T_LONG:     return TypeLong::make(constant.as_long());
+case T_FLOAT:    return TypeF::make(constant.as_float());
+case T_DOUBLE:   return TypeD::make(constant.as_double());
+case T_ARRAY:
+case T_OBJECT:
+{
+// cases:
+//   can_be_constant    = (oop not scavengable || ScavengeRootsInCode != 0)
+//   should_be_constant = (oop not scavengable || ScavengeRootsInCode >= 2)
+// An oop is not scavengable if it is in the perm gen.
+ciObject* oop_constant = constant.as_object();
+if (oop_constant->is_null_object()) {
+return Type::get_zero_type(T_OBJECT);
+} else if (require_constant || oop_constant->should_be_constant()) {
+return TypeOopPtr::make_from_constant(oop_constant, require_constant, is_autobox_cache);
+}
+}
+}
+// Fall through to failure
+return NULL;
 }
 //------------------------------make-------------------------------------------
 // Create a simple Type, with default empty symbol sets.  Then hashcons it
 else
 return size;
 }
 //------------------------------make-------------------------------------------
-const TypeAry *TypeAry::make( const Type *elem, const TypeInt *size) {
+const TypeAry* TypeAry::make(const Type* elem, const TypeInt* size, bool stable) {
 if (UseCompressedOops && elem->isa_oopptr()) {
 elem = elem->make_narrowoop();
 }
 size = normalize_array_size(size);
-return (TypeAry*)(new TypeAry(elem,size))->hashcons();
+return (TypeAry*)(new TypeAry(elem,size,stable))->hashcons();
 }
 //------------------------------meet-------------------------------------------
 // Compute the MEET of two types.  It returns a new Type object.
 const Type *TypeAry::xmeet( const Type *t ) const {
 typerr(t);
 case Array: {                 // Meeting 2 arrays?
 const TypeAry *a = t->is_ary();
 return TypeAry::make(_elem->meet(a->_elem),
-_size->xmeet(a->_size)->is_int());
+_size->xmeet(a->_size)->is_int(),
+_stable & a->_stable);
 }
 case Top:
 break;
 }
 return this;                  // Return the double constant
 //------------------------------xdual------------------------------------------
 // Dual: compute field-by-field dual
 const Type *TypeAry::xdual() const {
 const TypeInt* size_dual = _size->dual()->is_int();
 size_dual = normalize_array_size(size_dual);
-return new TypeAry( _elem->dual(), size_dual);
+return new TypeAry(_elem->dual(), size_dual, !_stable);
 }
 //------------------------------eq---------------------------------------------
 // Structural equality check for Type representations
 bool TypeAry::eq( const Type *t ) const {
 const TypeAry *a = (const TypeAry*)t;
 return _elem == a->_elem &&
+_stable == a->_stable &&
 _size == a->_size;
 }
 //------------------------------hash-------------------------------------------
 // Type-specific hashing function.
 int TypeAry::hash(void) const {
-return (intptr_t)_elem + (intptr_t)_size;
+return (intptr_t)_elem + (intptr_t)_size + (_stable ? 43 : 0);
 }
 //----------------------interface_vs_oop---------------------------------------
 #ifdef ASSERT
 bool TypeAry::interface_vs_oop(const Type *t) const {
 #endif
 //------------------------------dump2------------------------------------------
 #ifndef PRODUCT
 void TypeAry::dump2( Dict &d, uint depth, outputStream *st ) const {
+if (_stable)  st->print("stable:");
 _elem->dump2(d, depth, st);
 st->print("[");
 _size->dump2(d, depth, st);
 st->print("]");
 }
 //-------------------------------cast_to_size----------------------------------
 const TypeAryPtr* TypeAryPtr::cast_to_size(const TypeInt* new_size) const {
 assert(new_size != NULL, "");
 new_size = narrow_size_type(new_size);
 if (new_size == size())  return this;
-const TypeAry* new_ary = TypeAry::make(elem(), new_size);
+const TypeAry* new_ary = TypeAry::make(elem(), new_size, is_stable());
 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id);
 }
+//------------------------------cast_to_stable---------------------------------
+const TypeAryPtr* TypeAryPtr::cast_to_stable(bool stable, int stable_dimension) const {
+if (stable_dimension <= 0 || (stable_dimension == 1 && stable == this->is_stable()))
+return this;
+const Type* elem = this->elem();
+const TypePtr* elem_ptr = elem->make_ptr();
+if (stable_dimension > 1 && elem_ptr != NULL && elem_ptr->isa_aryptr()) {
+// If this is widened from a narrow oop, TypeAry::make will re-narrow it.
+elem = elem_ptr = elem_ptr->is_aryptr()->cast_to_stable(stable, stable_dimension - 1);
+}
+const TypeAry* new_ary = TypeAry::make(elem, size(), stable);
+return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id);
+}
+//-----------------------------stable_dimension--------------------------------
+int TypeAryPtr::stable_dimension() const {
+if (!is_stable())  return 0;
+int dim = 1;
+const TypePtr* elem_ptr = elem()->make_ptr();
+if (elem_ptr != NULL && elem_ptr->isa_aryptr())
+dim += elem_ptr->is_aryptr()->stable_dimension();
+return dim;
+}
 //------------------------------eq---------------------------------------------
 // Structural equality check for Type representations
 bool TypeAryPtr::eq( const Type *t ) const {
 const TypeAryPtr *p = t->is_aryptr();
 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);
+tary = TypeAry::make(Type::BOTTOM, tary->_size, tary->_stable);
 }
 } else // Non integral arrays.
 // Must fall to bottom if exact klasses in upper lattice
 // are not equal or super klass is exact.
 if ( above_centerline(ptr) && klass() != tap->klass() &&
 ((tap ->_klass_is_exact && this->_klass_is_exact) ||
 // 'tap'  is exact and super or unrelated:
 (tap ->_klass_is_exact && !tap->klass()->is_subtype_of(klass())) ||
 // 'this' is exact and super or unrelated:
 (this->_klass_is_exact && !klass()->is_subtype_of(tap->klass())))) {
-tary = TypeAry::make(Type::BOTTOM, tary->_size);
+tary = TypeAry::make(Type::BOTTOM, tary->_size, tary->_stable);
 return make( NotNull, NULL, tary, lazy_klass, false, off, InstanceBot );
 }
 bool xk = false;
 switch (tap->ptr()) {

changeset 19770	7cb9f982ea81
parent 17383	3665c0901a0d
child 19995	55af95bea4e7