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

comparison src/share/vm/oops/klassVtable.cpp @ 697:922aedc96ef5

Merge

author	ysr
date	Fri, 03 Apr 2009 15:59:19 -0700
parents	d3676b4cb78c
children	cff162798819

comparison

equal deleted inserted replaced

-:f18338cf04b0
+:922aedc96ef5
 /*
-* Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 void klassVtable::compute_vtable_size_and_num_mirandas(int &vtable_length,
 int &num_miranda_methods,
 klassOop super,
 objArrayOop methods,
 AccessFlags class_flags,
-oop classloader,
+Handle classloader,
-symbolOop classname,
+symbolHandle classname,
-objArrayOop local_interfaces
+objArrayOop local_interfaces,
+TRAPS
 ) {
 No_Safepoint_Verifier nsv;
 // set up default result values
 // go thru each method in the methods table to see if it needs a new entry
 int len = methods->length();
 for (int i = 0; i < len; i++) {
 assert(methods->obj_at(i)->is_method(), "must be a methodOop");
-methodOop m = methodOop(methods->obj_at(i));
+methodHandle mh(THREAD, methodOop(methods->obj_at(i)));
-if (needs_new_vtable_entry(m, super, classloader, classname, class_flags)) {
+if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, THREAD)) {
 vtable_length += vtableEntry::size(); // we need a new entry
 }
 }
 // compute the number of mirandas methods that must be added to the end
 superVtable->verify(tty, true);
 #endif
 superVtable->copy_vtable_to(table());
 #ifndef PRODUCT
 if (PrintVtables && Verbose) {
+ResourceMark rm;
 tty->print_cr("copy vtable from %s to %s size %d", sk->internal_name(), klass()->internal_name(), _length);
 }
 #endif
 return superVtable->length();
 }
 objArrayHandle methods(THREAD, ik()->methods());
 int len = methods()->length();
 int initialized = super_vtable_len;
-// update_super_vtable can stop for gc - ensure using handles
+// update_inherited_vtable can stop for gc - ensure using handles
 for (int i = 0; i < len; i++) {
 HandleMark hm(THREAD);
 assert(methods()->obj_at(i)->is_method(), "must be a methodOop");
 methodHandle mh(THREAD, (methodOop)methods()->obj_at(i));
-bool needs_new_entry = update_super_vtable(ik(), mh, super_vtable_len, checkconstraints, CHECK);
+bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, checkconstraints, CHECK);
 if (needs_new_entry) {
 put_method_at(mh(), initialized);
 mh()->set_vtable_index(initialized); // set primary vtable index
 initialized++;
 }
 // add miranda methods; it will also update the value of initialized
 fill_in_mirandas(initialized);
-// In class hierachieswhere the accesibility is not increasing (i.e., going from private ->
+// In class hierarchies where the accessibility is not increasing (i.e., going from private ->
 // package_private -> publicprotected), the vtable might actually be smaller than our initial
 // calculation.
 assert(initialized <= _length, "vtable initialization failed");
 for(;initialized < _length; initialized++) {
 put_method_at(NULL, initialized);
 }
 NOT_PRODUCT(verify(tty, true));
 }
 }
-// Interates through the vtables to find the broadest access level. This
+// Called for cases where a method does not override its superclass' vtable entry
-// will always be monotomic for valid Java programs - but not neccesarily
+// For bytecodes not produced by javac together it is possible that a method does not override
-// for incompatible class files.
+// the superclass's method, but might indirectly override a super-super class's vtable entry
-klassVtable::AccessType klassVtable::vtable_accessibility_at(int i) {
+// If none found, return a null superk, else return the superk of the method this does override
-// This vtable is not implementing the specific method
+instanceKlass* klassVtable::find_transitive_override(instanceKlass* initialsuper, methodHandle target_method,
-if (i >= length()) return acc_private;
+int vtable_index, Handle target_loader, symbolHandle target_classname, Thread * THREAD) {
+instanceKlass* superk = initialsuper;
-// Compute AccessType for current method. public or protected we are done.
+while (superk != NULL && superk->super() != NULL) {
-methodOop m = method_at(i);
+instanceKlass* supersuperklass = instanceKlass::cast(superk->super());
-if (m->is_protected() || m->is_public()) return acc_publicprotected;
+klassVtable* ssVtable = supersuperklass->vtable();
+if (vtable_index < ssVtable->length()) {
-AccessType acc = m->is_package_private() ? acc_package_private : acc_private;
+methodOop super_method = ssVtable->method_at(vtable_index);
+#ifndef PRODUCT
-// Compute AccessType for method in super classes
+symbolHandle name(THREAD,target_method()->name());
-klassOop super = klass()->super();
+symbolHandle signature(THREAD,target_method()->signature());
-AccessType super_acc = (super != NULL) ? instanceKlass::cast(klass()->super())->vtable()->vtable_accessibility_at(i)
+assert(super_method->name() == name() && super_method->signature() == signature(), "vtable entry name/sig mismatch");
-: acc_private;
+#endif
+if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {
-// Merge
+#ifndef PRODUCT
-return (AccessType)MAX2((int)acc, (int)super_acc);
+if (PrintVtables && Verbose) {
+ResourceMark rm(THREAD);
+tty->print("transitive overriding superclass %s with %s::%s index %d, original flags: ",
+supersuperklass->internal_name(),
+_klass->internal_name(), (target_method() != NULL) ?
+target_method()->name()->as_C_string() : "<NULL>", vtable_index);
+super_method->access_flags().print_on(tty);
+tty->print("overriders flags: ");
+target_method->access_flags().print_on(tty);
+tty->cr();
+}
+#endif /*PRODUCT*/
+break; // return found superk
+}
+} else  {
+// super class has no vtable entry here, stop transitive search
+superk = (instanceKlass*)NULL;
+break;
+}
+// if no override found yet, continue to search up
+superk = instanceKlass::cast(superk->super());
+}
+return superk;
 }
 // Update child's copy of super vtable for overrides
 // OR return true if a new vtable entry is required
 // Only called for instanceKlass's, i.e. not for arrays
 // If that changed, could not use _klass as handle for klass
-bool klassVtable::update_super_vtable(instanceKlass* klass, methodHandle target_method, int super_vtable_len, bool checkconstraints, TRAPS) {
+bool klassVtable::update_inherited_vtable(instanceKlass* klass, methodHandle target_method, int super_vtable_len,
+bool checkconstraints, TRAPS) {
 ResourceMark rm;
 bool allocate_new = true;
 assert(klass->oop_is_instance(), "must be instanceKlass");
 // Initialize the method's vtable index to "nonvirtual".
 if (klass->super() == NULL) {
 return allocate_new;
 }
 // private methods always have a new entry in the vtable
+// specification interpretation since classic has
+// private methods not overriding
 if (target_method()->is_private()) {
 return allocate_new;
 }
 // search through the vtable and update overridden entries
 // Since check_signature_loaders acquires SystemDictionary_lock
-// which can block for gc, once we are in this loop, use handles, not
+// which can block for gc, once we are in this loop, use handles
-// unhandled oops unless they are reinitialized for each loop
+// For classfiles built with >= jdk7, we now look for transitive overrides
-// handles for name, signature, klass, target_method
-// not for match_method, holder
 symbolHandle name(THREAD,target_method()->name());
 symbolHandle signature(THREAD,target_method()->signature());
+Handle target_loader(THREAD, _klass->class_loader());
+symbolHandle target_classname(THREAD, _klass->name());
 for(int i = 0; i < super_vtable_len; i++) {
-methodOop match_method = method_at(i);
+methodOop super_method = method_at(i);
 // Check if method name matches
-if (match_method->name() == name() && match_method->signature() == signature()) {
+if (super_method->name() == name() && super_method->signature() == signature()) {
-instanceKlass* holder = (THREAD, instanceKlass::cast(match_method->method_holder()));
+// get super_klass for method_holder for the found method
+instanceKlass* super_klass =  instanceKlass::cast(super_method->method_holder());
-// Check if the match_method is accessable from current class
+if ((super_klass->is_override(super_method, target_loader, target_classname, THREAD)) ||
-bool same_package_init = false;
+((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
-bool same_package_flag = false;
+&& ((super_klass = find_transitive_override(super_klass, target_method, i, target_loader,
-bool simple_match = match_method->is_public()  || match_method->is_protected();
+target_classname, THREAD)) != (instanceKlass*)NULL))) {
-if (!simple_match) {
+// overriding, so no new entry
-same_package_init = true;
+allocate_new = false;
-same_package_flag = holder->is_same_class_package(_klass->class_loader(), _klass->name());
-simple_match = match_method->is_package_private() && same_package_flag;
-}
-// match_method is the superclass' method. Note we can't override
-// and shouldn't access superclass' ACC_PRIVATE methods
-// (although they have been copied into our vtable)
-// A simple form of this statement is:
-// if ( (match_method->is_public()  || match_method->is_protected()) ||
-//    (match_method->is_package_private() && holder->is_same_class_package(klass->class_loader(), klass->name()))) {
-//
-// The complexity is introduced it avoid recomputing 'is_same_class_package' which is expensive.
-if (simple_match) {
-// Check if target_method and match_method has same level of accessibility. The accesibility of the
-// match method is the "most-general" visibility of all entries at it's particular vtable index for
-// all superclasses. This check must be done before we override the current entry in the vtable.
-AccessType at = vtable_accessibility_at(i);
-bool same_access = false;
-if (  (at == acc_publicprotected && (target_method()->is_public() || target_method()->is_protected())
-|| (at == acc_package_private && (target_method()->is_package_private() &&
-(( same_package_init && same_package_flag) ||
-(!same_package_init && holder->is_same_class_package(_klass->class_loader(), _klass->name()))))))) {
-same_access = true;
-}
 if (checkconstraints) {
 // Override vtable entry if passes loader constraint check
 // if loader constraint checking requested
 // No need to visit his super, since he and his super
 // have already made any needed loader constraints.
 // Since loader constraints are transitive, it is enough
 // to link to the first super, and we get all the others.
-symbolHandle signature(THREAD, target_method()->signature());
-Handle this_loader(THREAD, _klass->class_loader());
-instanceKlassHandle super_klass(THREAD, _klass->super());
 Handle super_loader(THREAD, super_klass->class_loader());
-if (this_loader() != super_loader()) {
+if (target_loader() != super_loader()) {
 ResourceMark rm(THREAD);
 char* failed_type_name =
-SystemDictionary::check_signature_loaders(signature, this_loader,
+SystemDictionary::check_signature_loaders(signature, target_loader,
 super_loader, true,
 CHECK_(false));
 if (failed_type_name != NULL) {
 const char* msg = "loader constraint violation: when resolving "
 "overridden method \"%s\" the class loader (instance"
 " of %s) of the current class, %s, and its superclass loader "
 "(instance of %s), have different Class objects for the type "
 "%s used in the signature";
 char* sig = target_method()->name_and_sig_as_C_string();
-const char* loader1 = SystemDictionary::loader_name(this_loader());
+const char* loader1 = SystemDictionary::loader_name(target_loader());
 char* current = _klass->name()->as_C_string();
 const char* loader2 = SystemDictionary::loader_name(super_loader());
 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
 strlen(current) + strlen(loader2) + strlen(failed_type_name);
 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
 failed_type_name);
 THROW_MSG_(vmSymbols::java_lang_LinkageError(), buf, false);
 }
 }
+}
+put_method_at(target_method(), i);
+target_method()->set_vtable_index(i);
+#ifndef PRODUCT
+if (PrintVtables && Verbose) {
+tty->print("overriding with %s::%s index %d, original flags: ",
+_klass->internal_name(), (target_method() != NULL) ?
+target_method()->name()->as_C_string() : "<NULL>", i);
+super_method->access_flags().print_on(tty);
+tty->print("overriders flags: ");
+target_method->access_flags().print_on(tty);
+tty->cr();
 }
-put_method_at(target_method(), i);
+#endif /*PRODUCT*/
+} else {
+// allocate_new = true; default. We might override one entry,
-if (same_access) {
+// but not override another. Once we override one, not need new
-// target and match has same accessiblity - share entry
-allocate_new = false;
-target_method()->set_vtable_index(i);
 #ifndef PRODUCT
 if (PrintVtables && Verbose) {
-AccessType targetacc;
+tty->print("NOT overriding with %s::%s index %d, original flags: ",
-if (target_method()->is_protected() ||
+_klass->internal_name(), (target_method() != NULL) ?
-target_method()->is_public()) {
+target_method()->name()->as_C_string() : "<NULL>", i);
-targetacc =  acc_publicprotected;
+super_method->access_flags().print_on(tty);
-} else {
+tty->print("overriders flags: ");
-targetacc = target_method()->is_package_private() ? acc_package_private : acc_private;
+target_method->access_flags().print_on(tty);
-}
+tty->cr();
-tty->print_cr("overriding with %s::%s index %d, original flags: %x overriders flags: %x",
+}
-_klass->internal_name(), (target_method() != NULL) ?
-target_method()->name()->as_C_string() : "<NULL>", i,
-at, targetacc);
-}
 #endif /*PRODUCT*/
-} else {
-#ifndef PRODUCT
-if (PrintVtables && Verbose) {
-AccessType targetacc;
-if (target_method()->is_protected() ||
-target_method()->is_public()) {
-targetacc =  acc_publicprotected;
-} else {
-targetacc = target_method()->is_package_private() ? acc_package_private : acc_private;
-}
-tty->print_cr("override %s %s::%s at index %d, original flags: %x overriders flags: %x",
-allocate_new ? "+ new" : "only",
-_klass->internal_name(), (target_method() != NULL) ?
-target_method()->name()->as_C_string() : "<NULL>", i,
-at, targetacc);
-}
-#endif /*PRODUCT*/
-}
 }
 }
 }
 return allocate_new;
 }
 void klassVtable::put_method_at(methodOop m, int index) {
 assert(m->is_oop_or_null(), "Not an oop or null");
 #ifndef PRODUCT
 if (PrintVtables && Verbose) {
+ResourceMark rm;
 tty->print_cr("adding %s::%s at index %d", _klass->internal_name(),
 (m != NULL) ? m->name()->as_C_string() : "<NULL>", index);
 }
 assert(unchecked_method_at(index)->is_oop_or_null(), "Not an oop or null");
 #endif
 // Find out if a method "m" with superclass "super", loader "classloader" and
 // name "classname" needs a new vtable entry.  Let P be a class package defined
 // by "classloader" and "classname".
 // NOTE: The logic used here is very similar to the one used for computing
 // the vtables indices for a method. We cannot directly use that function because,
-// when the Universe is boostrapping, a super's vtable might not be initialized.
+// we allocate the instanceKlass at load time, and that requires that the
-bool klassVtable::needs_new_vtable_entry(methodOop target_method,
+// superclass has been loaded.
+// However, the vtable entries are filled in at link time, and therefore
+// the superclass' vtable may not yet have been filled in.
+bool klassVtable::needs_new_vtable_entry(methodHandle target_method,
 klassOop super,
-oop classloader,
+Handle classloader,
-symbolOop classname,
+symbolHandle classname,
-AccessFlags class_flags) {
+AccessFlags class_flags,
-if ((class_flags.is_final() || target_method->is_final()) ||
+TRAPS) {
+if ((class_flags.is_final() || target_method()->is_final()) ||
 // a final method never needs a new entry; final methods can be statically
 // resolved and they have to be present in the vtable only if they override
 // a super's method, in which case they re-use its entry
-(target_method->is_static()) ||
+(target_method()->is_static()) ||
 // static methods don't need to be in vtable
-(target_method->name() ==  vmSymbols::object_initializer_name())
+(target_method()->name() ==  vmSymbols::object_initializer_name())
 // <init> is never called dynamically-bound
 ) {
 return false;
 }
 if (super == NULL) {
 return true;
 }
 // private methods always have a new entry in the vtable
-if (target_method->is_private()) {
+// specification interpretation since classic has
+// private methods not overriding
+if (target_method()->is_private()) {
 return true;
 }
 // search through the super class hierarchy to see if we need
 // a new entry
-symbolOop name = target_method->name();
+ResourceMark rm;
-symbolOop signature = target_method->signature();
+symbolOop name = target_method()->name();
+symbolOop signature = target_method()->signature();
 klassOop k = super;
-methodOop match_method = NULL;
+methodOop super_method = NULL;
 instanceKlass *holder = NULL;
+methodOop recheck_method =  NULL;
 while (k != NULL) {
 // lookup through the hierarchy for a method with matching name and sign.
-match_method = instanceKlass::cast(k)->lookup_method(name, signature);
+super_method = instanceKlass::cast(k)->lookup_method(name, signature);
-if (match_method == NULL) {
+if (super_method == NULL) {
 break; // we still have to search for a matching miranda method
 }
 // get the class holding the matching method
-holder = instanceKlass::cast(match_method->method_holder());
+// make sure you use that class for is_override
+instanceKlass* superk = instanceKlass::cast(super_method->method_holder());
-if (!match_method->is_static()) { // we want only instance method matches
+// we want only instance method matches
-if ((target_method->is_public() || target_method->is_protected()) &&
+// pretend private methods are not in the super vtable
-(match_method->is_public()  || match_method->is_protected())) {
+// since we do override around them: e.g. a.m pub/b.m private/c.m pub,
-// target and match are public/protected; we do not need a new entry
+// ignore private, c.m pub does override a.m pub
+// For classes that were not javac'd together, we also do transitive overriding around
+// methods that have less accessibility
+if ((!super_method->is_static()) &&
+(!super_method->is_private())) {
+if (superk->is_override(super_method, classloader, classname, THREAD)) {
 return false;
+// else keep looking for transitive overrides
 }
+}
-if (target_method->is_package_private() &&
-match_method->is_package_private() &&
+// Start with lookup result and continue to search up
-holder->is_same_class_package(classloader, classname)) {
+k = superk->super(); // haven't found an override match yet; continue to look
-// target and match are P private; we do not need a new entry
-return false;
-}
-}
-k = holder->super(); // haven't found a match yet; continue to look
 }
 // if the target method is public or protected it may have a matching
 // miranda method in the super, whose entry it should re-use.
-if (target_method->is_public() || target_method->is_protected()) {
+// Actually, to handle cases that javac would not generate, we need
-instanceKlass *sk = instanceKlass::cast(super);
+// this check for all access permissions.
-if (sk->has_miranda_methods()) {
+instanceKlass *sk = instanceKlass::cast(super);
-if (sk->lookup_method_in_all_interfaces(name, signature) != NULL) {
+if (sk->has_miranda_methods()) {
-return false;  // found a matching miranda; we do not need a new entry
+if (sk->lookup_method_in_all_interfaces(name, signature) != NULL) {
-}
+return false;  // found a matching miranda; we do not need a new entry
 }
 }
 return true; // found no match; we need a new entry
 }
 // Support for miranda methods
 if (num_interfaces > 0) {
 if (TraceItables) tty->print_cr("%3d: Initializing itables for %s", ++initialize_count,
 _klass->name()->as_C_string());
-// Interate through all interfaces
+// Iterate through all interfaces
 int i;
 for(i = 0; i < num_interfaces; i++) {
 itableOffsetEntry* ioe = offset_entry(i);
 KlassHandle interf_h (THREAD, ioe->interface_klass());
 assert(interf_h() != NULL && ioe->offset() != 0, "bad offset entry in itable");
 // RC_TRACE macro has an embedded ResourceMark
 RC_TRACE(0x00200000, ("itable method update: %s(%s)",
 new_method->name()->as_C_string(),
 new_method->signature()->as_C_string()));
 }
+break;
 }
 ime++;
 }
 }
 }
 // Adjust for <clinit>, which is left out of table if first method
 if (methods->length() > 0 && ((methodOop)methods->obj_at(0))->name() == vmSymbols::class_initializer_name()) {
 index--;
 }
 return index;
+}
+// inverse to compute_itable_index
+methodOop klassItable::method_for_itable_index(klassOop intf, int itable_index) {
+assert(instanceKlass::cast(intf)->is_interface(), "sanity check");
+objArrayOop methods = instanceKlass::cast(intf)->methods();
+int index = itable_index;
+// Adjust for <clinit>, which is left out of table if first method
+if (methods->length() > 0 && ((methodOop)methods->obj_at(0))->name() == vmSymbols::class_initializer_name()) {
+index++;
+}
+if (itable_index < 0 || index >= methods->length())
+return NULL;                // help caller defend against bad indexes
+methodOop m = (methodOop)methods->obj_at(index);
+assert(compute_itable_index(m) == itable_index, "correct inverse");
+return m;
 }
 void klassVtable::verify(outputStream* st, bool forced) {
 // make sure table is initialized
 if (!Universe::is_fully_initialized()) return;

Mercurial > hg > truffle

comparison src/share/vm/oops/klassVtable.cpp @ 697:922aedc96ef5