/*

 * Copyright (c) 1997, 2019, 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 "jvm.h"

#include "classfile/defaultMethods.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/resolutionErrors.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compilationPolicy.hpp"

#include "compiler/compileBroker.hpp"

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

#include "interpreter/bootstrapInfo.hpp"

#include "interpreter/bytecode.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "interpreter/linkResolver.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/resourceArea.hpp"

#include "oops/constantPool.hpp"

#include "oops/cpCache.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/method.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/reflection.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/signature.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/vmThread.hpp"

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

// Implementation of CallInfo

void CallInfo::set_static(Klass* 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(Klass* resolved_klass,

                             Klass* 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(Klass* resolved_klass,

                           Klass* 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, TRAPS) {

  set_handle(SystemDictionary::MethodHandle_klass(), resolved_method, resolved_appendix, CHECK);

}

void CallInfo::set_handle(Klass* resolved_klass,

                          const methodHandle& resolved_method,

                          Handle resolved_appendix, TRAPS) {

  guarantee(resolved_method.not_null(), "resolved method is null");

  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;

}

void CallInfo::set_common(Klass* resolved_klass,

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

  CompilationPolicy::compile_if_required(selected_method, THREAD);

}

// utility query for unreflecting a method

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

  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;

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

    index = LinkResolver::vtable_index_of_interface_method(resolved_klass,

    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.

    Klass* object_klass = SystemDictionary::Object_klass();

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

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

      "Object and interface method names should match at vtable index %d, %s != %s",

      index, object_resolved_method->name()->as_C_string(), resolved_method->name()->as_C_string());

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

      "Object and interface method signatures should match at vtable index %d, %s != %s",

      index, object_resolved_method->signature()->as_C_string(), resolved_method->signature()->as_C_string());

#endif // ASSERT

    kind = CallInfo::vtable_call;

  } else {

    // A regular interface call.

    kind = CallInfo::itable_call;

    index = resolved_method->itable_index();

  }

  assert(index == Method::nonvirtual_vtable_index || index >= 0, "bad index %d", index);

  _call_kind  = kind;

  _call_index = index;

  _resolved_appendix = Handle();

  // Find or create a ResolvedMethod instance for this Method*

  set_resolved_method_name(CHECK);

  DEBUG_ONLY(verify());

}

void CallInfo::set_resolved_method_name(TRAPS) {

  _resolved_method_name = Handle(THREAD, rmethod_name);

}

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

    fatal("Unexpected call kind %d", call_kind());

  }

}

#endif // ASSERT

#ifndef PRODUCT

void CallInfo::print() {

  ResourceMark rm;

  const char* kindstr;

  switch (_call_kind) {

  case direct_call: kindstr = "direct";  break;

  case vtable_call: kindstr = "vtable";  break;

  case itable_call: kindstr = "itable";  break;

  default         : kindstr = "unknown"; 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(const constantPoolHandle& pool, int index, const methodHandle& current_method, TRAPS) {

   // resolve klass

  _resolved_klass = pool->klass_ref_at(index, CHECK);

  // Get name, signature, and static klass

  _name          = pool->name_ref_at(index);

  _signature     = pool->signature_ref_at(index);

  _tag           = pool->tag_ref_at(index);

  _current_klass = pool->pool_holder();

  _current_method = current_method;

  // Coming from the constant pool always checks access

  _check_access  = true;

}

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

   // resolve klass

  _resolved_klass = pool->klass_ref_at(index, CHECK);

  // Get name, signature, and static klass

  _name          = pool->name_ref_at(index);

  _signature     = pool->signature_ref_at(index);

  _tag           = pool->tag_ref_at(index);

  _current_klass = pool->pool_holder();

  _current_method = methodHandle();

  // Coming from the constant pool always checks access

  _check_access  = true;

}

#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 == NULL ? "(none)" : _current_klass->name()->as_C_string(),

                _check_access ? "true" : "false");

}

#endif // PRODUCT

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

// Klass resolution

void LinkResolver::check_klass_accessability(Klass* ref_klass, Klass* sel_klass,

                                             bool fold_type_to_class, TRAPS) {

  Klass* base_klass = sel_klass;

  if (fold_type_to_class) {

    if (sel_klass->is_objArray_klass()) {

      base_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();

    }

    // The element type could be a typeArray - we only need the access

    // check if it is a reference to another class.

    if (!base_klass->is_instance_klass()) {

      return;  // no relevant check to do

    }

  }

  Reflection::VerifyClassAccessResults vca_result =

    Reflection::verify_class_access(ref_klass, InstanceKlass::cast(base_klass), true);

  if (vca_result != Reflection::ACCESS_OK) {

    ResourceMark rm(THREAD);

    char* msg = Reflection::verify_class_access_msg(ref_klass,

                                                    InstanceKlass::cast(base_klass),

                                                    vca_result);

    bool same_module = (base_klass->module() == ref_klass->module());

    if (msg == NULL) {

      Exceptions::fthrow(

        THREAD_AND_LOCATION,

        vmSymbols::java_lang_IllegalAccessError(),

        "failed to access class %s from class %s (%s%s%s)",

        base_klass->external_name(),

        ref_klass->external_name(),

        (same_module) ? base_klass->joint_in_module_of_loader(ref_klass) : base_klass->class_in_module_of_loader(),

        (same_module) ? "" : "; ",

        (same_module) ? "" : ref_klass->class_in_module_of_loader());

    } else {

      // Use module specific message returned by verify_class_access_msg().

      Exceptions::fthrow(

        THREAD_AND_LOCATION,

        vmSymbols::java_lang_IllegalAccessError(),

        "%s", msg);

    }

  }

}

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

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

Method* LinkResolver::lookup_method_in_klasses(const LinkInfo& link_info,

                                               bool checkpolymorphism,

                                               bool in_imethod_resolve) {

  NoSafepointVerifier nsv;  // Method* returned may not be reclaimed

  Klass* 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->is_array_klass()) {

    // Only consider klass and super klass for arrays

    return result;

  }

  InstanceKlass* ik = InstanceKlass::cast(klass);

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

      ik->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 = ik->find_method(name, signature);

  }

  if (result == NULL) {

    Array<Method*>* default_methods = ik->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 result;

}

// returns first instance method

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

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

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

  }

  if (klass->is_array_klass()) {

    // Only consider klass and super klass for arrays

  }

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

    }

  }

}

int LinkResolver::vtable_index_of_interface_method(Klass* klass,

                                                   const methodHandle& resolved_method) {

  int vtable_index = Method::invalid_vtable_index;

  Symbol* name = resolved_method->name();

  Symbol* signature = resolved_method->signature();

  InstanceKlass* ik = InstanceKlass::cast(klass);

  // First check in default method array

  if (!resolved_method->is_abstract() && ik->default_methods() != NULL) {

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

                                                 name, signature, Klass::find_overpass,

                                                 Klass::find_static, Klass::find_private);

    if (index >= 0 ) {

      vtable_index = ik->default_vtable_indices()->at(index);

    }

  }

  if (vtable_index == Method::invalid_vtable_index) {

    // get vtable_index for miranda methods

    klassVtable vt = ik->vtable();

    vtable_index = vt.index_of_miranda(name, signature);

  }

  return vtable_index;

}

Method* LinkResolver::lookup_method_in_interfaces(const LinkInfo& cp_info) {

  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 ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::skip_defaults);

}

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

       klass == SystemDictionary::VarHandle_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());

      }

                                                              basic_signature,

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

          ttyLocker ttyl;

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

          result->print_on(tty);

        }

      }