/*

 * Copyright (c) 2008, 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/javaClasses.inline.hpp"

#include "classfile/stringTable.hpp"

#include "code/codeCache.hpp"

#include "code/codeCacheExtensions.hpp"

#include "compiler/compileBroker.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/methodHandles.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/reflection.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubRoutines.hpp"

#include "utilities/exceptions.hpp"

/*

 * JSR 292 reference implementation: method handles

 * The JDK 7 reference implementation represented method handle

 * combinations as chains.  Each link in the chain had a "vmentry"

 * field which pointed at a bit of assembly code which performed

 * one transformation before dispatching to the next link in the chain.

 *

 * The current reference implementation pushes almost all code generation

 * responsibility to (trusted) Java code.  A method handle contains a

 * pointer to its "LambdaForm", which embodies all details of the method

 * handle's behavior.  The LambdaForm is a normal Java object, managed

 * by a runtime coded in Java.

 */

bool MethodHandles::_enabled = false; // set true after successful native linkage

MethodHandlesAdapterBlob* MethodHandles::_adapter_code = NULL;

/**

 * Generates method handle adapters. Returns 'false' if memory allocation

 * failed and true otherwise.

 */

bool MethodHandles::generate_adapters() {

  if (SystemDictionary::MethodHandle_klass() == NULL) {

    return true;

  }

  assert(_adapter_code == NULL, "generate only once");

  ResourceMark rm;

  TraceTime timer("MethodHandles adapters generation", TraceStartupTime);

  _adapter_code = MethodHandlesAdapterBlob::create(adapter_code_size);

  if (_adapter_code == NULL) {

     return false;

  }

  CodeBuffer code(_adapter_code);

  MethodHandlesAdapterGenerator g(&code);

  g.generate();

  code.log_section_sizes("MethodHandlesAdapterBlob");

  return true;

}

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

// MethodHandlesAdapterGenerator::generate

//

void MethodHandlesAdapterGenerator::generate() {

  // Generate generic method handle adapters.

  // Generate interpreter entries

  for (Interpreter::MethodKind mk = Interpreter::method_handle_invoke_FIRST;

       mk <= Interpreter::method_handle_invoke_LAST;

       mk = Interpreter::MethodKind(1 + (int)mk)) {

    vmIntrinsics::ID iid = Interpreter::method_handle_intrinsic(mk);

    StubCodeMark mark(this, "MethodHandle::interpreter_entry", vmIntrinsics::name_at(iid));

    address entry = MethodHandles::generate_method_handle_interpreter_entry(_masm, iid);

    if (entry != NULL) {

      CodeCacheExtensions::handle_generated_pc(entry, vmIntrinsics::name_at(iid));

      Interpreter::set_entry_for_kind(mk, entry);

    }

    // If the entry is not set, it will throw AbstractMethodError.

  }

}

void MethodHandles::set_enabled(bool z) {

  if (_enabled != z) {

    guarantee(z, "can only enable once");

    _enabled = z;

  }

}

// MemberName support

// import java_lang_invoke_MemberName.*

enum {

  IS_METHOD            = java_lang_invoke_MemberName::MN_IS_METHOD,

  IS_CONSTRUCTOR       = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,

  IS_FIELD             = java_lang_invoke_MemberName::MN_IS_FIELD,

  IS_TYPE              = java_lang_invoke_MemberName::MN_IS_TYPE,

  CALLER_SENSITIVE     = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,

  REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,

  REFERENCE_KIND_MASK  = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,

  SEARCH_SUPERCLASSES  = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES,

  SEARCH_INTERFACES    = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES,

  ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE

};

Handle MethodHandles::new_MemberName(TRAPS) {

  Handle empty;

  instanceKlassHandle k(THREAD, SystemDictionary::MemberName_klass());

  if (!k->is_initialized())  k->initialize(CHECK_(empty));

  return Handle(THREAD, k->allocate_instance(THREAD));

}

oop MethodHandles::init_MemberName(Handle mname, Handle target) {

  // This method is used from java.lang.invoke.MemberName constructors.

  // It fills in the new MemberName from a java.lang.reflect.Member.

  Thread* thread = Thread::current();

  oop target_oop = target();

  Klass* target_klass = target_oop->klass();

  if (target_klass == SystemDictionary::reflect_Field_klass()) {

    oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()

    int slot  = java_lang_reflect_Field::slot(target_oop);  // fd.index()

    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));

      fieldDescriptor fd(InstanceKlass::cast(k()), slot);

      oop mname2 = init_field_MemberName(mname, fd);

      if (mname2 != NULL) {

        // Since we have the reified name and type handy, add them to the result.

        if (java_lang_invoke_MemberName::name(mname2) == NULL)

          java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop));

        if (java_lang_invoke_MemberName::type(mname2) == NULL)

          java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop));

      }

      return mname2;

    }

  } else if (target_klass == SystemDictionary::reflect_Method_klass()) {

    oop clazz  = java_lang_reflect_Method::clazz(target_oop);

    int slot   = java_lang_reflect_Method::slot(target_oop);

    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));

      Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);

      if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))

        return NULL;            // do not resolve unless there is a concrete signature

      CallInfo info(m, k());

      return init_method_MemberName(mname, info);

    }

  } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {

    oop clazz  = java_lang_reflect_Constructor::clazz(target_oop);

    int slot   = java_lang_reflect_Constructor::slot(target_oop);

    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));

      Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);

      if (m == NULL)  return NULL;

      CallInfo info(m, k());

      return init_method_MemberName(mname, info);

    }

  }

  return NULL;

}

oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {

  assert(info.resolved_appendix().is_null(), "only normal methods here");

  methodHandle m = info.resolved_method();

  assert(m.not_null(), "null method handle");

  KlassHandle m_klass = m->method_holder();

  assert(m.not_null(), "null holder for method handle");

  int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );

  int vmindex = Method::invalid_vtable_index;

  switch (info.call_kind()) {

  case CallInfo::itable_call:

    vmindex = info.itable_index();

    // More importantly, the itable index only works with the method holder.

    assert(m_klass->verify_itable_index(vmindex), "");

    flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);

    if (TraceInvokeDynamic) {

      ResourceMark rm;

      tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",

            Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),

            vmindex);

       m->access_flags().print_on(tty);

       if (!m->is_abstract()) {

         tty->print("default");

       }

       tty->cr();

    }

    break;

  case CallInfo::vtable_call:

    vmindex = info.vtable_index();

    flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);

    assert(info.resolved_klass()->is_subtype_of(m_klass()), "virtual call must be type-safe");

    if (m_klass->is_interface()) {

      // This is a vtable call to an interface method (abstract "miranda method" or default method).

      // The vtable index is meaningless without a class (not interface) receiver type, so get one.

      // (LinkResolver should help us figure this out.)

      KlassHandle m_klass_non_interface = info.resolved_klass();

      if (m_klass_non_interface->is_interface()) {

        m_klass_non_interface = SystemDictionary::Object_klass();

#ifdef ASSERT

        { ResourceMark rm;

          Method* m2 = m_klass_non_interface->vtable()->method_at(vmindex);

          assert(m->name() == m2->name() && m->signature() == m2->signature(),

                 "at %d, %s != %s", vmindex,

                 m->name_and_sig_as_C_string(), m2->name_and_sig_as_C_string());

        }

#endif //ASSERT

      }

      if (!m->is_public()) {

        assert(m->is_public(), "virtual call must be to public interface method");

        return NULL;  // elicit an error later in product build

      }

      assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface()), "virtual call must be type-safe");

      m_klass = m_klass_non_interface;

    }

    if (TraceInvokeDynamic) {

      ResourceMark rm;

      tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",

            Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),

            m_klass->internal_name(), vmindex);

       m->access_flags().print_on(tty);

       if (m->is_default_method()) {

         tty->print("default");

       }

       tty->cr();

    }

    break;

  case CallInfo::direct_call:

    vmindex = Method::nonvirtual_vtable_index;

    if (m->is_static()) {

      flags |= IS_METHOD      | (JVM_REF_invokeStatic  << REFERENCE_KIND_SHIFT);

    } else if (m->is_initializer()) {

      flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);

    } else {

      flags |= IS_METHOD      | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);

    }

    break;

  default:  assert(false, "bad CallInfo");  return NULL;

  }

  // @CallerSensitive annotation detected

  if (m->caller_sensitive()) {

    flags |= CALLER_SENSITIVE;

  }

  oop mname_oop = mname();

  java_lang_invoke_MemberName::set_flags(   mname_oop, flags);

  java_lang_invoke_MemberName::set_vmtarget(mname_oop, m());

  java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex);   // vtable/itable index

  java_lang_invoke_MemberName::set_clazz(   mname_oop, m_klass->java_mirror());

  // Note:  name and type can be lazily computed by resolve_MemberName,

  // if Java code needs them as resolved String and MethodType objects.

  // The clazz must be eagerly stored, because it provides a GC

  // root to help keep alive the Method*.

  // If relevant, the vtable or itable value is stored as vmindex.

  // This is done eagerly, since it is readily available without

  // constructing any new objects.

  // TO DO: maybe intern mname_oop

  if (m->method_holder()->add_member_name(mname)) {

    return mname();

  } else {

    // Redefinition caused this to fail.  Return NULL (and an exception?)

    return NULL;

  }

}

oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {

  int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );

  flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);

  if (is_setter)  flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);

  Metadata* vmtarget = fd.field_holder();

  int vmindex        = fd.offset();  // determines the field uniquely when combined with static bit

  oop mname_oop = mname();

  java_lang_invoke_MemberName::set_flags(mname_oop,    flags);

  java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);

  java_lang_invoke_MemberName::set_vmindex(mname_oop,  vmindex);

  java_lang_invoke_MemberName::set_clazz(mname_oop,    fd.field_holder()->java_mirror());

  oop type = field_signature_type_or_null(fd.signature());

  oop name = field_name_or_null(fd.name());

  if (name != NULL)

    java_lang_invoke_MemberName::set_name(mname_oop,   name);

  if (type != NULL)

    java_lang_invoke_MemberName::set_type(mname_oop,   type);

  // Note:  name and type can be lazily computed by resolve_MemberName,

  // if Java code needs them as resolved String and Class objects.

  // Note that the incoming type oop might be pre-resolved (non-null).

  // The base clazz and field offset (vmindex) must be eagerly stored,

  // because they unambiguously identify the field.

  // Although the fieldDescriptor::_index would also identify the field,

  // we do not use it, because it is harder to decode.

  // TO DO: maybe intern mname_oop

  return mname();

}

// JVM 2.9 Special Methods:

// A method is signature polymorphic if and only if all of the following conditions hold :

// * It is declared in the java.lang.invoke.MethodHandle class.

// * It has a single formal parameter of type Object[].

// * It has a return type of Object.

// * It has the ACC_VARARGS and ACC_NATIVE flags set.

bool MethodHandles::is_method_handle_invoke_name(Klass* klass, Symbol* name) {

  if (klass == NULL)

    return false;

  // The following test will fail spuriously during bootstrap of MethodHandle itself:

  //    if (klass != SystemDictionary::MethodHandle_klass())

  // Test the name instead:

  if (klass->name() != vmSymbols::java_lang_invoke_MethodHandle())

    return false;

  Symbol* poly_sig = vmSymbols::object_array_object_signature();

  Method* m = InstanceKlass::cast(klass)->find_method(name, poly_sig);

  if (m == NULL)  return false;

  int required = JVM_ACC_NATIVE | JVM_ACC_VARARGS;

  int flags = m->access_flags().as_int();

  return (flags & required) == required;

}

Symbol* MethodHandles::signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid) {

  assert(is_signature_polymorphic_intrinsic(iid), "%d %s", iid, vmIntrinsics::name_at(iid));

  switch (iid) {

  case vmIntrinsics::_invokeBasic:      return vmSymbols::invokeBasic_name();

  case vmIntrinsics::_linkToVirtual:    return vmSymbols::linkToVirtual_name();

  case vmIntrinsics::_linkToStatic:     return vmSymbols::linkToStatic_name();

  case vmIntrinsics::_linkToSpecial:    return vmSymbols::linkToSpecial_name();

  case vmIntrinsics::_linkToInterface:  return vmSymbols::linkToInterface_name();

  }

  fatal("unexpected intrinsic id: %d %s", iid, vmIntrinsics::name_at(iid));

  return 0;

}

int MethodHandles::signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid) {

  switch (iid) {

  case vmIntrinsics::_invokeBasic:      return 0;

  case vmIntrinsics::_linkToVirtual:    return JVM_REF_invokeVirtual;

  case vmIntrinsics::_linkToStatic:     return JVM_REF_invokeStatic;

  case vmIntrinsics::_linkToSpecial:    return JVM_REF_invokeSpecial;

  case vmIntrinsics::_linkToInterface:  return JVM_REF_invokeInterface;

  }

  fatal("unexpected intrinsic id: %d %s", iid, vmIntrinsics::name_at(iid));

  return 0;

}

vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Symbol* name) {

  vmSymbols::SID name_id = vmSymbols::find_sid(name);

  switch (name_id) {

  // The ID _invokeGeneric stands for all non-static signature-polymorphic methods, except built-ins.

  case vmSymbols::VM_SYMBOL_ENUM_NAME(invoke_name):           return vmIntrinsics::_invokeGeneric;

  // The only built-in non-static signature-polymorphic method is MethodHandle.invokeBasic:

  case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeBasic_name):      return vmIntrinsics::_invokeBasic;

  // There is one static signature-polymorphic method for each JVM invocation mode.

  case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToVirtual_name):    return vmIntrinsics::_linkToVirtual;

  case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToStatic_name):     return vmIntrinsics::_linkToStatic;

  case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToSpecial_name):    return vmIntrinsics::_linkToSpecial;

  case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToInterface_name):  return vmIntrinsics::_linkToInterface;

  }

  // Cover the case of invokeExact and any future variants of invokeFoo.

  Klass* mh_klass = SystemDictionary::well_known_klass(

                              SystemDictionary::WK_KLASS_ENUM_NAME(MethodHandle_klass) );

  if (mh_klass != NULL && is_method_handle_invoke_name(mh_klass, name))

    return vmIntrinsics::_invokeGeneric;

  // Note: The pseudo-intrinsic _compiledLambdaForm is never linked against.

  // Instead it is used to mark lambda forms bound to invokehandle or invokedynamic.

  return vmIntrinsics::_none;

}

vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Klass* klass, Symbol* name) {

  if (klass != NULL &&

      klass->name() == vmSymbols::java_lang_invoke_MethodHandle()) {

    vmIntrinsics::ID iid = signature_polymorphic_name_id(name);

    if (iid != vmIntrinsics::_none)

      return iid;

    if (is_method_handle_invoke_name(klass, name))

      return vmIntrinsics::_invokeGeneric;

  }

  return vmIntrinsics::_none;

}

// convert the external string or reflective type to an internal signature

Symbol* MethodHandles::lookup_signature(oop type_str, bool intern_if_not_found, TRAPS) {

  if (java_lang_invoke_MethodType::is_instance(type_str)) {

    return java_lang_invoke_MethodType::as_signature(type_str, intern_if_not_found, THREAD);

  } else if (java_lang_Class::is_instance(type_str)) {

    return java_lang_Class::as_signature(type_str, false, THREAD);

  } else if (java_lang_String::is_instance_inlined(type_str)) {

    if (intern_if_not_found) {

      return java_lang_String::as_symbol(type_str, THREAD);

    } else {

      return java_lang_String::as_symbol_or_null(type_str);

    }

  } else {

    THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized type", NULL);

  }

}

static const char OBJ_SIG[] = "Ljava/lang/Object;";

enum { OBJ_SIG_LEN = 18 };

bool MethodHandles::is_basic_type_signature(Symbol* sig) {

  assert(vmSymbols::object_signature()->utf8_length() == (int)OBJ_SIG_LEN, "");

  assert(vmSymbols::object_signature()->equals(OBJ_SIG), "");

  const int len = sig->utf8_length();

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

    switch (sig->byte_at(i)) {

    case 'L':

      // only java/lang/Object is valid here

      if (sig->index_of_at(i, OBJ_SIG, OBJ_SIG_LEN) != i)

        return false;

      i += OBJ_SIG_LEN-1;  //-1 because of i++ in loop

      continue;

    case '(': case ')': case 'V':

    case 'I': case 'J': case 'F': case 'D':

      continue;

    //case '[':

    //case 'Z': case 'B': case 'C': case 'S':

    default:

      return false;

    }

  }

  return true;

}

Symbol* MethodHandles::lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS) {

  Symbol* bsig = NULL;

  if (sig == NULL) {

    return sig;

  } else if (is_basic_type_signature(sig)) {

    sig->increment_refcount();

    return sig;  // that was easy

  } else if (sig->byte_at(0) != '(') {

    BasicType bt = char2type(sig->byte_at(0));

    if (is_subword_type(bt)) {

      bsig = vmSymbols::int_signature();

    } else {

      assert(bt == T_OBJECT || bt == T_ARRAY, "is_basic_type_signature was false");

      bsig = vmSymbols::object_signature();

    }

  } else {

    ResourceMark rm;

    stringStream buffer(128);

    buffer.put('(');

    int arg_pos = 0, keep_arg_pos = -1;

    if (keep_last_arg)

      keep_arg_pos = ArgumentCount(sig).size() - 1;

    for (SignatureStream ss(sig); !ss.is_done(); ss.next()) {

      BasicType bt = ss.type();

      size_t this_arg_pos = buffer.size();

      if (ss.at_return_type()) {

        buffer.put(')');

      }

      if (arg_pos == keep_arg_pos) {

        buffer.write((char*) ss.raw_bytes(),

                     (int)   ss.raw_length());

      } else if (bt == T_OBJECT || bt == T_ARRAY) {

        buffer.write(OBJ_SIG, OBJ_SIG_LEN);

      } else {