/*

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

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "thread_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "thread_bsd.inline.hpp"

#endif

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

// Implementation of FieldAccessInfo

void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset,

BasicType field_type, AccessFlags access_flags) {

  _klass        = klass;

  _name         = name;

  _field_index  = field_index;

  _field_offset = field_offset;

  _field_type   = field_type;

  _access_flags = access_flags;

}

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

// 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, vtable_index, CHECK);

}

void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, 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.

  // Other than that case, there is no valid vtable index to specify.

  int vtable_index = Method::invalid_vtable_index;

  if (resolved_method->method_holder() == SystemDictionary::Object_klass()) {

    assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check");

    vtable_index = resolved_method->vtable_index();

  }

  set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_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");

  set_common(resolved_klass, selected_klass, resolved_method, selected_method, 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->vtable_index() == vtable_index, "");

  set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, 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, int vtable_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;

  _vtable_index    = vtable_index;

  _resolved_appendix = Handle();

  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;

    }

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

  }

}

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

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

}

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

  Klass* result_oop =

         ConstantPool::klass_ref_at_if_loaded_check(pool, index, CHECK);

  result = KlassHandle(THREAD, result_oop);

}

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

// Method resolution

//

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

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

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

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

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

    klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super());

    result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature));

  }

}

int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {

  ResourceMark rm(THREAD);

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

  return vt->index_of_miranda(name, signature);

}

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

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

        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

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

  //

  // We'll check for the method name first, as that's most likely

  // to be false (so we'll short-circuit out of these tests).

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

      sel_klass() == SystemDictionary::Object_klass() &&

      resolved_klass->oop_is_array()) {

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

    assert(flags.is_protected(), "clone 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) {

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

      || (resolved_klass() == SystemDictionary::MethodHandle_klass() &&

          MethodHandles::is_signature_polymorphic_name(resolved_klass(), method_name))) {

    Method* result_oop = ConstantPool::method_at_if_loaded(pool, index);

    if (result_oop != NULL) {

      resolved_method = methodHandle(THREAD, result_oop);

      return;

    }

  }

  if (code == Bytecodes::_invokeinterface) {

    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK);

  } else {

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

  }

}

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

                                  Symbol* method_name, Symbol* method_signature,

                                  KlassHandle current_klass, bool check_access, TRAPS) {

  Handle nested_exception;

  // 1. lookup method in resolved klass and its super klasses

  lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK);

  if (resolved_method.is_null()) { // not found in the class hierarchy

    // 2. lookup method in all the interfaces implemented by the resolved klass

    lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK);

    if (resolved_method.is_null()) {

      // JSR 292:  see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc

      lookup_polymorphic_method(resolved_method, resolved_klass, method_name, method_signature,

                                current_klass, (Handle*)NULL, (Handle*)NULL, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        nested_exception = Handle(THREAD, PENDING_EXCEPTION);

        CLEAR_PENDING_EXCEPTION;

      }

    }

    if (resolved_method.is_null()) {

      // 3. method lookup failed

      ResourceMark rm(THREAD);

      THROW_MSG_CAUSE(vmSymbols::java_lang_NoSuchMethodError(),

                      Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),

                                                              method_name,

                                                              method_signature),

                      nested_exception);

    }

  }

  // 4. check if klass is not interface

  if (resolved_klass->is_interface() && resolved_method->is_abstract()) {

    ResourceMark rm(THREAD);

    char buf[200];

    jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected",

        resolved_klass()->external_name());

    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);

  }

  // 5. check if method is concrete

  if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) {

    ResourceMark rm(THREAD);

    THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),

              Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),

                                                      method_name,

                                                      method_signature));

  }

  // 6. access checks, access checking may be turned off when calling from within the VM.

  if (check_access) {

    assert(current_klass.not_null() , "current_klass should not be null");

    // check if method can be accessed by the referring class

    check_method_accessability(current_klass,

                               resolved_klass,

                               KlassHandle(THREAD, resolved_method->method_holder()),

                               resolved_method,

                               CHECK);

    // check loader constraints

    Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader());

    {

      ResourceMark rm(THREAD);

      char* failed_type_name =

        SystemDictionary::check_signature_loaders(method_signature, loader,

                                                  class_loader, true, CHECK);

      if (failed_type_name != NULL) {

        const char* msg = "loader constraint violation: when resolving method"

          " \"%s\" the class loader (instance of %s) of the current class, %s,"

          " and the class loader (instance of %s) for resolved class, %s, have"

          " different Class objects for the type %s used in the signature";

        char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature);

        const char* loader1 = SystemDictionary::loader_name(loader());

        char* current = InstanceKlass::cast(current_klass())->name()->as_C_string();

        const char* loader2 = SystemDictionary::loader_name(class_loader());

        char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string();

        size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +

          strlen(current) + strlen(loader2) + strlen(resolved) +

          strlen(failed_type_name);

        char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);

        jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,

                     resolved, failed_type_name);

        THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);

      }

    }

  }

}

void LinkResolver::resolve_interface_method(methodHandle& resolved_method,

                                            KlassHandle resolved_klass,

                                            Symbol* method_name,

                                            Symbol* method_signature,

                                            KlassHandle current_klass,