/*

 * 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/defaultMethods.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "gc_interface/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 "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, 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, methodHandle resolved_method, 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, methodHandle resolved_method, 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(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,

                          methodHandle resolved_method,

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

      err_msg("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(),

      err_msg("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, err_msg("bad index %d", 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:

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

  }

}

#endif //ASSERT

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

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

  }

}

void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {

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

  result = KlassHandle(THREAD, result_oop);

}

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

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

void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, bool checkpolymorphism, TRAPS) {

  Method* result_oop = klass->uncached_lookup_method(name, signature);

  if (result_oop == NULL) {

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

    if (default_methods != NULL) {

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

    }

  }

  if (checkpolymorphism && EnableInvokeDynamic && result_oop != NULL) {

    vmIntrinsics::ID iid = result_oop->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;

    }

  }

  result = methodHandle(THREAD, result_oop);

}

// returns first instance method

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

void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {

  Method* result_oop = klass->uncached_lookup_method(name, signature);

  result = methodHandle(THREAD, result_oop);

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

  }

  if (result.is_null()) {

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

    if (default_methods != NULL) {

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

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

    }

  }

}

int LinkResolver::vtable_index_of_interface_method(KlassHandle klass,

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

    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;

}

void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {

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

  result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature));

}

void LinkResolver::lookup_polymorphic_method(methodHandle& result,

                                             KlassHandle klass, Symbol* name, Symbol* full_signature,

                                             KlassHandle current_klass,

                                             Handle *appendix_result_or_null,

                                             Handle *method_type_result,

                                             TRAPS) {

  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 (EnableInvokeDynamic &&

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

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

      }

      result = SystemDictionary::find_method_handle_intrinsic(iid,

                                                              basic_signature,

                                                              CHECK);

      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;

      }

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

        }

      }

      Handle appendix;

      Handle method_type;

      result = SystemDictionary::find_method_handle_invoker(name,

                                                            full_signature,

                                                            current_klass,

                                                            &appendix,

                                                            &method_type,

                                                            CHECK);

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

        int actual_size_of_params = result->size_of_parameters();

        int expected_size_of_params = ArgumentSizeComputer(basic_signature).size();

        // +1 for MethodHandle.this, +1 for trailing MethodType

        if (!MethodHandles::is_signature_polymorphic_static(iid))  expected_size_of_params += 1;

        if (appendix.not_null())                                   expected_size_of_params += 1;

        if (actual_size_of_params != expected_size_of_params) {

          tty->print_cr("*** basic_signature=%s", basic_signature->as_C_string());

          tty->print_cr("*** result for %s: ", vmIntrinsics::name_at(iid));

          result->print();

        }

        assert(actual_size_of_params == expected_size_of_params,

               err_msg("%d != %d", actual_size_of_params, expected_size_of_params));

#endif //ASSERT

        assert(appendix_result_or_null != NULL, "");

        (*appendix_result_or_null) = appendix;

        (*method_type_result)      = method_type;

        return;

      }

    }

  }

}

void LinkResolver::check_method_accessability(KlassHandle ref_klass,

                                              KlassHandle resolved_klass,

                                              KlassHandle sel_klass,

                                              methodHandle sel_method,

                                              TRAPS) {

  AccessFlags flags = sel_method->access_flags();

  // Special case #1:  arrays always override "clone". JVMS 2.15.

  // If the resolved klass is an array class, and the declaring class

  // is java.lang.Object and the method is "clone", set the flags

  // to public.

  // Special case #2:  If the resolved klass is an interface, and

  // the declaring class is java.lang.Object, and the method is

  // "clone" or "finalize", set the flags to public. If the

  // resolved interface does not contain "clone" or "finalize"

  // methods, the method/interface method resolution looks to

  // the interface's super class, java.lang.Object.  With JDK 8

  // interface accessability check requirement, special casing

  // this scenario is necessary to avoid an IAE.

  //

  // We'll check for each method name first and then java.lang.Object

  // to best short-circuit out of these tests.

  if (((sel_method->name() == vmSymbols::clone_name() &&

        (resolved_klass->oop_is_array() || resolved_klass->is_interface())) ||

       (sel_method->name() == vmSymbols::finalize_method_name() &&

        resolved_klass->is_interface())) &&

      sel_klass() == SystemDictionary::Object_klass()) {

    // We need to change "protected" to "public".

    assert(flags.is_protected(), "clone or finalize not protected?");

    jint new_flags = flags.as_int();

    new_flags = new_flags & (~JVM_ACC_PROTECTED);

    new_flags = new_flags | JVM_ACC_PUBLIC;

    flags.set_flags(new_flags);

  }

//  assert(extra_arg_result_or_null != NULL, "must be able to return extra argument");

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

                                       resolved_klass(),

                                       sel_klass(),

                                       flags,

                                       true)) {

    ResourceMark rm(THREAD);

    Exceptions::fthrow(

      THREAD_AND_LOCATION,

      vmSymbols::java_lang_IllegalAccessError(),

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

      sel_klass->external_name(),

      sel_method->name()->as_C_string(),

      sel_method->signature()->as_C_string(),

      ref_klass->external_name()

    );

    return;

  }

}

void LinkResolver::resolve_method_statically(methodHandle& resolved_method, KlassHandle& resolved_klass,

                                             Bytecodes::Code code, constantPoolHandle pool, int index, TRAPS) {

  // This method is used only

  // (1) in C2 from InlineTree::ok_to_inline (via ciMethod::check_call),

  // and

  // (2) in Bytecode_invoke::static_target

  // It appears to fail when applied to an invokeinterface call site.

  // FIXME: Remove this method and ciMethod::check_call; refactor to use the other LinkResolver entry points.

  // resolve klass

  if (code == Bytecodes::_invokedynamic) {

    resolved_klass = SystemDictionary::MethodHandle_klass();

    Symbol* method_name = vmSymbols::invoke_name();

    Symbol* method_signature = pool->signature_ref_at(index);

    KlassHandle  current_klass(THREAD, pool->pool_holder());

    resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, false, CHECK);

    return;

  }

  resolve_klass(resolved_klass, pool, index, CHECK);

  Symbol*  method_name       = pool->name_ref_at(index);

  Symbol*  method_signature  = pool->signature_ref_at(index);

  KlassHandle  current_klass(THREAD, pool->pool_holder());

  if (pool->has_preresolution()