/*

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

                                                       ) {

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

      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;

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

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

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

  }

}

}

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

  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

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

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

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

    // Check if method name matches

        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.

          Handle super_loader(THREAD, super_klass->class_loader());

            ResourceMark rm(THREAD);

            char* failed_type_name =

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

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

            }

          }

#ifndef PRODUCT

#endif /*PRODUCT*/

#ifndef PRODUCT

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

                                         klassOop super,

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

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

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

    return true;

  }

  // search through the super class hierarchy to see if we need

  // a new entry

  klassOop k = super;

  instanceKlass *holder = NULL;

  while (k != NULL) {

    // lookup through the hierarchy for a method with matching name and sign.

      break; // we still have to search for a matching miranda method

    }

    // get the class holding the matching method

        return false;

      }

    }

  }

  // if the target method is public or protected it may have a matching

  // miranda method in the super, whose entry it should re-use.

    }

  }

  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;