/*

 * Copyright (c) 2008, 2010, 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.

 *

 */

/*

 * 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_flyby",

  "adapter_ricochet",

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

  "adapter_spread_args/0",

  "adapter_spread_args/1",

  "adapter_spread_args/more",

  NULL

};

// Adapters.

MethodHandlesAdapterBlob* MethodHandles::_adapter_code      = NULL;

int                       MethodHandles::_adapter_code_size = StubRoutines::method_handles_adapters_code_size;

jobject MethodHandles::_raise_exception_method;

#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_ricochet), "adapter_ricochet"), "");

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

  return true;

}

#endif

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

// MethodHandles::generate_adapters

//

void MethodHandles::generate_adapters() {

  if (!EnableMethodHandles || 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)) {

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

    MethodHandles::generate_method_handle_stub(_masm, ek);

  }

}

void MethodHandles::set_enabled(bool z) {

  if (_enabled != z) {

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

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

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

                                         klassOop& receiver_limit_result, int& decode_flags_result) {

  if (vmtarget == NULL)  return NULL;

  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_dyn_MethodType::is_instance(mtype)) {

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

      objArrayOop ptypes = java_dyn_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.)

methodOop MethodHandles::decode_DirectMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {

  oop vmtarget = sun_dyn_DirectMethodHandle::vmtarget(mh);

  int vmindex  = sun_dyn_DirectMethodHandle::vmindex(mh);

  oop mtype    = sun_dyn_DirectMethodHandle::type(mh);

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

}

methodOop MethodHandles::decode_BoundMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {

  assert(sun_dyn_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_dyn_MethodHandle::vmtarget(bmh);

    if (target == NULL)  return NULL;

    decode_flags_result |= MethodHandles::_dmf_binds_argument;

    klassOop tk = target->klass();

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

      bmh = target;

      continue;

    } else {

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

      }

    }

  }

}

methodOop MethodHandles::decode_AdapterMethodHandle(oop mh, klassOop& 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(sun_dyn_AdapterMethodHandle::conversion(amh));

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

    oop target = java_dyn_MethodHandle::vmtarget(amh);

    if (target == NULL)  return NULL;

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

    }

  }

}

methodOop MethodHandles::decode_MethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {

  if (mh == NULL)  return NULL;

  klassOop mhk = mh->klass();

  assert(java_dyn_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 (sun_dyn_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 NULL;              // 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.)

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

methodOop MethodHandles::decode_method(oop x, klassOop& receiver_limit_result, int& decode_flags_result) {

  decode_flags_result = 0;

  receiver_limit_result = NULL;

  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_dyn_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(!sun_dyn_MemberName::is_instance(x), "already checked");

  }

  return NULL;

}

int MethodHandles::decode_MethodHandle_stack_pushes(oop mh) {

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

    return 0;                   // no push/pop

  int this_vmslots = java_dyn_MethodHandle::vmslots(mh);

  int last_vmslots = 0;

  oop last_mh = mh;

  for (;;) {

    oop target = java_dyn_MethodHandle::vmtarget(last_mh);

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

      last_vmslots = java_dyn_MethodHandle::vmslots(target);

      break;

    } else if (!java_dyn_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 sun_dyn_MemberName.*

enum {

  IS_METHOD      = sun_dyn_MemberName::MN_IS_METHOD,

  IS_CONSTRUCTOR = sun_dyn_MemberName::MN_IS_CONSTRUCTOR,

  IS_FIELD       = sun_dyn_MemberName::MN_IS_FIELD,

  IS_TYPE        = sun_dyn_MemberName::MN_IS_TYPE,

  SEARCH_SUPERCLASSES = sun_dyn_MemberName::MN_SEARCH_SUPERCLASSES,

  SEARCH_INTERFACES   = sun_dyn_MemberName::MN_SEARCH_INTERFACES,

  ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE,

  VM_INDEX_UNINITIALIZED = sun_dyn_MemberName::VM_INDEX_UNINITIALIZED

};

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

}

void MethodHandles::init_MemberName(oop mname_oop, oop target_oop) {

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

    klassOop k = java_lang_Class::as_klassOop(clazz);

    int offset = instanceKlass::cast(k)->offset_from_fields(slot);

    init_MemberName(mname_oop, k, accessFlags_from(mods), offset);

  } else {

    int decode_flags = 0; klassOop receiver_limit = NULL;

    methodOop m = MethodHandles::decode_method(target_oop,

                                               receiver_limit, decode_flags);

    bool do_dispatch = ((decode_flags & MethodHandles::_dmf_does_dispatch) != 0);

    init_MemberName(mname_oop, m, do_dispatch);

  }

}

void MethodHandles::init_MemberName(oop mname_oop, methodOop m, bool do_dispatch) {

  int flags = ((m->is_initializer() ? IS_CONSTRUCTOR : IS_METHOD)

               | (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS ));

  oop vmtarget = m;

  int vmindex  = methodOopDesc::invalid_vtable_index;  // implies no info yet

  if (!do_dispatch || (flags & IS_CONSTRUCTOR) || m->can_be_statically_bound())

    vmindex = methodOopDesc::nonvirtual_vtable_index; // implies never any dispatch

  assert(vmindex != VM_INDEX_UNINITIALIZED, "Java sentinel value");

  sun_dyn_MemberName::set_vmtarget(mname_oop, vmtarget);

  sun_dyn_MemberName::set_vmindex(mname_oop,  vmindex);

  sun_dyn_MemberName::set_flags(mname_oop,    flags);

  sun_dyn_MemberName::set_clazz(mname_oop,    Klass::cast(m->method_holder())->java_mirror());

}

void MethodHandles::init_MemberName(oop mname_oop, klassOop field_holder, AccessFlags mods, int offset) {

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

  oop vmtarget = field_holder;

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

  assert(vmindex != VM_INDEX_UNINITIALIZED, "bad alias on vmindex");

  sun_dyn_MemberName::set_vmtarget(mname_oop, vmtarget);

  sun_dyn_MemberName::set_vmindex(mname_oop,  vmindex);

  sun_dyn_MemberName::set_flags(mname_oop,    flags);

  sun_dyn_MemberName::set_clazz(mname_oop,    Klass::cast(field_holder)->java_mirror());

}

methodOop MethodHandles::decode_MemberName(oop mname, klassOop& receiver_limit_result, int& decode_flags_result) {

  int flags  = sun_dyn_MemberName::flags(mname);

  if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) == 0)  return NULL;  // not invocable

  oop vmtarget = sun_dyn_MemberName::vmtarget(mname);

  int vmindex  = sun_dyn_MemberName::vmindex(mname);

  if (vmindex == VM_INDEX_UNINITIALIZED)  return NULL; // not resolved

  methodOop m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);

  oop clazz = sun_dyn_MemberName::clazz(mname);

  if (clazz != NULL && java_lang_Class::is_instance(clazz)) {

    klassOop klass = java_lang_Class::as_klassOop(clazz);

    if (klass != NULL)  receiver_limit_result = klass;

  }

  return m;

}

// An unresolved member name is a mere symbolic reference.

// Resolving it plants a vmtarget/vmindex in it,

// which refers dirctly to JVM internals.

void MethodHandles::resolve_MemberName(Handle mname, TRAPS) {

  assert(sun_dyn_MemberName::is_instance(mname()), "");

#ifdef ASSERT

  // If this assert throws, renegotiate the sentinel value used by the Java code,

  // so that it is distinct from any valid vtable index value, and any special

  // values defined in methodOopDesc::VtableIndexFlag.

  // The point of the slop is to give the Java code and the JVM some room

  // to independently specify sentinel values.

  const int sentinel_slop  = 10;

  const int sentinel_limit = methodOopDesc::highest_unused_vtable_index_value - sentinel_slop;

  assert(VM_INDEX_UNINITIALIZED < sentinel_limit, "Java sentinel != JVM sentinels");

#endif

  if (sun_dyn_MemberName::vmindex(mname()) != VM_INDEX_UNINITIALIZED)

    return;  // already resolved

  oop defc_oop = sun_dyn_MemberName::clazz(mname());

  oop name_str = sun_dyn_MemberName::name(mname());

  oop type_str = sun_dyn_MemberName::type(mname());

  int flags    = sun_dyn_MemberName::flags(mname());

  if (defc_oop == NULL || name_str == NULL || type_str == NULL) {

    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve");

  }

  klassOop defc_klassOop = java_lang_Class::as_klassOop(defc_oop);

  defc_oop = NULL;  // safety

  if (defc_klassOop == NULL)  return;  // a primitive; no resolution possible

  if (!Klass::cast(defc_klassOop)->oop_is_instance()) {

    if (!Klass::cast(defc_klassOop)->oop_is_array())  return;

    defc_klassOop = SystemDictionary::Object_klass();

  }

  instanceKlassHandle defc(THREAD, defc_klassOop);

  defc_klassOop = NULL;  // safety

  if (defc.is_null()) {

    THROW_MSG(vmSymbols::java_lang_InternalError(), "primitive class");

  }

  defc->link_class(CHECK);

  // convert the external string name to an internal symbol

  symbolHandle name(THREAD, java_lang_String::as_symbol_or_null(name_str));

  if (name.is_null())  return;  // no such name

  name_str = NULL;  // safety

  Handle polymorphic_method_type;

  bool polymorphic_signature = false;

  if ((flags & ALL_KINDS) == IS_METHOD &&

      (defc() == SystemDictionary::InvokeDynamic_klass() ||

       (defc() == SystemDictionary::MethodHandle_klass() &&

        methodOopDesc::is_method_handle_invoke_name(name()))))

    polymorphic_signature = true;

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

  symbolHandle type; {

    symbolOop type_sym = NULL;

    if (java_dyn_MethodType::is_instance(type_str)) {

      type_sym = java_dyn_MethodType::as_signature(type_str, polymorphic_signature, CHECK);

      if (polymorphic_signature)

        polymorphic_method_type = Handle(THREAD, type_str);  //preserve exactly

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

      type_sym = java_lang_Class::as_signature(type_str, false, CHECK);

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

      if (polymorphic_signature) {

        type     = java_lang_String::as_symbol(type_str, CHECK);

      } else {

        type_sym = java_lang_String::as_symbol_or_null(type_str);

      }

    } else {

      THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized type");

    }

    if (type_sym != NULL)

      type = symbolHandle(THREAD, type_sym);

  }

  if (type.is_null())  return;  // no such signature exists in the VM

  type_str = NULL; // safety

  // Time to do the lookup.