/*

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

 *

 */

#include "precompiled.hpp"

#include "interpreter/rewriter.hpp"

#include "memory/oopFactory.hpp"

#include "prims/methodHandleWalk.hpp"

/*

 * JSR 292 reference implementation: method handle structure analysis

 */

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

// MethodHandleChain

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

  if (!java_dyn_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 (sun_dyn_DirectMethodHandle::is_instance(mh())) {

    set_last_method(mh(), THREAD);

    return;

  }

  if (sun_dyn_AdapterMethodHandle::is_instance(mh())) {

    _conversion = AdapterMethodHandle_conversion();

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

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

  }

  if (sun_dyn_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_dyn_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;

  klassOop receiver_limit_oop = NULL;

  int flags = 0;

  methodOop m = MethodHandles::decode_method(target, receiver_limit_oop, flags);

  _last_method = methodHandle(THREAD, m);

  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.

  // FIXME: Make it explicit MethodHandleImpl refactors out from MethodHandle

  BasicType arg_type = T_VOID;

  if (target != NULL) {

    oop mtype = java_dyn_MethodHandle::type(target);

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

    if (arg_num >= 0) {

      oop ptype = java_dyn_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;

    }

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

  assert(false, "lose");

  _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 > sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW) {

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

      }

      // perform the adapter action

      switch (chain().adapter_conversion_op()) {

      case sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY:

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

        break;

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

        oop outgoing_mh_oop = chain().vmtarget_oop();

        if (!java_dyn_MethodHandle::is_instance(outgoing_mh_oop))

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

        Handle outgoing_mtype(THREAD, java_dyn_MethodHandle::type(outgoing_mh_oop));

        outgoing_mh_oop = NULL;  // GC safety

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

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

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

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

          SlotState* arg_state = slot_state(slot);

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

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

          klassOop  in_klass  = NULL;

          klassOop  out_klass = NULL;

          BasicType inpbt  = java_lang_Class::as_BasicType(java_dyn_MethodType::ptype(incoming_mtype(), i), &in_klass);

          BasicType outpbt = java_lang_Class::as_BasicType(java_dyn_MethodType::ptype(outgoing_mtype(), i), &out_klass);

          assert(inpbt == arg.basic_type(), "sanity");

          if (inpbt != outpbt) {

            vmIntrinsics::ID iid = vmIntrinsics::for_raw_conversion(inpbt, outpbt);

            if (iid == vmIntrinsics::_none) {

              lose("no raw conversion method", CHECK_(empty));

            }

            ArgToken arglist[2];

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

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

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

            change_argument(inpbt, slot, outpbt, arg);

          }

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

        }

        BasicType inrbt  = java_lang_Class::as_BasicType(java_dyn_MethodType::rtype(incoming_mtype()));

        BasicType outrbt = java_lang_Class::as_BasicType(java_dyn_MethodType::rtype(outgoing_mtype()));

        if (inrbt != outrbt) {

          if (inrbt == T_INT && outrbt == T_VOID) {

            // See comments in MethodHandles::same_basic_type_for_arguments.

          } else {

            assert(false, "IMPLEMENT ME");

            lose("no raw conversion method", CHECK_(empty));

          }

        }

        break;

      }

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

        assert(arg.index() == new_arg.index(), "should be the same index");

        debug_only(dest_klass = (klassOop)badOop);

        break;

      }

      case sun_dyn_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 sun_dyn_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 sun_dyn_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::_invokevirtual, false, 1, &arglist[0], CHECK_(empty));

        change_argument(src, arg_slot, T_OBJECT, arg);

        break;

      }

      case sun_dyn_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 sun_dyn_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 sun_dyn_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 sun_dyn_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 sun_dyn_AdapterMethodHandle::OP_COLLECT_ARGS: { //NYI, may GC

        lose("unimplemented", CHECK_(empty));

        break;

      }

      case sun_dyn_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, 3, &arglist[0], CHECK_(empty));

        // Spread out the array elements.

        Bytecodes::Code aload_op = Bytecodes::_aaload;

        if (element_type != T_OBJECT) {

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

        }

        int ap = arg_slot;

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

          jvalue   offset_jvalue;  offset_jvalue.i = i;

          ArgToken offset_arg = make_prim_constant(T_INT, &offset_jvalue, CHECK_(empty));

          ArgToken element_arg = make_fetch(element_type, element_klass(), aload_op, array_arg, offset_arg, CHECK_(empty));

          change_argument(T_VOID, ap, element_type, element_arg);

          ap += type2size[element_type];

        }

        break;

      }

      case sun_dyn_AdapterMethodHandle::OP_FLYBY: //NYI, runs Java code

      case sun_dyn_AdapterMethodHandle::OP_RICOCHET: //NYI, runs Java code

        lose("unimplemented", CHECK_(empty));

        break;

      default:

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

        break;

      }

    }

    if (chain().is_bound()) {

      // push a new argument

      BasicType arg_type  = chain().bound_arg_type();

      jint      arg_slot  = chain().bound_arg_slot();

      oop       arg_oop   = chain().bound_arg_oop();

      ArgToken  arg;

      if (arg_type == T_OBJECT) {

        arg = make_oop_constant(arg_oop, CHECK_(empty));

      } else {

        jvalue arg_value;

        BasicType bt = java_lang_boxing_object::get_value(arg_oop, &arg_value);

        if (bt == arg_type) {

          arg = make_prim_constant(arg_type, &arg_value, CHECK_(empty));

        } else {

          lose("bad bound value", CHECK_(empty));

        }

      }

      debug_only(arg_oop = badOop);

      change_argument(T_VOID, arg_slot, arg_type, arg);

    }

    // this test must come after the body of the loop

    if (!chain().is_last()) {

      chain().next(CHECK_(empty));

    } else {

      break;

    }

  }

  // finish the sequence with a tail-call to the ultimate target

  // parameters are passed in logical order (recv 1st), not slot order