jdk-sandbox: comparison src/hotspot/share/oops/instanceKlass.cpp

equal deleted inserted replaced

-:fad2334b2906
+:9c68699bebe5
 }
 }
 void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,
 const Klass* super_klass,
-Array<Klass*>* local_interfaces,
+Array<InstanceKlass*>* local_interfaces,
-Array<Klass*>* transitive_interfaces) {
+Array<InstanceKlass*>* transitive_interfaces) {
 // Only deallocate transitive interfaces if not empty, same as super class
 // or same as local interfaces.  See code in parseClassFile.
-Array<Klass*>* ti = transitive_interfaces;
+Array<InstanceKlass*>* ti = transitive_interfaces;
-if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) {
+if (ti != Universe::the_empty_instance_klass_array() && ti != local_interfaces) {
 // check that the interfaces don't come from super class
-Array<Klass*>* sti = (super_klass == NULL) ? NULL :
+Array<InstanceKlass*>* sti = (super_klass == NULL) ? NULL :
 InstanceKlass::cast(super_klass)->transitive_interfaces();
 if (ti != sti && ti != NULL && !ti->is_shared()) {
-MetadataFactory::free_array<Klass*>(loader_data, ti);
+MetadataFactory::free_array<InstanceKlass*>(loader_data, ti);
 }
 }
 // local interfaces can be empty
-if (local_interfaces != Universe::the_empty_klass_array() &&
+if (local_interfaces != Universe::the_empty_instance_klass_array() &&
 local_interfaces != NULL && !local_interfaces->is_shared()) {
-MetadataFactory::free_array<Klass*>(loader_data, local_interfaces);
+MetadataFactory::free_array<InstanceKlass*>(loader_data, local_interfaces);
 }
 }
 // This function deallocates the metadata and C heap pointers that the
 // InstanceKlass points to.
 // This array is in Klass, but remove it with the InstanceKlass since
 // this place would be the only caller and it can share memory with transitive
 // interfaces.
 if (secondary_supers() != NULL &&
 secondary_supers() != Universe::the_empty_klass_array() &&
-secondary_supers() != transitive_interfaces() &&
+// see comments in compute_secondary_supers about the following cast
+(address)(secondary_supers()) != (address)(transitive_interfaces()) &&
 !secondary_supers()->is_shared()) {
 MetadataFactory::free_array<Klass*>(loader_data, secondary_supers());
 }
 set_secondary_supers(NULL);
 InstanceKlass* ik_super = InstanceKlass::cast(super_klass);
 ik_super->link_class_impl(throw_verifyerror, CHECK_false);
 }
 // link all interfaces implemented by this class before linking this class
-Array<Klass*>* interfaces = local_interfaces();
+Array<InstanceKlass*>* interfaces = local_interfaces();
 int num_interfaces = interfaces->length();
 for (int index = 0; index < num_interfaces; index++) {
-InstanceKlass* interk = InstanceKlass::cast(interfaces->at(index));
+InstanceKlass* interk = interfaces->at(index);
 interk->link_class_impl(throw_verifyerror, CHECK_false);
 }
 // in case the class is linked in the process of linking its superclasses
 if (is_linked()) {
 // Eagerly initialize superinterfaces that declare default methods (concrete instance: any access)
 void InstanceKlass::initialize_super_interfaces(TRAPS) {
 assert (has_nonstatic_concrete_methods(), "caller should have checked this");
 for (int i = 0; i < local_interfaces()->length(); ++i) {
-Klass* iface = local_interfaces()->at(i);
+InstanceKlass* ik = local_interfaces()->at(i);
-InstanceKlass* ik = InstanceKlass::cast(iface);
 // Initialization is depth first search ie. we start with top of the inheritance tree
 // has_nonstatic_concrete_methods drives searching superinterfaces since it
 // means has_nonstatic_concrete_methods in its superinterface hierarchy
 if (ik->has_nonstatic_concrete_methods()) {
 else
 return Klass::can_be_primary_super_slow();
 }
 GrowableArray<Klass*>* InstanceKlass::compute_secondary_supers(int num_extra_slots,
-Array<Klass*>* transitive_interfaces) {
+Array<InstanceKlass*>* transitive_interfaces) {
 // The secondaries are the implemented interfaces.
-Array<Klass*>* interfaces = transitive_interfaces;
+Array<InstanceKlass*>* interfaces = transitive_interfaces;
 int num_secondaries = num_extra_slots + interfaces->length();
 if (num_secondaries == 0) {
 // Must share this for correct bootstrapping!
 set_secondary_supers(Universe::the_empty_klass_array());
 return NULL;
 } else if (num_extra_slots == 0) {
-// The secondary super list is exactly the same as the transitive interfaces.
+// The secondary super list is exactly the same as the transitive interfaces, so
+// let's use it instead of making a copy.
 // Redefine classes has to be careful not to delete this!
-set_secondary_supers(interfaces);
+// We need the cast because Array<Klass*> is NOT a supertype of Array<InstanceKlass*>,
+// (but it's safe to do here because we won't write into _secondary_supers from this point on).
+set_secondary_supers((Array<Klass*>*)(address)interfaces);
 return NULL;
 } else {
 // Copy transitive interfaces to a temporary growable array to be constructed
 // into the secondary super list with extra slots.
 GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(interfaces->length());
 // Do NOT return private or static methods, new in JDK8 which are not externally visible
 // They should only be found in the initial InterfaceMethodRef
 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
 Symbol* signature,
 DefaultsLookupMode defaults_mode) const {
-Array<Klass*>* all_ifs = transitive_interfaces();
+Array<InstanceKlass*>* all_ifs = transitive_interfaces();
 int num_ifs = all_ifs->length();
 InstanceKlass *ik = NULL;
 for (int i = 0; i < num_ifs; i++) {
-ik = InstanceKlass::cast(all_ifs->at(i));
+ik = all_ifs->at(i);
 Method* m = ik->lookup_method(name, signature);
 if (m != NULL && m->is_public() && !m->is_static() &&
 ((defaults_mode != skip_defaults) || !m->is_default_method())) {
 return m;
 }
 ResourceMark rm;
 log_trace(class, fingerprint)("%s : super %s not fingerprinted", external_name(), java_super()->external_name());
 return false;
 }
-Array<Klass*>* local_interfaces = this->local_interfaces();
+Array<InstanceKlass*>* local_interfaces = this->local_interfaces();
 if (local_interfaces != NULL) {
 int length = local_interfaces->length();
 for (int i = 0; i < length; i++) {
-InstanceKlass* intf = InstanceKlass::cast(local_interfaces->at(i));
+InstanceKlass* intf = local_interfaces->at(i);
 if (!intf->has_passed_fingerprint_check()) {
 ResourceMark rm;
 log_trace(class, fingerprint)("%s : interface %s not fingerprinted", external_name(), intf->external_name());
 return false;
 }
 bad = true;
 break;
 }
 }
 if (!bad) {
-Array<Klass*>* interfaces = transitive_interfaces();
+Array<InstanceKlass*>* interfaces = transitive_interfaces();
 for (int i = 0; i < interfaces->length(); i++) {
-Klass* iface = interfaces->at(i);
+InstanceKlass* iface = interfaces->at(i);
-if (InstanceKlass::cast(iface)->is_in_error_state()) {
+if (iface->is_in_error_state()) {
 bad = true;
 break;
 }
 }
 }
 } else if (this == SystemDictionary::MethodType_klass()) {
 st->print(BULLET"signature: ");
 java_lang_invoke_MethodType::print_signature(obj, st);
 st->cr();
 }
+}
+bool InstanceKlass::verify_itable_index(int i) {
+int method_count = klassItable::method_count_for_interface(this);
+assert(i >= 0 && i < method_count, "index out of bounds");
+return true;
 }
 #endif //PRODUCT
 void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) {
 "implementors cannot be interfaces");
 }
 // Verify local interfaces
 if (local_interfaces()) {
-Array<Klass*>* local_interfaces = this->local_interfaces();
+Array<InstanceKlass*>* local_interfaces = this->local_interfaces();
 for (int j = 0; j < local_interfaces->length(); j++) {
-Klass* e = local_interfaces->at(j);
+InstanceKlass* e = local_interfaces->at(j);
 guarantee(e->is_klass() && e->is_interface(), "invalid local interface");
 }
 }
 // Verify transitive interfaces
 if (transitive_interfaces() != NULL) {
-Array<Klass*>* transitive_interfaces = this->transitive_interfaces();
+Array<InstanceKlass*>* transitive_interfaces = this->transitive_interfaces();
 for (int j = 0; j < transitive_interfaces->length(); j++) {
-Klass* e = transitive_interfaces->at(j);
+InstanceKlass* e = transitive_interfaces->at(j);
 guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface");
 }
 }
 // Verify methods

changeset 51329	9c68699bebe5
parent 51268	4ac20e5f96ce
child 51334	cc2c79d22508