src/share/vm/oops/klassVtable.cpp

Print this page

        

*** 681,762 **** // 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"); - // the search could find a miranda or a default method 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, ! // its default_method table and its super ! // Miranda methods are calculated twice: ! // first: before vtable size calculation: including abstract and superinterface default // We include potential default methods to give them space in the vtable. ! // During the first run, the default_methods list is empty ! // This is seen by default method creation ! // Second: recalculated during vtable initialization: only include abstract methods. // During the second run, default_methods is set up, so concrete methods from // superinterfaces with matching names/signatures to default_methods are already // in the default_methods list and do not need to be appended to the vtable ! // as mirandas ! // This is seen by link resolution and selection. ! // "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() || m->is_overpass()) { return false; } Symbol* name = m->name(); Symbol* signature = m->signature(); - Method* mo; ! if ((mo = InstanceKlass::find_instance_method(class_methods, name, signature)) == NULL) { ! // did not find it in the method table of the current class ! if ((default_methods == NULL) || ! InstanceKlass::find_method(default_methods, name, signature) == NULL) { ! if (super == NULL) { ! // super doesn't exist ! return true; } ! mo = InstanceKlass::cast(super)->lookup_method(name, signature); ! while (mo != NULL && mo->access_flags().is_static() ! && mo->method_holder() != NULL ! && mo->method_holder()->super() != NULL) { ! mo = mo->method_holder()->super()->uncached_lookup_method(name, signature, Klass::find_overpass); ! } ! if (mo == NULL || mo->access_flags().is_private() ) { ! // super class hierarchy does not implement it or protection is different ! return true; ! } ! } ! } else { ! // if the local class has a private method, the miranda will not ! // override it, so a vtable slot is needed ! if (mo->access_flags().is_private()) { ! ! // Second round, weed out any superinterface methods that turned ! // into default methods, i.e. were concrete not abstract in the end ! if ((default_methods == NULL) || ! InstanceKlass::find_method(default_methods, name, signature) == NULL) { ! return true; } } } ! return false; } // Scans current_interface_methods for miranda methods that do not // already appear in new_mirandas, or default methods, and are also not defined-and-non-private // in super (superclass). These mirandas are added to all_mirandas if it is --- 681,769 ---- // 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"); 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, ! // its default_method table and its super class. ! // "Miranda" means an abstract non-private method that would not be ! // overridden. A "miranda" method should only include non-private interface ! // instance methods, not private methods, not static methods, ! // not default methods (concrete interface methods), not overpass methods. ! // If a given class already has a local (including overpass) method, a ! // default method, or any of its superclasses has the same which would have ! // overridden an abstract method, then this is not a miranda method. ! // ! // Miranda methods are checked multiple times. ! // Pass 1: during class load/class file parsing: before vtable size calculation: ! // include superinterface abstract and default methods (non-private instance). // We include potential default methods to give them space in the vtable. ! // During the first run, the current instanceKlass has not yet been ! // created, the superclasses and superinterfaces do have instanceKlasses ! // but may not have vtables, the default_methods list is empty, no overpasses. ! // This is seen by default method creation. ! // ! // Pass 2: recalculated during vtable initialization: only include abstract methods. // During the second run, default_methods is set up, so concrete methods from // superinterfaces with matching names/signatures to default_methods are already // in the default_methods list and do not need to be appended to the vtable ! // as mirandas. Abstract methods may already have been handled via ! // overpasses - either local or superclass overpasses, which may be ! // in the vtable already. ! // ! // Pass 3: They are also checked by link resolution and selection, ! // for invocation on a method (not interface method) reference that ! // resolves to a method with an interface as its method_holder. ! // Used as part of walking from the bottom of the vtable to find ! // the vtable index for the miranda method. ! // ! // Part of the Miranda Rights in the US mean that if you do not have ! // an attorney one will be appointed to you. bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods, Array<Method*>* default_methods, Klass* super) { if (m->is_static() || m->is_private() || m->is_overpass()) { return false; } Symbol* name = m->name(); Symbol* signature = m->signature(); ! // First look in local methods to see if already covered ! if (InstanceKlass::find_local_method(class_methods, name, signature, ! Klass::find_overpass, Klass::skip_static, Klass::skip_private) != NULL) ! { ! return false; } ! // Check local default methods ! if ((default_methods != NULL) && ! (InstanceKlass::find_method(default_methods, name, signature) != NULL)) { ! return false; } + + InstanceKlass* cursuper; + // Iterate on all superclasses, which should have instanceKlasses + // Note that we explicitly look for overpasses at each level. + // Overpasses may or may not exist supers for pass 1, + // they should have been created for pass 2 and later. + + for (cursuper = InstanceKlass::cast(super); cursuper != NULL; cursuper = (InstanceKlass*)cursuper->super()) + { + if (cursuper->find_local_method(name, signature, + Klass::find_overpass, Klass::skip_static, Klass::skip_private) != NULL) { + return false; } } ! return true; } // Scans current_interface_methods for miranda methods that do not // already appear in new_mirandas, or default methods, and are also not defined-and-non-private // in super (superclass). These mirandas are added to all_mirandas if it is