/*

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

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/reflection.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubRoutines.hpp"

/*

 * JSR 292 reference implementation: method handles

 */

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

MethodHandleEntry* MethodHandles::_entries[MethodHandles::_EK_LIMIT] = {NULL};

const char*        MethodHandles::_entry_names[_EK_LIMIT+1] = {

  "raise_exception",

  "invokestatic",               // how a MH emulates invokestatic

  "invokespecial",              // ditto for the other invokes...

  "invokevirtual",

  "invokeinterface",

  "bound_ref",                  // these are for BMH...

  "bound_int",

  "bound_long",

  "bound_ref_direct",           // (direct versions have a direct methodOop)

  "bound_int_direct",

  "bound_long_direct",

  // starting at _adapter_mh_first:

  "adapter_retype_only",       // these are for AMH...

  "adapter_retype_raw",

  "adapter_check_cast",

  "adapter_prim_to_prim",

  "adapter_ref_to_prim",

  "adapter_prim_to_ref",

  "adapter_swap_args",

  "adapter_rot_args",

  "adapter_dup_args",

  "adapter_drop_args",

  "adapter_collect_args",

  "adapter_spread_args",

  "adapter_fold_args",

  "adapter_unused_13",

  // optimized adapter types:

  "adapter_swap_args/1",

  "adapter_swap_args/2",

  "adapter_rot_args/1,up",

  "adapter_rot_args/1,down",

  "adapter_rot_args/2,up",

  "adapter_rot_args/2,down",

  "adapter_prim_to_prim/i2i",

  "adapter_prim_to_prim/l2i",

  "adapter_prim_to_prim/d2f",

  "adapter_prim_to_prim/i2l",

  "adapter_prim_to_prim/f2d",

  "adapter_ref_to_prim/unboxi",

  "adapter_ref_to_prim/unboxl",

  // return value handlers for collect/filter/fold adapters:

  "return/ref",

  "return/int",

  "return/long",

  "return/float",

  "return/double",

  "return/void",

  "return/S0/ref",

  "return/S1/ref",

  "return/S2/ref",

  "return/S3/ref",

  "return/S4/ref",

  "return/S5/ref",

  "return/any",

  // spreading (array length cases 0, 1, ...)

  "adapter_spread/0",

  "adapter_spread/1/ref",

  "adapter_spread/2/ref",

  "adapter_spread/3/ref",

  "adapter_spread/4/ref",

  "adapter_spread/5/ref",

  "adapter_spread/ref",

  "adapter_spread/byte",

  "adapter_spread/char",

  "adapter_spread/short",

  "adapter_spread/int",

  "adapter_spread/long",

  "adapter_spread/float",

  "adapter_spread/double",

  // blocking filter/collect conversions:

  "adapter_collect/ref",

  "adapter_collect/int",

  "adapter_collect/long",

  "adapter_collect/float",

  "adapter_collect/double",

  "adapter_collect/void",

  "adapter_collect/0/ref",

  "adapter_collect/1/ref",

  "adapter_collect/2/ref",

  "adapter_collect/3/ref",

  "adapter_collect/4/ref",

  "adapter_collect/5/ref",

  "adapter_filter/S0/ref",

  "adapter_filter/S1/ref",

  "adapter_filter/S2/ref",

  "adapter_filter/S3/ref",

  "adapter_filter/S4/ref",

  "adapter_filter/S5/ref",

  "adapter_collect/2/S0/ref",

  "adapter_collect/2/S1/ref",

  "adapter_collect/2/S2/ref",

  "adapter_collect/2/S3/ref",

  "adapter_collect/2/S4/ref",

  "adapter_collect/2/S5/ref",

  // blocking fold conversions:

  "adapter_fold/ref",

  "adapter_fold/int",

  "adapter_fold/long",

  "adapter_fold/float",

  "adapter_fold/double",

  "adapter_fold/void",

  "adapter_fold/1/ref",

  "adapter_fold/2/ref",

  "adapter_fold/3/ref",

  "adapter_fold/4/ref",

  "adapter_fold/5/ref",

  NULL

};

// Adapters.

MethodHandlesAdapterBlob* MethodHandles::_adapter_code      = NULL;

int                       MethodHandles::_adapter_code_size = StubRoutines::method_handles_adapters_code_size;

jobject MethodHandles::_raise_exception_method;

address MethodHandles::_adapter_return_handlers[CONV_TYPE_MASK+1];

#ifdef ASSERT

bool MethodHandles::spot_check_entry_names() {

  assert(!strcmp(entry_name(_invokestatic_mh), "invokestatic"), "");

  assert(!strcmp(entry_name(_bound_ref_mh), "bound_ref"), "");

  assert(!strcmp(entry_name(_adapter_retype_only), "adapter_retype_only"), "");

  assert(!strcmp(entry_name(_adapter_fold_args), "adapter_fold_args"), "");

  assert(!strcmp(entry_name(_adapter_opt_unboxi), "adapter_ref_to_prim/unboxi"), "");

  assert(!strcmp(entry_name(_adapter_opt_spread_char), "adapter_spread/char"), "");

  assert(!strcmp(entry_name(_adapter_opt_spread_double), "adapter_spread/double"), "");

  assert(!strcmp(entry_name(_adapter_opt_collect_int), "adapter_collect/int"), "");

  assert(!strcmp(entry_name(_adapter_opt_collect_0_ref), "adapter_collect/0/ref"), "");

  assert(!strcmp(entry_name(_adapter_opt_collect_2_S3_ref), "adapter_collect/2/S3/ref"), "");

  assert(!strcmp(entry_name(_adapter_opt_filter_S5_ref), "adapter_filter/S5/ref"), "");

  assert(!strcmp(entry_name(_adapter_opt_fold_3_ref), "adapter_fold/3/ref"), "");

  assert(!strcmp(entry_name(_adapter_opt_fold_void), "adapter_fold/void"), "");

  return true;

}

#endif

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

// MethodHandles::generate_adapters

//

void MethodHandles::generate_adapters() {

#ifdef TARGET_ARCH_NYI_6939861

  if (FLAG_IS_DEFAULT(UseRicochetFrames))  UseRicochetFrames = false;

#endif

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

}

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

// MethodHandlesAdapterGenerator::generate

//

void MethodHandlesAdapterGenerator::generate() {

  // Generate generic method handle adapters.

  for (MethodHandles::EntryKind ek = MethodHandles::_EK_FIRST;

       ek < MethodHandles::_EK_LIMIT;

       ek = MethodHandles::EntryKind(1 + (int)ek)) {

    if (MethodHandles::ek_supported(ek)) {

      StubCodeMark mark(this, "MethodHandle", MethodHandles::entry_name(ek));

      MethodHandles::generate_method_handle_stub(_masm, ek);

    }

  }

}

#ifdef TARGET_ARCH_NYI_6939861

// these defs belong in methodHandles_<arch>.cpp

frame MethodHandles::ricochet_frame_sender(const frame& fr, RegisterMap *map) {

  ShouldNotCallThis();

  return fr;

}

void MethodHandles::ricochet_frame_oops_do(const frame& fr, OopClosure* f, const RegisterMap* reg_map) {

  ShouldNotCallThis();

}

#endif //TARGET_ARCH_NYI_6939861

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

// MethodHandles::ek_supported

//

bool MethodHandles::ek_supported(MethodHandles::EntryKind ek) {

  MethodHandles::EntryKind ek_orig = MethodHandles::ek_original_kind(ek);

  switch (ek_orig) {

  case _adapter_unused_13:

    return false;  // not defined yet

  case _adapter_prim_to_ref:

    return UseRicochetFrames && conv_op_supported(java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF);

  case _adapter_collect_args:

    return UseRicochetFrames && conv_op_supported(java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS);

  case _adapter_fold_args:

    return UseRicochetFrames && conv_op_supported(java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS);

  case _adapter_opt_return_any:

    return UseRicochetFrames;

#ifdef TARGET_ARCH_NYI_6939861

  // ports before 6939861 supported only three kinds of spread ops

  case _adapter_spread_args:

    // restrict spreads to three kinds:

    switch (ek) {

    case _adapter_opt_spread_0:

    case _adapter_opt_spread_1:

    case _adapter_opt_spread_more:

      break;

    default:

      return false;

      break;

    }

    break;

#endif //TARGET_ARCH_NYI_6939861

  }

  return true;

}

void MethodHandles::set_enabled(bool z) {

  if (_enabled != z) {

    guarantee(z && EnableInvokeDynamic, "can only enable once, and only if -XX:+EnableInvokeDynamic");

    _enabled = z;

  }

}

// Note: A method which does not have a TRAPS argument cannot block in the GC

// or throw exceptions.  Such methods are used in this file to do something quick

// and local, like parse a data structure.  For speed, such methods work on plain

// oops, not handles.  Trapping methods uniformly operate on handles.

methodHandle MethodHandles::decode_vmtarget(oop vmtarget, int vmindex, oop mtype,

                                            KlassHandle& receiver_limit_result, int& decode_flags_result) {

  if (vmtarget == NULL)  return methodHandle();

  assert(methodOopDesc::nonvirtual_vtable_index < 0, "encoding");

  if (vmindex < 0) {

    // this DMH performs no dispatch; it is directly bound to a methodOop

    // A MemberName may either be directly bound to a methodOop,

    // or it may use the klass/index form; both forms mean the same thing.

    methodOop m = decode_methodOop(methodOop(vmtarget), decode_flags_result);

    if ((decode_flags_result & _dmf_has_receiver) != 0

        && java_lang_invoke_MethodType::is_instance(mtype)) {

      // Extract receiver type restriction from mtype.ptypes[0].

      objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(mtype);

      oop ptype0 = (ptypes == NULL || ptypes->length() < 1) ? oop(NULL) : ptypes->obj_at(0);

      if (java_lang_Class::is_instance(ptype0))

        receiver_limit_result = java_lang_Class::as_klassOop(ptype0);

    }

    if (vmindex == methodOopDesc::nonvirtual_vtable_index) {

      // this DMH can be an "invokespecial" version

      decode_flags_result &= ~_dmf_does_dispatch;

    } else {

      assert(vmindex == methodOopDesc::invalid_vtable_index, "random vmindex?");

    }

    return m;

  } else {

    assert(vmtarget->is_klass(), "must be class or interface");

    decode_flags_result |= MethodHandles::_dmf_does_dispatch;

    decode_flags_result |= MethodHandles::_dmf_has_receiver;

    receiver_limit_result = (klassOop)vmtarget;

    Klass* tk = Klass::cast((klassOop)vmtarget);

    if (tk->is_interface()) {

      // an itable linkage is <interface, itable index>

      decode_flags_result |= MethodHandles::_dmf_from_interface;

      return klassItable::method_for_itable_index((klassOop)vmtarget, vmindex);

    } else {

      if (!tk->oop_is_instance())

        tk = instanceKlass::cast(SystemDictionary::Object_klass());

      return ((instanceKlass*)tk)->method_at_vtable(vmindex);

    }

  }

}

// MemberName and DirectMethodHandle have the same linkage to the JVM internals.

// (MemberName is the non-operational name used for queries and setup.)

methodHandle MethodHandles::decode_DirectMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {

  oop vmtarget = java_lang_invoke_DirectMethodHandle::vmtarget(mh);

  int vmindex  = java_lang_invoke_DirectMethodHandle::vmindex(mh);

  oop mtype    = java_lang_invoke_DirectMethodHandle::type(mh);

  return decode_vmtarget(vmtarget, vmindex, mtype, receiver_limit_result, decode_flags_result);

}

methodHandle MethodHandles::decode_BoundMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {

  assert(java_lang_invoke_BoundMethodHandle::is_instance(mh), "");

  assert(mh->klass() != SystemDictionary::AdapterMethodHandle_klass(), "");

  for (oop bmh = mh;;) {

    // Bound MHs can be stacked to bind several arguments.

    oop target = java_lang_invoke_MethodHandle::vmtarget(bmh);

    if (target == NULL)  return methodHandle();

    decode_flags_result |= MethodHandles::_dmf_binds_argument;

    klassOop tk = target->klass();

    if (tk == SystemDictionary::BoundMethodHandle_klass()) {

      bmh = target;

      continue;

    } else {

      if (java_lang_invoke_MethodHandle::is_subclass(tk)) {

        //assert(tk == SystemDictionary::DirectMethodHandle_klass(), "end of BMH chain must be DMH");

        return decode_MethodHandle(target, receiver_limit_result, decode_flags_result);

      } else {

        // Optimized case:  binding a receiver to a non-dispatched DMH

        // short-circuits directly to the methodOop.

        // (It might be another argument besides a receiver also.)

        assert(target->is_method(), "must be a simple method");

        decode_flags_result |= MethodHandles::_dmf_binds_method;

        methodOop m = (methodOop) target;

        if (!m->is_static())

          decode_flags_result |= MethodHandles::_dmf_has_receiver;

        return m;

      }

    }

  }

}

methodHandle MethodHandles::decode_AdapterMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {

  assert(mh->klass() == SystemDictionary::AdapterMethodHandle_klass(), "");

  for (oop amh = mh;;) {

    // Adapter MHs can be stacked to convert several arguments.

    int conv_op = adapter_conversion_op(java_lang_invoke_AdapterMethodHandle::conversion(amh));

    decode_flags_result |= (_dmf_adapter_lsb << conv_op) & _DMF_ADAPTER_MASK;

    oop target = java_lang_invoke_MethodHandle::vmtarget(amh);

    if (target == NULL)  return methodHandle();

    klassOop tk = target->klass();

    if (tk == SystemDictionary::AdapterMethodHandle_klass()) {

      amh = target;

      continue;

    } else {

      // must be a BMH (which will bind some more arguments) or a DMH (for the final call)

      return MethodHandles::decode_MethodHandle(target, receiver_limit_result, decode_flags_result);

    }

  }

}

methodHandle MethodHandles::decode_MethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {

  if (mh == NULL)  return methodHandle();

  klassOop mhk = mh->klass();

  assert(java_lang_invoke_MethodHandle::is_subclass(mhk), "must be a MethodHandle");

  if (mhk == SystemDictionary::DirectMethodHandle_klass()) {

    return decode_DirectMethodHandle(mh, receiver_limit_result, decode_flags_result);

  } else if (mhk == SystemDictionary::BoundMethodHandle_klass()) {

    return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);

  } else if (mhk == SystemDictionary::AdapterMethodHandle_klass()) {

    return decode_AdapterMethodHandle(mh, receiver_limit_result, decode_flags_result);

  } else if (java_lang_invoke_BoundMethodHandle::is_subclass(mhk)) {

    // could be a JavaMethodHandle (but not an adapter MH)

    return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);

  } else {

    assert(false, "cannot parse this MH");

    return methodHandle();  // random MH?

  }

}

methodOop MethodHandles::decode_methodOop(methodOop m, int& decode_flags_result) {

  assert(m->is_method(), "");

  if (m->is_static()) {

    // check that signature begins '(L' or '([' (not '(I', '()', etc.)

    Symbol* sig = m->signature();

    BasicType recv_bt = char2type(sig->byte_at(1));

    // Note: recv_bt might be T_ILLEGAL if byte_at(2) is ')'

    assert(sig->byte_at(0) == '(', "must be method sig");

//     if (recv_bt == T_OBJECT || recv_bt == T_ARRAY)

//       decode_flags_result |= _dmf_has_receiver;

  } else {

    // non-static method

    decode_flags_result |= _dmf_has_receiver;

    if (!m->can_be_statically_bound() && !m->is_initializer()) {

      decode_flags_result |= _dmf_does_dispatch;

      if (Klass::cast(m->method_holder())->is_interface())

        decode_flags_result |= _dmf_from_interface;

    }

  }

  return m;

}

// A trusted party is handing us a cookie to determine a method.

// Let's boil it down to the method oop they really want.

methodHandle MethodHandles::decode_method(oop x, KlassHandle& receiver_limit_result, int& decode_flags_result) {

  decode_flags_result = 0;

  receiver_limit_result = KlassHandle();

  klassOop xk = x->klass();

  if (xk == Universe::methodKlassObj()) {

    return decode_methodOop((methodOop) x, decode_flags_result);

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

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

    return decode_MemberName(x, receiver_limit_result, decode_flags_result);

  } else if (java_lang_invoke_MethodHandle::is_subclass(xk)) {

    return decode_MethodHandle(x, receiver_limit_result, decode_flags_result);

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

    oop clazz  = java_lang_reflect_Method::clazz(x);

    int slot   = java_lang_reflect_Method::slot(x);

    klassOop k = java_lang_Class::as_klassOop(clazz);

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

      return decode_methodOop(instanceKlass::cast(k)->method_with_idnum(slot),

                              decode_flags_result);

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

    oop clazz  = java_lang_reflect_Constructor::clazz(x);

    int slot   = java_lang_reflect_Constructor::slot(x);

    klassOop k = java_lang_Class::as_klassOop(clazz);

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

      return decode_methodOop(instanceKlass::cast(k)->method_with_idnum(slot),

                              decode_flags_result);

  } else {

    // unrecognized object

    assert(!x->is_method(), "already checked");

    assert(!java_lang_invoke_MemberName::is_instance(x), "already checked");

  }

  return methodHandle();

}

int MethodHandles::decode_MethodHandle_stack_pushes(oop mh) {

  if (mh->klass() == SystemDictionary::DirectMethodHandle_klass())

    return 0;                   // no push/pop

  int this_vmslots = java_lang_invoke_MethodHandle::vmslots(mh);

  int last_vmslots = 0;

  oop last_mh = mh;

  for (;;) {

    oop target = java_lang_invoke_MethodHandle::vmtarget(last_mh);

    if (target->klass() == SystemDictionary::DirectMethodHandle_klass()) {

      last_vmslots = java_lang_invoke_MethodHandle::vmslots(target);

      break;

    } else if (!java_lang_invoke_MethodHandle::is_instance(target)) {

      // might be klass or method

      assert(target->is_method(), "must get here with a direct ref to method");

      last_vmslots = methodOop(target)->size_of_parameters();

      break;

    }

    last_mh = target;

  }

  // If I am called with fewer VM slots than my ultimate callee,

  // it must be that I push the additionally needed slots.

  // Likewise if am called with more VM slots, I will pop them.

  return (last_vmslots - this_vmslots);

}

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

  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,

  VM_INDEX_UNINITIALIZED = java_lang_invoke_MemberName::VM_INDEX_UNINITIALIZED