jdk8-mips64-public/hotspot: comparison src/share/vm/oops/objArrayKlass.cpp

-:6b6ddf8c4329
+:80e866b1d053
 // Also, see if the element has secondary supertypes.
 // We need an array type for each.
 Array<Klass*>* element_supers = element_klass->secondary_supers();
 for( int i = element_supers->length()-1; i >= 0; i-- ) {
 Klass* elem_super = element_supers->at(i);
-if (Klass::cast(elem_super)->array_klass_or_null() == NULL) {
+if (elem_super->array_klass_or_null() == NULL) {
 supers_exist = false;
 break;
 }
 }
 if (!supers_exist) {
 if (element_klass->oop_is_objArray()) {
 bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
 } else {
 bk = element_klass();
 }
-assert(bk != NULL && (Klass::cast(bk)->oop_is_instance() || Klass::cast(bk)->oop_is_typeArray()), "invalid bottom klass");
+assert(bk != NULL && (bk->oop_is_instance() || bk->oop_is_typeArray()), "invalid bottom klass");
 this->set_bottom_klass(bk);
 this->set_class_loader_data(bk->class_loader_data());
 this->set_layout_helper(array_layout_helper(T_OBJECT));
 assert(this->oop_is_array(), "sanity");
 Copy::conjoint_oops_atomic(src, dst, length);
 } else {
 // We have to make sure all elements conform to the destination array
 Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();
 Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();
-if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
+if (stype == bound || stype->is_subtype_of(bound)) {
 // elements are guaranteed to be subtypes, so no check necessary
 bs->write_ref_array_pre(dst, length);
 Copy::conjoint_oops_atomic(src, dst, length);
 } else {
 // slow case: need individual subtype checks
 // even slower now
 bool element_is_null = oopDesc::is_null(element);
 oop new_val = element_is_null ? oop(NULL)
 : oopDesc::decode_heap_oop_not_null(element);
 if (element_is_null ||
-Klass::cast((new_val->klass()))->is_subtype_of(bound)) {
+(new_val->klass())->is_subtype_of(bound)) {
 bs->write_ref_field_pre(p, new_val);
 *p = *from;
 } else {
 // We must do a barrier to cover the partial copy.
 const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize);
 return Klass::can_be_primary_super_slow();
 }
 GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) {
 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
-Array<Klass*>* elem_supers = Klass::cast(element_klass())->secondary_supers();
+Array<Klass*>* elem_supers = element_klass()->secondary_supers();
 int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length();
 int num_secondaries = num_extra_slots + 2 + num_elem_supers;
 if (num_secondaries == 2) {
 // Must share this for correct bootstrapping!
 set_secondary_supers(Universe::the_array_interfaces_array());
 ObjArrayKlass* oak = ObjArrayKlass::cast(k);
 return element_klass()->is_subtype_of(oak->element_klass());
 }
 void ObjArrayKlass::initialize(TRAPS) {
-Klass::cast(bottom_klass())->initialize(THREAD);  // dispatches to either InstanceKlass or TypeArrayKlass
+bottom_klass()->initialize(THREAD);  // dispatches to either InstanceKlass or TypeArrayKlass
 }
 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
 {                                   \
 T* p         = (T*)(a)->base();   \
 if (element_klass() == NULL) {
 assert(Universe::is_bootstrapping(), "partial objArray only at startup");
 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
 }
 // Return the flags of the bottom element type.
-jint element_flags = Klass::cast(bottom_klass())->compute_modifier_flags(CHECK_0);
+jint element_flags = bottom_klass()->compute_modifier_flags(CHECK_0);
 return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED))
 | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL);
 }
 ArrayKlass::verify_on(st);
 guarantee(element_klass()->is_metadata(), "should be in metaspace");
 guarantee(element_klass()->is_klass(), "should be klass");
 guarantee(bottom_klass()->is_metadata(), "should be in metaspace");
 guarantee(bottom_klass()->is_klass(), "should be klass");
-Klass* bk = Klass::cast(bottom_klass());
+Klass* bk = bottom_klass();
 guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(),  "invalid bottom klass");
 }
 void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) {
 ArrayKlass::oop_verify_on(obj, st);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/oops/objArrayKlass.cpp

src/share/vm/oops/objArrayKlass.cpp