< prev index next >
src/hotspot/share/oops/instanceKlass.cpp
Print this page
@@ -437,28 +437,28 @@
}
}
void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,
const Klass* super_klass,
- Array<Klass*>* local_interfaces,
- Array<Klass*>* transitive_interfaces) {
+ Array<InstanceKlass*>* local_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;
- if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) {
+ Array<InstanceKlass*>* ti = transitive_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.
@@ -515,11 +515,11 @@
// 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() &&
+ (address)(secondary_supers()) != (address)(transitive_interfaces()) &&
!secondary_supers()->is_shared()) {
MetadataFactory::free_array<Klass*>(loader_data, secondary_supers());
}
set_secondary_supers(NULL);
@@ -753,14 +753,14 @@
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()) {
@@ -870,12 +870,11 @@
// 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 = InstanceKlass::cast(iface);
+ InstanceKlass* ik = local_interfaces()->at(i);
// 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()) {
@@ -1115,22 +1114,23 @@
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. Just don't write into it!
// Redefine classes has to be careful not to delete this!
- set_secondary_supers(interfaces);
+ 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());
@@ -1789,15 +1789,15 @@
// 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;
}
@@ -2140,15 +2140,15 @@
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;
}
@@ -2351,14 +2351,14 @@
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);
- if (InstanceKlass::cast(iface)->is_in_error_state()) {
+ InstanceKlass* iface = interfaces->at(i);
+ if (iface->is_in_error_state()) {
bad = true;
break;
}
}
}
@@ -3252,10 +3252,16 @@
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) {
st->print("a ");
name()->print_value_on(st);
@@ -3496,22 +3502,22 @@
"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
< prev index next >