/*

 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "gc_implementation/shared/markSweep.inline.hpp"

#include "memory/gcLocker.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/klassOop.hpp"

#include "oops/klassVtable.hpp"

#include "oops/methodOop.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "runtime/arguments.hpp"

#include "runtime/handles.inline.hpp"

#include "utilities/copy.hpp"

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,

                                                       Handle classloader,

                                                       symbolHandle classname,

                                                       objArrayOop local_interfaces,

                                                       TRAPS

                                                       ) {

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

    methodHandle mh(THREAD, methodOop(methods->obj_at(i)));

    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

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

      ResourceMark rm;

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

  }

}

// Called for cases where a method does not override its superclass' vtable entry

// For bytecodes not produced by javac together it is possible that a method does not override

// the superclass's method, but might indirectly override a super-super class's vtable entry

// If none found, return a null superk, else return the superk of the method this does override

instanceKlass* klassVtable::find_transitive_override(instanceKlass* initialsuper, methodHandle target_method,

                            int vtable_index, Handle target_loader, symbolHandle target_classname, Thread * THREAD) {

  instanceKlass* superk = initialsuper;

  while (superk != NULL && superk->super() != NULL) {

    instanceKlass* supersuperklass = instanceKlass::cast(superk->super());

    klassVtable* ssVtable = supersuperklass->vtable();

    if (vtable_index < ssVtable->length()) {

      methodOop super_method = ssVtable->method_at(vtable_index);

#ifndef PRODUCT

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

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

      assert(super_method->name() == name() && super_method->signature() == signature(), "vtable entry name/sig mismatch");

#endif

      if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {

#ifndef PRODUCT

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

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

  // For classfiles built with >= jdk7, we now look for transitive overrides

  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 super_method = method_at(i);

    // Check if method name matches

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

      // get super_klass for method_holder for the found method

      instanceKlass* super_klass =  instanceKlass::cast(super_method->method_holder());

      if ((super_klass->is_override(super_method, target_loader, target_classname, THREAD)) ||

      ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)

        && ((super_klass = find_transitive_override(super_klass, target_method, i, target_loader,

             target_classname, THREAD)) != (instanceKlass*)NULL))) {

        // overriding, so no new entry

        allocate_new = false;

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

          if (target_loader() != super_loader()) {

            ResourceMark rm(THREAD);

            char* failed_type_name =

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

        }

#endif /*PRODUCT*/

      } else {

        // allocate_new = true; default. We might override one entry,

        // but not override another. Once we override one, not need new

#ifndef PRODUCT

        if (PrintVtables && Verbose) {

          tty->print("NOT 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();

        }

#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

  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,

// we allocate the instanceKlass at load time, and that requires that the

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

                                         Handle classloader,

                                         symbolHandle classname,

                                         AccessFlags class_flags,

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

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

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

  ResourceMark rm;

  symbolOop name = target_method()->name();

  symbolOop signature = target_method()->signature();

  klassOop k = super;

  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.

    super_method = instanceKlass::cast(k)->lookup_method(name, signature);

    if (super_method == NULL) {

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

    }

    // get the class holding the matching method

    // make sure you use that class for is_override

    instanceKlass* superk = instanceKlass::cast(super_method->method_holder());

    // we want only instance method matches

    // pretend private methods are not in the super vtable

    // since we do override around them: e.g. a.m pub/b.m private/c.m pub,

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

      }

    }

    // Start with lookup result and continue to search up

    k = superk->super(); // haven't found an override 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.

  // Actually, to handle cases that javac would not generate, we need

  // this check for all access permissions.

  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;

  }