/*

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

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "interpreter/bytecode.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/reflection.hpp"

#include "runtime/signature.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/vmThread.hpp"

//------------------------------------------------------------------------------------------------------------------------

// Implementation of CallInfo

void CallInfo::set_static(KlassHandle resolved_klass, const methodHandle& resolved_method, TRAPS) {

  int vtable_index = Method::nonvirtual_vtable_index;

  set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);

}

void CallInfo::set_interface(KlassHandle resolved_klass,

                             KlassHandle selected_klass,

                             const methodHandle& resolved_method,

                             const methodHandle& selected_method,

                             int itable_index, TRAPS) {

  // This is only called for interface methods. If the resolved_method

  // comes from java/lang/Object, it can be the subject of a virtual call, so

  // we should pick the vtable index from the resolved method.

  // In that case, the caller must call set_virtual instead of set_interface.

  assert(resolved_method->method_holder()->is_interface(), "");

  assert(itable_index == resolved_method()->itable_index(), "");

  set_common(resolved_klass, selected_klass, resolved_method, selected_method, CallInfo::itable_call, itable_index, CHECK);

}

void CallInfo::set_virtual(KlassHandle resolved_klass,

                           KlassHandle selected_klass,

                           const methodHandle& resolved_method,

                           const methodHandle& selected_method,

                           int vtable_index, TRAPS) {

  assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");

  assert(vtable_index < 0 || !resolved_method->has_vtable_index() || vtable_index == resolved_method->vtable_index(), "");

  CallKind kind = (vtable_index >= 0 && !resolved_method->can_be_statically_bound() ? CallInfo::vtable_call : CallInfo::direct_call);

  set_common(resolved_klass, selected_klass, resolved_method, selected_method, kind, vtable_index, CHECK);

  assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");

}

void CallInfo::set_handle(const methodHandle& resolved_method,

                          Handle resolved_appendix,

                          Handle resolved_method_type, TRAPS) {

  if (resolved_method.is_null()) {

    THROW_MSG(vmSymbols::java_lang_InternalError(), "resolved method is null");

  }

  KlassHandle resolved_klass = SystemDictionary::MethodHandle_klass();

  assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic ||

         resolved_method->is_compiled_lambda_form(),

         "linkMethod must return one of these");

  int vtable_index = Method::nonvirtual_vtable_index;

  assert(!resolved_method->has_vtable_index(), "");

  set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);

  _resolved_appendix    = resolved_appendix;

  _resolved_method_type = resolved_method_type;

}

void CallInfo::set_common(KlassHandle resolved_klass,

                          KlassHandle selected_klass,

                          const methodHandle& resolved_method,

                          const methodHandle& selected_method,

                          CallKind kind,

                          int index,

                          TRAPS) {

  assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");

  _resolved_klass  = resolved_klass;

  _selected_klass  = selected_klass;

  _resolved_method = resolved_method;

  _selected_method = selected_method;

  _call_kind       = kind;

  _call_index      = index;

  _resolved_appendix = Handle();

  DEBUG_ONLY(verify());  // verify before making side effects

  if (CompilationPolicy::must_be_compiled(selected_method)) {

    // This path is unusual, mostly used by the '-Xcomp' stress test mode.

    // Note: with several active threads, the must_be_compiled may be true

    //       while can_be_compiled is false; remove assert

    // assert(CompilationPolicy::can_be_compiled(selected_method), "cannot compile");

    if (THREAD->is_Compiler_thread()) {

      // don't force compilation, resolve was on behalf of compiler

      return;

    }

    if (selected_method->method_holder()->is_not_initialized()) {

      // 'is_not_initialized' means not only '!is_initialized', but also that

      // initialization has not been started yet ('!being_initialized')

      // Do not force compilation of methods in uninitialized classes.

      // Note that doing this would throw an assert later,

      // in CompileBroker::compile_method.

      // We sometimes use the link resolver to do reflective lookups

      // even before classes are initialized.

      return;

    }

    CompileBroker::compile_method(selected_method, InvocationEntryBci,

                                  CompilationPolicy::policy()->initial_compile_level(),

                                  methodHandle(), 0, "must_be_compiled", CHECK);

  }

}

// utility query for unreflecting a method

CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass) {

  Klass* resolved_method_holder = resolved_method->method_holder();

  if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st

    resolved_klass = resolved_method_holder;

  }

  _resolved_klass  = resolved_klass;

  _selected_klass  = resolved_klass;

  _resolved_method = resolved_method;

  _selected_method = resolved_method;

  // classify:

  CallKind kind = CallInfo::unknown_kind;

  int index = resolved_method->vtable_index();

  if (resolved_method->can_be_statically_bound()) {

    kind = CallInfo::direct_call;

  } else if (!resolved_method_holder->is_interface()) {

    // Could be an Object method inherited into an interface, but still a vtable call.

    kind = CallInfo::vtable_call;

  } else if (!resolved_klass->is_interface()) {

    // A default or miranda method.  Compute the vtable index.

    ResourceMark rm;

    klassVtable* vt = InstanceKlass::cast(resolved_klass)->vtable();

    index = LinkResolver::vtable_index_of_interface_method(resolved_klass,

                           resolved_method);

    assert(index >= 0 , "we should have valid vtable index at this point");

    kind = CallInfo::vtable_call;

  } else if (resolved_method->has_vtable_index()) {

    // Can occur if an interface redeclares a method of Object.

#ifdef ASSERT

    // Ensure that this is really the case.

    KlassHandle object_klass = SystemDictionary::Object_klass();

    Method * object_resolved_method = object_klass()->vtable()->method_at(index);

    assert(object_resolved_method->name() == resolved_method->name(),

    assert(object_resolved_method->signature() == resolved_method->signature(),

#endif // ASSERT

    kind = CallInfo::vtable_call;

  } else {

    // A regular interface call.

    kind = CallInfo::itable_call;

    index = resolved_method->itable_index();

  }

  _call_kind  = kind;

  _call_index = index;

  _resolved_appendix = Handle();

  DEBUG_ONLY(verify());

}

#ifdef ASSERT

void CallInfo::verify() {

  switch (call_kind()) {  // the meaning and allowed value of index depends on kind

  case CallInfo::direct_call:

    if (_call_index == Method::nonvirtual_vtable_index)  break;

    // else fall through to check vtable index:

  case CallInfo::vtable_call:

    assert(resolved_klass()->verify_vtable_index(_call_index), "");

    break;

  case CallInfo::itable_call:

    assert(resolved_method()->method_holder()->verify_itable_index(_call_index), "");

    break;

  case CallInfo::unknown_kind:

    assert(call_kind() != CallInfo::unknown_kind, "CallInfo must be set");

    break;

  default:

  }

}

#endif //ASSERT

#ifndef PRODUCT

void CallInfo::print() {

  ResourceMark rm;

  const char* kindstr = "unknown";

  switch (_call_kind) {

  case direct_call: kindstr = "direct"; break;

  case vtable_call: kindstr = "vtable"; break;

  case itable_call: kindstr = "itable"; break;

  }

  tty->print_cr("Call %s@%d %s", kindstr, _call_index,

                _resolved_method.is_null() ? "(none)" : _resolved_method->name_and_sig_as_C_string());

}

#endif

//------------------------------------------------------------------------------------------------------------------------

// Implementation of LinkInfo

LinkInfo::LinkInfo(constantPoolHandle pool, int index, TRAPS) {

   // resolve klass

  Klass* result = pool->klass_ref_at(index, CHECK);

  _resolved_klass = KlassHandle(THREAD, result);

  // Get name, signature, and static klass

  _name          = pool->name_ref_at(index);

  _signature     = pool->signature_ref_at(index);

  _current_klass = KlassHandle(THREAD, pool->pool_holder());

  // Coming from the constant pool always checks access

  _check_access  = true;

}

char* LinkInfo::method_string() const {

  return Method::name_and_sig_as_C_string(_resolved_klass(), _name, _signature);

}

#ifndef PRODUCT

void LinkInfo::print() {

  ResourceMark rm;

  tty->print_cr("Link resolved_klass=%s name=%s signature=%s current_klass=%s check_access=%s",

                _resolved_klass->name()->as_C_string(),

                _name->as_C_string(),

                _signature->as_C_string(),

                _current_klass.is_null() ? "(none)" : _current_klass->name()->as_C_string(),

                _check_access ? "true" : "false");

}

#endif // PRODUCT

//------------------------------------------------------------------------------------------------------------------------

// Klass resolution

void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) {

  if (!Reflection::verify_class_access(ref_klass(),

                                       sel_klass(),

                                       true)) {

    ResourceMark rm(THREAD);

    Exceptions::fthrow(

      THREAD_AND_LOCATION,

      vmSymbols::java_lang_IllegalAccessError(),

      "tried to access class %s from class %s",

      sel_klass->external_name(),

      ref_klass->external_name()

    );

    return;

  }

}

//------------------------------------------------------------------------------------------------------------------------

// Method resolution

//

// According to JVM spec. $5.4.3c & $5.4.3d

// Look up method in klasses, including static methods

// Then look up local default methods

methodHandle LinkResolver::lookup_method_in_klasses(const LinkInfo& link_info,

                                                    bool checkpolymorphism,

                                                    bool in_imethod_resolve, TRAPS) {

  KlassHandle klass = link_info.resolved_klass();

  Symbol* name = link_info.name();

  Symbol* signature = link_info.signature();

  // Ignore overpasses so statics can be found during resolution

  Method* result = klass->uncached_lookup_method(name, signature, Klass::skip_overpass);

  if (klass->oop_is_array()) {

    // Only consider klass and super klass for arrays

    return methodHandle(THREAD, result);

  }

  // JDK 8, JVMS 5.4.3.4: Interface method resolution should

  // ignore static and non-public methods of java.lang.Object,

  // like clone, finalize, registerNatives.

  if (in_imethod_resolve &&

      result != NULL &&

      klass->is_interface() &&

      (result->is_static() || !result->is_public()) &&

      result->method_holder() == SystemDictionary::Object_klass()) {

    result = NULL;

  }

  // Before considering default methods, check for an overpass in the

  // current class if a method has not been found.

  if (result == NULL) {

    result = InstanceKlass::cast(klass())->find_method(name, signature);

  }

  if (result == NULL) {

    Array<Method*>* default_methods = InstanceKlass::cast(klass())->default_methods();

    if (default_methods != NULL) {

      result = InstanceKlass::find_method(default_methods, name, signature);

    }

  }

  if (checkpolymorphism && result != NULL) {

    vmIntrinsics::ID iid = result->intrinsic_id();

    if (MethodHandles::is_signature_polymorphic(iid)) {

      // Do not link directly to these.  The VM must produce a synthetic one using lookup_polymorphic_method.

      return NULL;

    }

  }

  return methodHandle(THREAD, result);

}

// returns first instance method

// Looks up method in classes, then looks up local default methods

methodHandle LinkResolver::lookup_instance_method_in_klasses(KlassHandle klass,

                                                             Symbol* name,

                                                             Symbol* signature, TRAPS) {

  Method* result = klass->uncached_lookup_method(name, signature, Klass::find_overpass);

  while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {

    Klass* super_klass = result->method_holder()->super();

    result = super_klass->uncached_lookup_method(name, signature, Klass::find_overpass);

  }

  if (klass->oop_is_array()) {

    // Only consider klass and super klass for arrays

    return methodHandle(THREAD, result);

  }

  if (result == NULL) {

    Array<Method*>* default_methods = InstanceKlass::cast(klass())->default_methods();

    if (default_methods != NULL) {

      result = InstanceKlass::find_method(default_methods, name, signature);

      assert(result == NULL || !result->is_static(), "static defaults not allowed");

    }

  }

  return methodHandle(THREAD, result);

}

int LinkResolver::vtable_index_of_interface_method(KlassHandle klass,

                                                   const methodHandle& resolved_method) {

  int vtable_index = Method::invalid_vtable_index;

  Symbol* name = resolved_method->name();

  Symbol* signature = resolved_method->signature();

  // First check in default method array

  if (!resolved_method->is_abstract() &&

    (InstanceKlass::cast(klass())->default_methods() != NULL)) {

    int index = InstanceKlass::find_method_index(InstanceKlass::cast(klass())->default_methods(),

                                                 name, signature, Klass::find_overpass,

                                                 Klass::find_static, Klass::find_private);

    if (index >= 0 ) {

      vtable_index = InstanceKlass::cast(klass())->default_vtable_indices()->at(index);

    }

  }

  if (vtable_index == Method::invalid_vtable_index) {

    // get vtable_index for miranda methods

    ResourceMark rm;

    klassVtable *vt = InstanceKlass::cast(klass())->vtable();

    vtable_index = vt->index_of_miranda(name, signature);

  }

  return vtable_index;

}

methodHandle LinkResolver::lookup_method_in_interfaces(const LinkInfo& cp_info, TRAPS) {

  InstanceKlass *ik = InstanceKlass::cast(cp_info.resolved_klass()());

  // Specify 'true' in order to skip default methods when searching the

  // interfaces.  Function lookup_method_in_klasses() already looked for

  // the method in the default methods table.

  return methodHandle(THREAD,

    ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(),

    Klass::skip_defaults));

}

methodHandle LinkResolver::lookup_polymorphic_method(

                                             const LinkInfo& link_info,

                                             Handle *appendix_result_or_null,

                                             Handle *method_type_result,

                                             TRAPS) {

  KlassHandle klass = link_info.resolved_klass();

  Symbol* name = link_info.name();

  Symbol* full_signature = link_info.signature();

  vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name);

  if (TraceMethodHandles) {

    ResourceMark rm(THREAD);

    tty->print_cr("lookup_polymorphic_method iid=%s %s.%s%s",

                  vmIntrinsics::name_at(iid), klass->external_name(),

                  name->as_C_string(), full_signature->as_C_string());

  }

  if (klass() == SystemDictionary::MethodHandle_klass() &&

      iid != vmIntrinsics::_none) {

    if (MethodHandles::is_signature_polymorphic_intrinsic(iid)) {

      // Most of these do not need an up-call to Java to resolve, so can be done anywhere.

      // Do not erase last argument type (MemberName) if it is a static linkTo method.

      bool keep_last_arg = MethodHandles::is_signature_polymorphic_static(iid);

      TempNewSymbol basic_signature =

        MethodHandles::lookup_basic_type_signature(full_signature, keep_last_arg, CHECK_NULL);

      if (TraceMethodHandles) {

        ResourceMark rm(THREAD);

        tty->print_cr("lookup_polymorphic_method %s %s => basic %s",

                      name->as_C_string(),

                      full_signature->as_C_string(),

                      basic_signature->as_C_string());

      }

      methodHandle result = SystemDictionary::find_method_handle_intrinsic(iid,

                                                              basic_signature,

                                                              CHECK_NULL);

      if (result.not_null()) {

        assert(result->is_method_handle_intrinsic(), "MH.invokeBasic or MH.linkTo* intrinsic");

        assert(result->intrinsic_id() != vmIntrinsics::_invokeGeneric, "wrong place to find this");

        assert(basic_signature == result->signature(), "predict the result signature");

        if (TraceMethodHandles) {

          tty->print("lookup_polymorphic_method => intrinsic ");

          result->print_on(tty);

        }

      }

      return result;

    } else if (iid == vmIntrinsics::_invokeGeneric

               && !THREAD->is_Compiler_thread()

               && appendix_result_or_null != NULL) {

      // This is a method with type-checking semantics.

      // We will ask Java code to spin an adapter method for it.

      if (!MethodHandles::enabled()) {

        // Make sure the Java part of the runtime has been booted up.

        Klass* natives = SystemDictionary::MethodHandleNatives_klass();

        if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) {

          SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(),

                                            Handle(),

                                            Handle(),

                                            true,

                                            CHECK_NULL);

        }

      }

      Handle appendix;

      Handle method_type;

      methodHandle result = SystemDictionary::find_method_handle_invoker(

                                                            name,

                                                            full_signature,

                                                            link_info.current_klass(),

                                                            &appendix,

                                                            &method_type,

                                                            CHECK_NULL);

      if (TraceMethodHandles) {

        tty->print("lookup_polymorphic_method => (via Java) ");

        result->print_on(tty);

        tty->print("  lookup_polymorphic_method => appendix = ");

        if (appendix.is_null())  tty->print_cr("(none)");

        else                     appendix->print_on(tty);

      }

      if (result.not_null()) {

#ifdef ASSERT

        ResourceMark rm(THREAD);

        TempNewSymbol basic_signature =

          MethodHandles::lookup_basic_type_signature(full_signature, CHECK_NULL);