/*

 * Copyright 1997-2008 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.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_klassVtable.cpp.incl"

inline instanceKlass* klassVtable::ik() const {

  Klass* k = _klass()->klass_part();

  assert(k->oop_is_instance(), "not an instanceKlass");

  return (instanceKlass*)k;

}

// this function computes the vtable size (including the size needed for miranda

// methods) and the number of miranda methods in this class

// Note on Miranda methods: Let's say there is a class C that implements

// interface I.  Let's say there is a method m in I that neither C nor any

// of its super classes implement (i.e there is no method of any access, with

// the same name and signature as m), then m is a Miranda method which is

// entered as a public abstract method in C's vtable.  From then on it should

// treated as any other public method in C for method over-ride purposes.

void klassVtable::compute_vtable_size_and_num_mirandas(int &vtable_length,

                                                       int &num_miranda_methods,

                                                       klassOop super,

                                                       objArrayOop methods,

                                                       AccessFlags class_flags,

                                                       oop classloader,

                                                       symbolOop classname,

                                                       objArrayOop local_interfaces

                                                       ) {

  No_Safepoint_Verifier nsv;

  // set up default result values

  vtable_length = 0;

  num_miranda_methods = 0;

  // start off with super's vtable length

  instanceKlass* sk = (instanceKlass*)super->klass_part();

  vtable_length = super == NULL ? 0 : sk->vtable_length();

  // 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));

    if (needs_new_vtable_entry(m, super, classloader, classname, class_flags)) {

      vtable_length += vtableEntry::size(); // we need a new entry

    }

  }

  // compute the number of mirandas methods that must be added to the end

  num_miranda_methods = get_num_mirandas(super, methods, local_interfaces);

  vtable_length += (num_miranda_methods * 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();

  }

  if (super == NULL && !Universe::is_bootstrapping() &&

      vtable_length != Universe::base_vtable_size()) {

    // Someone is attempting to redefine java.lang.Object incorrectly.  The

    // only way this should happen is from

    // SystemDictionary::resolve_from_stream(), which will detect this later

    // and throw a security exception.  So don't assert here to let

    // the exception occur.

    vtable_length = Universe::base_vtable_size();

  }

  assert(super != NULL || vtable_length == Universe::base_vtable_size(),

         "bad vtable size for class Object");

  assert(vtable_length % vtableEntry::size() == 0, "bad vtable length");

  assert(vtable_length >= Universe::base_vtable_size(), "vtable too small");

}

int klassVtable::index_of(methodOop m, int len) const {

  assert(m->vtable_index() >= 0, "do not ask this of non-vtable methods");

  return m->vtable_index();

}

int klassVtable::initialize_from_super(KlassHandle super) {

  if (super.is_null()) {

    return 0;

  } else {

    // copy methods from superKlass

    // can't inherit from array class, so must be instanceKlass

    assert(super->oop_is_instance(), "must be instance klass");

    instanceKlass* sk = (instanceKlass*)super()->klass_part();

    klassVtable* superVtable = sk->vtable();

    assert(superVtable->length() <= _length, "vtable too short");

#ifdef ASSERT

    superVtable->verify(tty, true);

#endif

    superVtable->copy_vtable_to(table());

#ifndef PRODUCT

    if (PrintVtables && Verbose) {

      tty->print_cr("copy vtable from %s to %s size %d", sk->internal_name(), klass()->internal_name(), _length);

    }

#endif

    return superVtable->length();

  }

}

// Revised lookup semantics   introduced 1.3 (Kestral beta)

void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) {

  // Note:  Arrays can have intermediate array supers.  Use java_super to skip them.

  KlassHandle super (THREAD, klass()->java_super());

  int nofNewEntries = 0;

  if (PrintVtables && !klass()->oop_is_array()) {

    ResourceMark rm(THREAD);

    tty->print_cr("Initializing: %s", _klass->name()->as_C_string());

  }

#ifdef ASSERT

  oop* end_of_obj = (oop*)_klass() + _klass()->size();

  oop* end_of_vtable = (oop*)&table()[_length];

  assert(end_of_vtable <= end_of_obj, "vtable extends beyond end");

#endif

  if (Universe::is_bootstrapping()) {

    // just clear everything

    for (int i = 0; i < _length; i++) table()[i].clear();

    return;

  }

  int super_vtable_len = initialize_from_super(super);

  if (klass()->oop_is_array()) {

    assert(super_vtable_len == _length, "arrays shouldn't introduce new methods");

  } else {

    assert(_klass->oop_is_instance(), "must be instanceKlass");

    objArrayHandle methods(THREAD, ik()->methods());

    int len = methods()->length();

    int initialized = super_vtable_len;

    // update_super_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);

      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 ->

    // 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

// will always be monotomic for valid Java programs - but not neccesarily

// for incompatible class files.

klassVtable::AccessType klassVtable::vtable_accessibility_at(int i) {

  // This vtable is not implementing the specific method

  if (i >= length()) return acc_private;

  // Compute AccessType for current method. public or protected we are done.

  methodOop m = method_at(i);

  if (m->is_protected() || m->is_public()) return acc_publicprotected;

  AccessType acc = m->is_package_private() ? acc_package_private : acc_private;

  // Compute AccessType for method in super classes

  klassOop super = klass()->super();

  AccessType super_acc = (super != NULL) ? instanceKlass::cast(klass()->super())->vtable()->vtable_accessibility_at(i)

                                         : acc_private;

  // Merge

  return (AccessType)MAX2((int)acc, (int)super_acc);

}

// 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) {

  ResourceMark rm;

  bool allocate_new = true;

  assert(klass->oop_is_instance(), "must be instanceKlass");

  // Initialize the method's vtable index to "nonvirtual".

  // If we allocate a vtable entry, we will update it to a non-negative number.

  target_method()->set_vtable_index(methodOopDesc::nonvirtual_vtable_index);

  // Static and <init> methods are never in

  if (target_method()->is_static() || target_method()->name() ==  vmSymbols::object_initializer_name()) {

    return false;

  }

  if (klass->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

    allocate_new = false;

  }

  // we need a new entry if there is no superclass

  if (klass->super() == NULL) {

    return allocate_new;

  }

  // private methods always have a new entry in the vtable

  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

  // unhandled oops unless they are reinitialized for each loop

  // handles for name, signature, klass, target_method

  // not for match_method, holder

  symbolHandle name(THREAD,target_method()->name());

  symbolHandle signature(THREAD,target_method()->signature());

  for(int i = 0; i < super_vtable_len; i++) {

    methodOop match_method = method_at(i);

    // Check if method name matches

    if (match_method->name() == name() && match_method->signature() == signature()) {

      instanceKlass* holder = (THREAD, instanceKlass::cast(match_method->method_holder()));

      // Check if the match_method is accessable from current class

      bool same_package_init = false;

      bool same_package_flag = false;

      bool simple_match = match_method->is_public()  || match_method->is_protected();

      if (!simple_match) {

        same_package_init = true;

        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()) {

            ResourceMark rm(THREAD);

            char* failed_type_name =

              SystemDictionary::check_signature_loaders(signature, this_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());

              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);

        if (same_access) {

          // target and match has same accessiblity - share entry

          allocate_new = false;

          target_method()->set_vtable_index(i);

#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("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) {

    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

  table()[index].set(m);

}

// 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.

bool klassVtable::needs_new_vtable_entry(methodOop target_method,

                                         klassOop super,

                                         oop classloader,

                                         symbolOop classname,

                                         AccessFlags class_flags) {

  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()) ||

      // static methods don't need to be in vtable

      (target_method->name() ==  vmSymbols::object_initializer_name())

      // <init> is never called dynamically-bound

      ) {

    return false;

  }

  // we need a new entry if there is no superclass

  if (super == NULL) {

    return true;

  }

  // private methods always have a new entry in the vtable

  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();

  symbolOop signature = target_method->signature();

  klassOop k = super;

  methodOop match_method = NULL;

  instanceKlass *holder = 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);

    if (match_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());

    if (!match_method->is_static()) { // we want only instance method matches

      if ((target_method->is_public() || target_method->is_protected()) &&

          (match_method->is_public()  || match_method->is_protected())) {

        // target and match are public/protected; we do not need a new entry

        return false;

      }

      if (target_method->is_package_private() &&

          match_method->is_package_private() &&

          holder->is_same_class_package(classloader, classname)) {

        // 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()) {

    instanceKlass *sk = instanceKlass::cast(super);

    if (sk->has_miranda_methods()) {

      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

// get the vtable index of a miranda method with matching "name" and "signature"

int klassVtable::index_of_miranda(symbolOop name, symbolOop signature) {

  // search from the bottom, might be faster

  for (int i = (length() - 1); i >= 0; i--) {

    methodOop m = table()[i].method();

    if (is_miranda_entry_at(i) &&

        m->name() == name && m->signature() == signature) {

      return i;

    }

  }

  return methodOopDesc::invalid_vtable_index;

}

// check if an entry is miranda

bool klassVtable::is_miranda_entry_at(int i) {

  methodOop m = method_at(i);

  klassOop method_holder = m->method_holder();

  instanceKlass *mhk = instanceKlass::cast(method_holder);

  // miranda methods are interface methods in a class's vtable

  if (mhk->is_interface()) {

    assert(m->is_public() && m->is_abstract(), "should be public and abstract");

    assert(ik()->implements_interface(method_holder) , "this class should implement the interface");

    assert(is_miranda(m, ik()->methods(), ik()->super()), "should be a miranda_method");

    return true;

  }

  return false;

}

// check if a method is a miranda method, given a class's methods table and it's super

// the caller must make sure that the method belongs to an interface implemented by the class

bool klassVtable::is_miranda(methodOop m, objArrayOop class_methods, klassOop super) {

  symbolOop name = m->name();

  symbolOop signature = m->signature();

  if (instanceKlass::find_method(class_methods, name, signature) == NULL) {

     // did not find it in the method table of the current class

    if (super == NULL) {

      // super doesn't exist

      return true;

    } else {

      if (instanceKlass::cast(super)->lookup_method(name, signature) == NULL) {

        // super class hierarchy does not implement it

        return true;

      }

    }

  }

  return false;

}

void klassVtable::add_new_mirandas_to_list(GrowableArray<methodOop>* list_of_current_mirandas,

                                           objArrayOop current_interface_methods,