/*

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

  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(oop mname_oop, oop target_oop) {

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

    int mods  = java_lang_reflect_Field::modifiers(target_oop);

    oop type  = java_lang_reflect_Field::type(target_oop);

    oop name  = java_lang_reflect_Field::name(target_oop);

    Klass* k = java_lang_Class::as_Klass(clazz);

    intptr_t offset = InstanceKlass::cast(k)->field_offset(slot);

    return init_field_MemberName(mname_oop, k, accessFlags_from(mods), type, name, offset);

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

    Klass* k = java_lang_Class::as_Klass(clazz);

    if (k != NULL && Klass::cast(k)->oop_is_instance()) {

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

      return init_method_MemberName(mname_oop, m, true, k);

    }

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

    Klass* k = java_lang_Class::as_Klass(clazz);

    if (k != NULL && Klass::cast(k)->oop_is_instance()) {

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

      return init_method_MemberName(mname_oop, m, false, k);

    }

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

    // Note: This only works if the MemberName has already been resolved.

    oop clazz        = java_lang_invoke_MemberName::clazz(target_oop);

    int flags        = java_lang_invoke_MemberName::flags(target_oop);

    Metadata* vmtarget=java_lang_invoke_MemberName::vmtarget(target_oop);

    intptr_t vmindex = java_lang_invoke_MemberName::vmindex(target_oop);

    Klass* k         = java_lang_Class::as_Klass(clazz);

    int ref_kind     = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;

    if (vmtarget == NULL)  return NULL;  // not resolved

    if ((flags & IS_FIELD) != 0) {

      assert(vmtarget->is_klass(), "field vmtarget is Klass*");

      int basic_mods = (ref_kind_is_static(ref_kind) ? JVM_ACC_STATIC : 0);

      // FIXME:  how does k (receiver_limit) contribute?

      return init_field_MemberName(mname_oop, (Klass*)vmtarget, accessFlags_from(basic_mods), NULL, NULL, vmindex);

    } else if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) != 0) {

      assert(vmtarget->is_method(), "method or constructor vmtarget is Method*");

      return init_method_MemberName(mname_oop, (Method*)vmtarget, ref_kind_does_dispatch(ref_kind), k);

    } else {

      return NULL;

    }

  }

  return NULL;

}

oop MethodHandles::init_method_MemberName(oop mname_oop, Method* m, bool do_dispatch,

                                          Klass* receiver_limit) {

  AccessFlags mods = m->access_flags();

  int flags = (jushort)( mods.as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );

  int vmindex = Method::nonvirtual_vtable_index; // implies never any dispatch

  Klass* mklass = m->method_holder();

  if (receiver_limit == NULL)

    receiver_limit = mklass;

  if (m->is_initializer()) {

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

  } else if (mods.is_static()) {

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

  } else if (receiver_limit != mklass &&

             !Klass::cast(receiver_limit)->is_subtype_of(mklass)) {

    return NULL;  // bad receiver limit

  } else if (Klass::cast(receiver_limit)->is_interface() &&

             Klass::cast(mklass)->is_interface()) {

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

    receiver_limit = mklass;  // ignore passed-in limit; interfaces are interconvertible

    vmindex = klassItable::compute_itable_index(m);

  } else if (mklass != receiver_limit && Klass::cast(mklass)->is_interface()) {

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

    // it is a miranda method, so m->vtable_index is not what we want

    ResourceMark rm;

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

    vmindex = vt->index_of_miranda(m->name(), m->signature());

  } else if (!do_dispatch || m->can_be_statically_bound()) {

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

  } else {

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

    vmindex = m->vtable_index();

  }

  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,    Klass::cast(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

  return mname_oop;

}

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

  Handle empty;

  if (info.resolved_appendix().not_null()) {

    // The resolved MemberName must not be accompanied by an appendix argument,

    // since there is no way to bind this value into the MemberName.

    // Caller is responsible to prevent this from happening.

    THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);

  }

  methodHandle m = info.resolved_method();

  KlassHandle defc = info.resolved_klass();

  int vmindex = -1;

  if (defc->is_interface() && Klass::cast(m->method_holder())->is_interface()) {

    // LinkResolver does not report itable indexes!  (fix this?)

    vmindex = klassItable::compute_itable_index(m());

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

    // LinkResolver reports vtable index even for final methods!

    vmindex = Method::nonvirtual_vtable_index;

  } else {

    vmindex = info.vtable_index();

  }

  oop res = init_method_MemberName(mname_oop, m(), (vmindex >= 0), defc());

  assert(res == NULL || (java_lang_invoke_MemberName::vmindex(res) == vmindex), "");

  return Handle(THREAD, res);

}

oop MethodHandles::init_field_MemberName(oop mname_oop, Klass* field_holder,

                                         AccessFlags mods, oop type, oop name,

                                         intptr_t offset, bool is_setter) {

  int flags = (jushort)( mods.as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );

  flags |= IS_FIELD | ((mods.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 = field_holder;

  int vmindex  = offset;  // determines the field uniquely when combined with static bit

  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,    Klass::cast(field_holder)->java_mirror());

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

}

Handle MethodHandles::init_field_MemberName(oop mname_oop, FieldAccessInfo& info, TRAPS) {

  return Handle();

#if 0 // FIXME

  KlassHandle field_holder = info.klass();

  intptr_t    field_offset = info.field_offset();

  return init_field_MemberName(mname_oop, field_holder(),

                               info.access_flags(),

                               type, name,

                               field_offset, false /*is_setter*/);

#endif

}

// 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::cast(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::cast(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':