truffle: src/share/vm/oops/klassVtable.cpp comparison

comparison src/share/vm/oops/klassVtable.cpp @ 13055:fce21ac5968d

8027229: ICCE expected for >=2 maximally specific default methods. Summary: Need to process defaults for interfaces for invokespecial Reviewed-by: lfoltan, hseigel, coleenp, jrose

author	acorn
date	Wed, 13 Nov 2013 07:31:26 -0800
parents	ac9cb1d5a202
children	9d15b81d5d1b

comparison

equal deleted inserted replaced

-:19f8a5d7600b
+:fce21ac5968d
 GrowableArray<Method*> new_mirandas(20);
 // compute the number of mirandas methods that must be added to the end
 get_mirandas(&new_mirandas, all_mirandas, super, methods, NULL, local_interfaces);
 *num_new_mirandas = new_mirandas.length();
-vtable_length += *num_new_mirandas * vtableEntry::size();
+// Interfaces do not need interface methods in their vtables
+// This includes miranda methods and during later processing, default methods
+if (!class_flags.is_interface()) {
+vtable_length += *num_new_mirandas * vtableEntry::size();
+}
 if (Universe::is_bootstrapping() && vtable_length == 0) {
 // array classes don't have their superclass set correctly during
 // bootstrapping
 vtable_length = Universe::base_vtable_size();
 }
 }
 }
 // add miranda methods; it will also return the updated initialized
-initialized = fill_in_mirandas(initialized);
+// Interfaces do not need interface methods in their vtables
+// This includes miranda methods and during later processing, default methods
+if (!ik()->is_interface()) {
+initialized = fill_in_mirandas(initialized);
+}
 // In class hierarchies where the accessibility is not increasing (i.e., going from private ->
 // package_private -> public/protected), the vtable might actually be smaller than our initial
 // calculation.
 assert(initialized <= _length, "vtable initialization failed");
 tty->print("transitive overriding superclass %s with %s::%s index %d, original flags: ",
 supersuperklass->internal_name(),
 _klass->internal_name(), sig, vtable_index);
 super_method->access_flags().print_on(tty);
 if (super_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 tty->print("overriders flags: ");
 target_method->access_flags().print_on(tty);
 if (target_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 }
 #endif /*PRODUCT*/
 break; // return found superk
 }
 } else if (klass->is_interface()) {
 allocate_new = false;  // see note below in needs_new_vtable_entry
 // An interface never allocates new vtable slots, only inherits old ones.
 // This method will either be assigned its own itable index later,
 // or be assigned an inherited vtable index in the loop below.
-// default methods store their vtable indices in the inheritors default_vtable_indices
+// default methods inherited by classes store their vtable indices
-assert (default_index == -1, "interfaces don't store resolved default methods");
+// in the inheritor's default_vtable_indices
-target_method()->set_vtable_index(Method::pending_itable_index);
+// default methods inherited by interfaces may already have a
+// valid itable index, if so, don't change it
+// overpass methods in an interface will be assigned an itable index later
+// by an inheriting class
+if (!is_default || !target_method()->has_itable_index()) {
+target_method()->set_vtable_index(Method::pending_itable_index);
+}
 }
 // we need a new entry if there is no superclass
 if (klass->super() == NULL) {
 return allocate_new;
 char* sig = target_method()->name_and_sig_as_C_string();
 tty->print("overriding with %s::%s index %d, original flags: ",
 target_klass->internal_name(), sig, i);
 super_method->access_flags().print_on(tty);
 if (super_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 if (super_method->is_overpass()) {
 tty->print("overpass");
 }
 tty->print("overriders flags: ");
 target_method->access_flags().print_on(tty);
 if (target_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 if (target_method->is_overpass()) {
 tty->print("overpass");
 }
 tty->cr();
 char* sig = target_method()->name_and_sig_as_C_string();
 tty->print("NOT overriding with %s::%s index %d, original flags: ",
 target_klass->internal_name(), sig,i);
 super_method->access_flags().print_on(tty);
 if (super_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 if (super_method->is_overpass()) {
 tty->print("overpass");
 }
 tty->print("overriders flags: ");
 target_method->access_flags().print_on(tty);
 if (target_method->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 if (target_method->is_overpass()) {
 tty->print("overpass");
 }
 tty->cr();
 void klassVtable::put_method_at(Method* m, int index) {
 #ifndef PRODUCT
 if (PrintVtables && Verbose) {
 ResourceMark rm;
-tty->print_cr("adding %s::%s at index %d", _klass->internal_name(),
+const char* sig = (m != NULL) ? m->name_and_sig_as_C_string() : "<NULL>";
-(m != NULL) ? m->name()->as_C_string() : "<NULL>", index);
+tty->print("adding %s at index %d, flags: ", sig, index);
+if (m != NULL) {
+m->access_flags().print_on(tty);
+if (m->is_default_method()) {
+tty->print("default ");
+}
+if (m->is_overpass()) {
+tty->print("overpass");
+}
+}
+tty->cr();
 }
 #endif
 table()[index].set(m);
 }
 // miranda methods are public abstract instance interface methods in a class's vtable
 if (mhk->is_interface()) {
 assert(m->is_public(), "should be public");
 assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
-assert(is_miranda(m, ik()->methods(), ik()->default_methods(), ik()->super()), "should be a miranda_method");
+// the search could find a miranda or a default method
-return true;
+if (is_miranda(m, ik()->methods(), ik()->default_methods(), ik()->super())) {
+return true;
+}
 }
 return false;
 }
 // check if a method is a miranda method, given a class's methods table,
 // "miranda" means not static, not defined by this class.
 // private methods in interfaces do not belong in the miranda list.
 // the caller must make sure that the method belongs to an interface implemented by the class
 // Miranda methods only include public interface instance methods
 // Not private methods, not static methods, not default == concrete abstract
+// Miranda methods also do not include overpass methods in interfaces
 bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
 Array<Method*>* default_methods, Klass* super) {
-if (m->is_static() || m->is_private()) {
+if (m->is_static() || m->is_private() || m->is_overpass()) {
 return false;
 }
 Symbol* name = m->name();
 Symbol* signature = m->signature();
 if (InstanceKlass::find_method(class_methods, name, signature) == NULL) {
 }
 // Discover miranda methods ("miranda" = "interface abstract, no binding"),
 // and append them into the vtable starting at index initialized,
 // return the new value of initialized.
+// Miranda methods use vtable entries, but do not get assigned a vtable_index
+// The vtable_index is discovered by searching from the end of the vtable
 int klassVtable::fill_in_mirandas(int initialized) {
 GrowableArray<Method*> mirandas(20);
 get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
 ik()->default_methods(), ik()->local_interfaces());
 for (int i = 0; i < mirandas.length(); i++) {
 char* sig = meth->name_and_sig_as_C_string();
 tty->print("fill in mirandas with %s index %d, flags: ",
 sig, initialized);
 meth->access_flags().print_on(tty);
 if (meth->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 tty->cr();
 }
 }
 put_method_at(mirandas.at(i), initialized);
 Method* m = unchecked_method_at(i);
 if (m != NULL) {
 tty->print("      (%5d)  ", i);
 m->access_flags().print_on(tty);
 if (m->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 if (m->is_overpass()) {
 tty->print("overpass");
 }
 tty->print(" --  ");
 for (int i = 0; i < nof_methods; i++) {
 Method* m = methods->at(i);
 if (interface_method_needs_itable_index(m)) {
 assert(!m->is_final_method(), "no final interface methods");
 // If m is already assigned a vtable index, do not disturb it.
+if (TraceItables && Verbose) {
+ResourceMark rm;
+const char* sig = (m != NULL) ? m->name_and_sig_as_C_string() : "<NULL>";
+if (m->has_vtable_index()) {
+tty->print("itable index %d for method: %s, flags: ", m->vtable_index(), sig);
+} else {
+tty->print("itable index %d for method: %s, flags: ", ime_num, sig);
+}
+if (m != NULL) {
+m->access_flags().print_on(tty);
+if (m->is_default_method()) {
+tty->print("default ");
+}
+if (m->is_overpass()) {
+tty->print("overpass");
+}
+}
+tty->cr();
+}
 if (!m->has_vtable_index()) {
 assert(m->vtable_index() == Method::pending_itable_index, "set by initialize_vtable");
 m->set_itable_index(ime_num);
 // Progress to next itable entry
 ime_num++;
 interf_h()->internal_name(), ime_num, sig,
 target()->method_holder()->internal_name());
 tty->print("target_method flags: ");
 target()->access_flags().print_on(tty);
 if (target()->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 tty->cr();
 }
 }
 }
 Method* m = ime->method();
 if (m != NULL) {
 tty->print("      (%5d)  ", i);
 m->access_flags().print_on(tty);
 if (m->is_default_method()) {
-tty->print("default");
+tty->print("default ");
 }
 tty->print(" --  ");
 m->print_name(tty);
 tty->cr();
 }

Mercurial > hg > truffle

comparison src/share/vm/oops/klassVtable.cpp @ 13055:fce21ac5968d