/*

 * 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 "interpreter/rewriter.hpp"

#include "memory/oopFactory.hpp"

#include "prims/methodHandleWalk.hpp"

/*

 * JSR 292 reference implementation: method handle structure analysis

 */

#ifdef PRODUCT

#define print_method_handle(mh) {}

#else //PRODUCT

extern "C" void print_method_handle(oop mh);

#endif //PRODUCT

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

// MethodHandleChain

void MethodHandleChain::set_method_handle(Handle mh, TRAPS) {

  if (!java_lang_invoke_MethodHandle::is_instance(mh()))  lose("bad method handle", CHECK);

  // set current method handle and unpack partially

  _method_handle = mh;

  _is_last       = false;

  _is_bound      = false;

  _arg_slot      = -1;

  _arg_type      = T_VOID;

  _conversion    = -1;

  _last_invoke   = Bytecodes::_nop;  //arbitrary non-garbage

  if (java_lang_invoke_DirectMethodHandle::is_instance(mh())) {

    set_last_method(mh(), THREAD);

    return;

  }

  if (java_lang_invoke_AdapterMethodHandle::is_instance(mh())) {

    _conversion = AdapterMethodHandle_conversion();

    assert(_conversion != -1, "bad conv value");

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

  }

  if (java_lang_invoke_BoundMethodHandle::is_instance(mh())) {

    if (!is_adapter())          // keep AMH and BMH separate in this model

      _is_bound = true;

    _arg_slot = BoundMethodHandle_vmargslot();

    oop target = MethodHandle_vmtarget_oop();

    if (!is_bound() || java_lang_invoke_MethodHandle::is_instance(target)) {

      _arg_type = compute_bound_arg_type(target, NULL, _arg_slot, CHECK);

    } else if (target != NULL && target->is_method()) {

      methodOop m = (methodOop) target;

      _arg_type = compute_bound_arg_type(NULL, m, _arg_slot, CHECK);

      set_last_method(mh(), CHECK);

    } else {

      _is_bound = false;  // lose!

    }

  }

  if (is_bound() && _arg_type == T_VOID) {

    lose("bad vmargslot", CHECK);

  }

  if (!is_bound() && !is_adapter()) {

    lose("unrecognized MH type", CHECK);

  }

}

void MethodHandleChain::set_last_method(oop target, TRAPS) {

  _is_last = true;

  KlassHandle receiver_limit; int flags = 0;

  _last_method = MethodHandles::decode_method(target, receiver_limit, flags);

  if ((flags & MethodHandles::_dmf_has_receiver) == 0)

    _last_invoke = Bytecodes::_invokestatic;

  else if ((flags & MethodHandles::_dmf_does_dispatch) == 0)

    _last_invoke = Bytecodes::_invokespecial;

  else if ((flags & MethodHandles::_dmf_from_interface) != 0)

    _last_invoke = Bytecodes::_invokeinterface;

  else

    _last_invoke = Bytecodes::_invokevirtual;

}

BasicType MethodHandleChain::compute_bound_arg_type(oop target, methodOop m, int arg_slot, TRAPS) {

  // There is no direct indication of whether the argument is primitive or not.

  // It is implied by the _vmentry code, and by the MethodType of the target.

  BasicType arg_type = T_VOID;

  if (target != NULL) {

    oop mtype = java_lang_invoke_MethodHandle::type(target);

    int arg_num = MethodHandles::argument_slot_to_argnum(mtype, arg_slot);

    if (arg_num >= 0) {

      oop ptype = java_lang_invoke_MethodType::ptype(mtype, arg_num);

      arg_type = java_lang_Class::as_BasicType(ptype);

    }

  } else if (m != NULL) {

    // figure out the argument type from the slot

    // FIXME: make this explicit in the MH

    int cur_slot = m->size_of_parameters();

    if (arg_slot >= cur_slot)

      return T_VOID;

    if (!m->is_static()) {

      cur_slot -= type2size[T_OBJECT];

      if (cur_slot == arg_slot)

        return T_OBJECT;

    }

    ResourceMark rm(THREAD);

    for (SignatureStream ss(m->signature()); !ss.is_done(); ss.next()) {

      BasicType bt = ss.type();

      cur_slot -= type2size[bt];

      if (cur_slot <= arg_slot) {

        if (cur_slot == arg_slot)

          arg_type = bt;

        break;

      }

    }

  }

  if (arg_type == T_ARRAY)

    arg_type = T_OBJECT;

  return arg_type;

}

void MethodHandleChain::lose(const char* msg, TRAPS) {

  _lose_message = msg;

  if (!THREAD->is_Java_thread() || ((JavaThread*)THREAD)->thread_state() != _thread_in_vm) {

    // throw a preallocated exception

    THROW_OOP(Universe::virtual_machine_error_instance());

  }

  THROW_MSG(vmSymbols::java_lang_InternalError(), msg);

}

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

// MethodHandleWalker

Bytecodes::Code MethodHandleWalker::conversion_code(BasicType src, BasicType dest) {

  if (is_subword_type(src)) {

    src = T_INT;          // all subword src types act like int

  }

  if (src == dest) {

    return Bytecodes::_nop;

  }

#define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))

  switch (SRC_DEST(src, dest)) {

  case SRC_DEST(T_INT, T_LONG):           return Bytecodes::_i2l;

  case SRC_DEST(T_INT, T_FLOAT):          return Bytecodes::_i2f;

  case SRC_DEST(T_INT, T_DOUBLE):         return Bytecodes::_i2d;

  case SRC_DEST(T_INT, T_BYTE):           return Bytecodes::_i2b;

  case SRC_DEST(T_INT, T_CHAR):           return Bytecodes::_i2c;

  case SRC_DEST(T_INT, T_SHORT):          return Bytecodes::_i2s;

  case SRC_DEST(T_LONG, T_INT):           return Bytecodes::_l2i;

  case SRC_DEST(T_LONG, T_FLOAT):         return Bytecodes::_l2f;

  case SRC_DEST(T_LONG, T_DOUBLE):        return Bytecodes::_l2d;

  case SRC_DEST(T_FLOAT, T_INT):          return Bytecodes::_f2i;

  case SRC_DEST(T_FLOAT, T_LONG):         return Bytecodes::_f2l;

  case SRC_DEST(T_FLOAT, T_DOUBLE):       return Bytecodes::_f2d;

  case SRC_DEST(T_DOUBLE, T_INT):         return Bytecodes::_d2i;

  case SRC_DEST(T_DOUBLE, T_LONG):        return Bytecodes::_d2l;

  case SRC_DEST(T_DOUBLE, T_FLOAT):       return Bytecodes::_d2f;

  }

#undef SRC_DEST

  // cannot do it in one step, or at all

  return Bytecodes::_illegal;

}

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

// MethodHandleWalker::walk

//

MethodHandleWalker::ArgToken

MethodHandleWalker::walk(TRAPS) {

  ArgToken empty = ArgToken();  // Empty return value.

  walk_incoming_state(CHECK_(empty));

  for (;;) {

    set_method_handle(chain().method_handle_oop());

    assert(_outgoing_argc == argument_count_slow(), "empty slots under control");

    if (chain().is_adapter()) {

      int conv_op = chain().adapter_conversion_op();

      int arg_slot = chain().adapter_arg_slot();

      SlotState* arg_state = slot_state(arg_slot);

      if (arg_state == NULL

          && conv_op > java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) {

        lose("bad argument index", CHECK_(empty));

      }

      bool retain_original_args = false;  // used by fold/collect logic

      // perform the adapter action

      switch (conv_op) {

      case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:

        // No changes to arguments; pass the bits through.

        break;

      case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW: {

        // To keep the verifier happy, emit bitwise ("raw") conversions as needed.

        // See MethodHandles::same_basic_type_for_arguments for allowed conversions.

        Handle incoming_mtype(THREAD, chain().method_type_oop());

        Handle outgoing_mtype;

        {

          oop outgoing_mh_oop = chain().vmtarget_oop();

          if (!java_lang_invoke_MethodHandle::is_instance(outgoing_mh_oop))

            lose("outgoing target not a MethodHandle", CHECK_(empty));

          outgoing_mtype = Handle(THREAD, java_lang_invoke_MethodHandle::type(outgoing_mh_oop));

        }

        int nptypes = java_lang_invoke_MethodType::ptype_count(outgoing_mtype());

        if (nptypes != java_lang_invoke_MethodType::ptype_count(incoming_mtype()))

          lose("incoming and outgoing parameter count do not agree", CHECK_(empty));

        // Argument types.

        for (int i = 0, slot = _outgoing.length() - 1; slot >= 0; slot--) {

          SlotState* arg_state = slot_state(slot);

          if (arg_state->_type == T_VOID)  continue;

          klassOop  src_klass = NULL;

          klassOop  dst_klass = NULL;

          BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(incoming_mtype(), i), &src_klass);

          BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::ptype(outgoing_mtype(), i), &dst_klass);

          retype_raw_argument_type(src, dst, slot, CHECK_(empty));

          i++;  // We need to skip void slots at the top of the loop.

        }

        // Return type.

        {

          BasicType src = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(incoming_mtype()));

          BasicType dst = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(outgoing_mtype()));

          retype_raw_return_type(src, dst, CHECK_(empty));

        }

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST: {

        // checkcast the Nth outgoing argument in place

        klassOop dest_klass = NULL;

        BasicType dest = java_lang_Class::as_BasicType(chain().adapter_arg_oop(), &dest_klass);

        assert(dest == T_OBJECT, "");

        assert(dest == arg_state->_type, "");

        ArgToken arg = arg_state->_arg;

        ArgToken new_arg = make_conversion(T_OBJECT, dest_klass, Bytecodes::_checkcast, arg, CHECK_(empty));

        debug_only(dest_klass = (klassOop)badOop);

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM: {

        // i2l, etc., on the Nth outgoing argument in place

        BasicType src = chain().adapter_conversion_src_type(),

                  dest = chain().adapter_conversion_dest_type();

        Bytecodes::Code bc = conversion_code(src, dest);

        ArgToken arg = arg_state->_arg;

        if (bc == Bytecodes::_nop) {

          break;

        } else if (bc != Bytecodes::_illegal) {

          arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

        } else if (is_subword_type(dest)) {

          bc = conversion_code(src, T_INT);

          if (bc != Bytecodes::_illegal) {

            arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

            bc = conversion_code(T_INT, dest);

            arg = make_conversion(dest, NULL, bc, arg, CHECK_(empty));

          }

        }

        if (bc == Bytecodes::_illegal) {

          lose("bad primitive conversion", CHECK_(empty));

        }

        change_argument(src, arg_slot, dest, arg);

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM: {

        // checkcast to wrapper type & call intValue, etc.

        BasicType dest = chain().adapter_conversion_dest_type();

        ArgToken arg = arg_state->_arg;

        arg = make_conversion(T_OBJECT, SystemDictionary::box_klass(dest),

                              Bytecodes::_checkcast, arg, CHECK_(empty));

        vmIntrinsics::ID unboxer = vmIntrinsics::for_unboxing(dest);

        if (unboxer == vmIntrinsics::_none) {

          lose("no unboxing method", CHECK_(empty));

        }

        ArgToken arglist[2];

        arglist[0] = arg;         // outgoing 'this'

        arglist[1] = ArgToken();  // sentinel

        arg = make_invoke(NULL, unboxer, Bytecodes::_invokevirtual, false, 1, &arglist[0], CHECK_(empty));

        change_argument(T_OBJECT, arg_slot, dest, arg);

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF: {

        // call wrapper type.valueOf

        BasicType src = chain().adapter_conversion_src_type();

        ArgToken arg = arg_state->_arg;

        vmIntrinsics::ID boxer = vmIntrinsics::for_boxing(src);

        if (boxer == vmIntrinsics::_none) {

          lose("no boxing method", CHECK_(empty));

        }

        ArgToken arglist[2];

        arglist[0] = arg;         // outgoing value

        arglist[1] = ArgToken();  // sentinel

        arg = make_invoke(NULL, boxer, Bytecodes::_invokestatic, false, 1, &arglist[0], CHECK_(empty));

        change_argument(src, arg_slot, T_OBJECT, arg);

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS: {

        int dest_arg_slot = chain().adapter_conversion_vminfo();

        if (!slot_has_argument(dest_arg_slot)) {

          lose("bad swap index", CHECK_(empty));

        }

        // a simple swap between two arguments

        SlotState* dest_arg_state = slot_state(dest_arg_slot);

        SlotState temp = (*dest_arg_state);

        (*dest_arg_state) = (*arg_state);

        (*arg_state) = temp;

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {

        int dest_arg_slot = chain().adapter_conversion_vminfo();

        if (!slot_has_argument(dest_arg_slot) || arg_slot == dest_arg_slot) {

          lose("bad rotate index", CHECK_(empty));

        }

        SlotState* dest_arg_state = slot_state(dest_arg_slot);

        // Rotate the source argument (plus following N slots) into the

        // position occupied by the dest argument (plus following N slots).

        int rotate_count = type2size[dest_arg_state->_type];

        // (no other rotate counts are currently supported)

        if (arg_slot < dest_arg_slot) {

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

            SlotState temp = _outgoing.at(arg_slot);

            _outgoing.remove_at(arg_slot);

            _outgoing.insert_before(dest_arg_slot + rotate_count - 1, temp);

          }

        } else { // arg_slot > dest_arg_slot

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

            SlotState temp = _outgoing.at(arg_slot + rotate_count - 1);

            _outgoing.remove_at(arg_slot + rotate_count - 1);

            _outgoing.insert_before(dest_arg_slot, temp);

          }

        }

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS: {

        int dup_slots = chain().adapter_conversion_stack_pushes();

        if (dup_slots <= 0) {

          lose("bad dup count", CHECK_(empty));

        }

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

          SlotState* dup = slot_state(arg_slot + 2*i);

          if (dup == NULL)              break;  // safety net

          if (dup->_type != T_VOID)     _outgoing_argc += 1;

          _outgoing.insert_before(i, (*dup));

        }

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {

        int drop_slots = -chain().adapter_conversion_stack_pushes();

        if (drop_slots <= 0) {

          lose("bad drop count", CHECK_(empty));

        }

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

          SlotState* drop = slot_state(arg_slot);

          if (drop == NULL)             break;  // safety net

          if (drop->_type != T_VOID)    _outgoing_argc -= 1;

          _outgoing.remove_at(arg_slot);

        }

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:

        retain_original_args = true;   // and fall through:

      case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {

        // call argument MH recursively

        //{static int x; if (!x++) print_method_handle(chain().method_handle_oop()); --x;}

        Handle recursive_mh(THREAD, chain().adapter_arg_oop());

        if (!java_lang_invoke_MethodHandle::is_instance(recursive_mh())) {

          lose("recursive target not a MethodHandle", CHECK_(empty));

        }

        Handle recursive_mtype(THREAD, java_lang_invoke_MethodHandle::type(recursive_mh()));

        int argc = java_lang_invoke_MethodType::ptype_count(recursive_mtype());

        int coll_slots = java_lang_invoke_MethodHandle::vmslots(recursive_mh());

        BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(recursive_mtype()));

        ArgToken* arglist = NEW_RESOURCE_ARRAY(ArgToken, 1 + argc + 1);  // 1+: mh, +1: sentinel

        arglist[0] = make_oop_constant(recursive_mh(), CHECK_(empty));

        if (arg_slot < 0 || coll_slots < 0 || arg_slot + coll_slots > _outgoing.length()) {

          lose("bad fold/collect arg slot", CHECK_(empty));

        }

        for (int i = 0, slot = arg_slot + coll_slots - 1; slot >= arg_slot; slot--) {

          SlotState* arg_state = slot_state(slot);

          BasicType  arg_type  = arg_state->_type;

          if (arg_type == T_VOID)  continue;

          ArgToken arg = _outgoing.at(slot)._arg;

          if (i >= argc) { lose("bad fold/collect arg", CHECK_(empty)); }

          arglist[1+i] = arg;

          if (!retain_original_args)

            change_argument(arg_type, slot, T_VOID, ArgToken(tt_void));

          i++;

        }

        arglist[1+argc] = ArgToken();  // sentinel

        oop invoker = java_lang_invoke_MethodTypeForm::vmlayout(

                          java_lang_invoke_MethodType::form(recursive_mtype()) );

        if (invoker == NULL || !invoker->is_method()) {

          lose("bad vmlayout slot", CHECK_(empty));

        }

        // FIXME: consider inlining the invokee at the bytecode level

        ArgToken ret = make_invoke(methodOop(invoker), vmIntrinsics::_none,

                                   Bytecodes::_invokevirtual, false, 1+argc, &arglist[0], CHECK_(empty));

        DEBUG_ONLY(invoker = NULL);

        if (rtype == T_OBJECT) {

          klassOop rklass = java_lang_Class::as_klassOop( java_lang_invoke_MethodType::rtype(recursive_mtype()) );

          if (rklass != SystemDictionary::Object_klass() &&

              !Klass::cast(rklass)->is_interface()) {

            // preserve type safety

            ret = make_conversion(T_OBJECT, rklass, Bytecodes::_checkcast, ret, CHECK_(empty));

          }

        }

        break;

      }

      case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {

        klassOop array_klass_oop = NULL;

        BasicType array_type = java_lang_Class::as_BasicType(chain().adapter_arg_oop(),

                                                             &array_klass_oop);

        assert(array_type == T_OBJECT, "");

        assert(Klass::cast(array_klass_oop)->oop_is_array(), "");

        arrayKlassHandle array_klass(THREAD, array_klass_oop);

        debug_only(array_klass_oop = (klassOop)badOop);

        klassOop element_klass_oop = NULL;

        BasicType element_type = java_lang_Class::as_BasicType(array_klass->component_mirror(),

                                                               &element_klass_oop);

        KlassHandle element_klass(THREAD, element_klass_oop);

        debug_only(element_klass_oop = (klassOop)badOop);

        // Fetch the argument, which we will cast to the required array type.

        assert(arg_state->_type == T_OBJECT, "");

        ArgToken array_arg = arg_state->_arg;

        array_arg = make_conversion(T_OBJECT, array_klass(), Bytecodes::_checkcast, array_arg, CHECK_(empty));

        change_argument(T_OBJECT, arg_slot, T_VOID, ArgToken(tt_void));

        // Check the required length.

        int spread_slots = 1 + chain().adapter_conversion_stack_pushes();

        int spread_length = spread_slots;

        if (type2size[element_type] == 2) {

          if (spread_slots % 2 != 0)  spread_slots = -1;  // force error

          spread_length = spread_slots / 2;

        }

        if (spread_slots < 0) {

          lose("bad spread length", CHECK_(empty));

        }

        jvalue   length_jvalue;  length_jvalue.i = spread_length;

        ArgToken length_arg = make_prim_constant(T_INT, &length_jvalue, CHECK_(empty));

        // Call a built-in method known to the JVM to validate the length.

        ArgToken arglist[3];

        arglist[0] = array_arg;   // value to check

        arglist[1] = length_arg;  // length to check

        arglist[2] = ArgToken();  // sentinel

        make_invoke(NULL, vmIntrinsics::_checkSpreadArgument,

                    Bytecodes::_invokestatic, false, 2, &arglist[0], CHECK_(empty));

        // Spread out the array elements.

        Bytecodes::Code aload_op = Bytecodes::_nop;

        switch (element_type) {

        case T_INT:       aload_op = Bytecodes::_iaload; break;

        case T_LONG:      aload_op = Bytecodes::_laload; break;

        case T_FLOAT:     aload_op = Bytecodes::_faload; break;

        case T_DOUBLE:    aload_op = Bytecodes::_daload; break;

        case T_OBJECT:    aload_op = Bytecodes::_aaload; break;

        case T_BOOLEAN:   // fall through:

        case T_BYTE:      aload_op = Bytecodes::_baload; break;

        case T_CHAR:      aload_op = Bytecodes::_caload; break;

        case T_SHORT:     aload_op = Bytecodes::_saload; break;

        default:          lose("primitive array NYI", CHECK_(empty));