/*

 * Copyright (c) 1997, 2013, 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/klassVtable.hpp"

#include "oops/method.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();

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

  return (InstanceKlass*)k;

}

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

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

// 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_ret, int* num_new_mirandas,

    GrowableArray<Method*>* all_mirandas, Klass* super,

    Array<Method*>* methods, AccessFlags class_flags,

    Handle classloader, Symbol* classname, Array<Klass*>* local_interfaces,

    TRAPS) {

  No_Safepoint_Verifier nsv;

  // set up default result values

  int vtable_length = 0;

  // start off with super's vtable length

  InstanceKlass* sk = (InstanceKlass*)super;

  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->at(i)->is_method(), "must be a Method*");

    methodHandle mh(THREAD, methods->at(i));

    if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, THREAD)) {

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

    }

  }

  GrowableArray<Method*> new_mirandas(20);

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

  get_mirandas(&new_mirandas, all_mirandas, super, methods, local_interfaces);

  *num_new_mirandas = new_mirandas.length();

  vtable_length += *num_new_mirandas * 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");

  *vtable_length_ret = vtable_length;

}

int klassVtable::index_of(Method* m, int len) const {

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

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

  }

}

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

    Array<Method*>* methods = ik()->methods();

    int len = methods->length();

    int initialized = super_vtable_len;

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

      HandleMark hm(THREAD);

      assert(methods->at(i)->is_method(), "must be a Method*");

      methodHandle mh(THREAD, methods->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++;

      }

    }

    // In class hierarchies where the accessibility is not increasing (i.e., going from private ->

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

      Method* super_method = ssVtable->method_at(vtable_index);

#ifndef PRODUCT

      Symbol* name= target_method()->name();

      Symbol* signature = 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

// 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(Method::nonvirtual_vtable_index);

  // Static and <init> methods are never in

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

    return false;

  }

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

  Symbol* name = target_method()->name();

  Symbol* signature = target_method()->signature();

  Handle target_loader(THREAD, _klass()->class_loader());

  Symbol*  target_classname = _klass->name();

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

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

            Symbol* failed_type_symbol =

              SystemDictionary::check_signature_loaders(signature, target_loader,

                                                        super_loader, true,

                                                        CHECK_(false));

            if (failed_type_symbol != 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());

              char* failed_type_name = failed_type_symbol->as_C_string();

              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(Method* m, int index) {

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

  }

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

                                         Klass* super,

                                         Handle classloader,

                                         Symbol* classname,

                                         AccessFlags class_flags,

                                         TRAPS) {

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

  Symbol* name = target_method()->name();

  Symbol* signature = target_method()->signature();

  Klass* k = super;

  Method* super_method = NULL;

  InstanceKlass *holder = NULL;

  Method* 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 = 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