/*

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

#include "compiler/compileBroker.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/reflection.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubRoutines.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;

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

// MethodHandles::generate_adapters

//

void MethodHandles::generate_adapters() {

  if (!EnableInvokeDynamic || SystemDictionary::MethodHandle_klass() == NULL)  return;

  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)

    vm_exit_out_of_memory(adapter_code_size, OOM_MALLOC_ERROR,

                          "CodeCache: no room for MethodHandles adapters");

  {

    CodeBuffer code(_adapter_code);

    MethodHandlesAdapterGenerator g(&code);

    g.generate();

    code.log_section_sizes("MethodHandlesAdapterBlob");

  }

}

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

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

      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 && EnableInvokeDynamic, "can only enable once, and only if -XX:+EnableInvokeDynamic");

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

    if (!k.is_null() && k->oop_is_instance()) {

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

    if (!k.is_null() && k->oop_is_instance()) {

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

    if (!k.is_null() && k->oop_is_instance()) {

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

  KlassHandle receiver_limit = info.resolved_klass();

  methodHandle m = info.resolved_method();

  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.

    receiver_limit = m->method_holder();

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

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

    break;

  case CallInfo::vtable_call:

    vmindex = info.vtable_index();

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

    assert(receiver_limit->is_subtype_of(m->method_holder()), "virtual call must be type-safe");

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

      assert(receiver_limit == m->method_holder(), "constructor call must be exactly typed");

    } else {

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

      assert(receiver_limit->is_subtype_of(m->method_holder()), "special call must be type-safe");

    }

    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, receiver_limit->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

  m->method_holder()->add_member_name(m->method_idnum(), mname);

  return mname();

}

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), err_msg("iid=%d", 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();

  }

  assert(false, "");

  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;

  }

  assert(false, err_msg("iid=%d", 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, CHECK_NULL);

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

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

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

    if (intern_if_not_found) {

      return java_lang_String::as_symbol(type_str, CHECK_NULL);

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

        if (is_subword_type(bt))

          bt = T_INT;

        buffer.put(type2char(bt));

      }

      arg_pos++;

    }

    const char* sigstr =       buffer.base();

    int         siglen = (int) buffer.size();

    bsig = SymbolTable::new_symbol(sigstr, siglen, THREAD);

  }

  assert(is_basic_type_signature(bsig) ||

         // detune assert in case the injected argument is not a basic type:

         keep_last_arg, "");

  return bsig;

}

void MethodHandles::print_as_basic_type_signature_on(outputStream* st,

                                                     Symbol* sig,

                                                     bool keep_arrays,

                                                     bool keep_basic_names) {

  st = st ? st : tty;

  int len  = sig->utf8_length();

  int array = 0;

  bool prev_type = false;

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

    char ch = sig->byte_at(i);

    switch (ch) {

    case '(': case ')':

      prev_type = false;

      st->put(ch);

      continue;

    case '[':

      if (!keep_basic_names && keep_arrays)

        st->put(ch);

      array++;

      continue;

    case 'L':

      {

        if (prev_type)  st->put(',');

        int start = i+1, slash = start;