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

equal deleted inserted replaced

-:6bf8877eb1b9
+:677cede5608e
 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.
 const Type* con_type = NULL;
 ciObject* oop_constant = constant.as_object();
 if (oop_constant->is_null_object()) {
 con_type = Type::get_zero_type(T_OBJECT);
 } else {
 //------------------------------make_from_constant-----------------------------
 // Make a java pointer from an oop constant
 const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) {
 assert(!o->is_null_object(), "null object not yet handled here.");
+const bool make_constant = require_constant || o->should_be_constant();
 ciKlass* klass = o->klass();
 if (klass->is_instance_klass()) {
 // Element is an instance
-if (require_constant) {
+if (make_constant) {
-if (!o->can_be_constant())  return NULL;
+return TypeInstPtr::make(o);
-} else if (!o->should_be_constant()) {
+} else {
 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.
 const TypeOopPtr *etype =
 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 (require_constant) {
+if (make_constant) {
-if (!o->can_be_constant())  return NULL;
+return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
-} else if (!o->should_be_constant()) {
+} else {
 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()) {
 // Element is an typeArray
 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 (require_constant) {
+if (make_constant) {
-if (!o->can_be_constant())  return NULL;
+return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
-} else if (!o->should_be_constant()) {
+} else {
 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
 }
-const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
-return arr;
 }
 fatal("unhandled object type");
 return NULL;
 }

changeset 54120	677cede5608e
parent 53623	83b40a7bf00d
child 55393	5dcab10ebfbe
child 55604	a30c86af2eb7
child 58678	9cf78a70fa4f