/*

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

#ifdef ASSERT

  if (Verbose) {

    tty->print_cr(INTPTR_FORMAT " lose: %s", _method_handle(), msg);

    print();

  }

#endif

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

}

#ifdef ASSERT

static const char* adapter_ops[] = {

  "retype_only"  ,

  "retype_raw"   ,

  "check_cast"   ,

  "prim_to_prim" ,

  "ref_to_prim"  ,

  "prim_to_ref"  ,

  "swap_args"    ,

  "rot_args"     ,

  "dup_args"     ,

  "drop_args"    ,

  "collect_args" ,

  "spread_args"  ,

  "fold_args"

};

static const char* adapter_op_to_string(int op) {

  if (op >= 0 && op < (int)ARRAY_SIZE(adapter_ops))

    return adapter_ops[op];

  return "unknown_op";

}

void MethodHandleChain::print(Handle mh) {

  EXCEPTION_MARK;

  MethodHandleChain mhc(mh, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    oop ex = THREAD->pending_exception();

    CLEAR_PENDING_EXCEPTION;

    ex->print();

    return;

  }

  mhc.print();

}

void MethodHandleChain::print() {

  EXCEPTION_MARK;

  print_impl(THREAD);

  if (HAS_PENDING_EXCEPTION) {

    oop ex = THREAD->pending_exception();

    CLEAR_PENDING_EXCEPTION;

    ex->print();

  }

}

void MethodHandleChain::print_impl(TRAPS) {

  ResourceMark rm;

  MethodHandleChain chain(_root, CHECK);

  for (;;) {

    tty->print(INTPTR_FORMAT ": ", chain.method_handle()());

    if (chain.is_bound()) {

      tty->print("bound: arg_type %s arg_slot %d",

                 type2name(chain.bound_arg_type()),

                 chain.bound_arg_slot());

      oop o = chain.bound_arg_oop();

      if (o != NULL) {

        if (o->is_instance()) {

          tty->print(" instance %s", o->klass()->klass_part()->internal_name());

        } else {

          o->print();

        }

      }

    } else if (chain.is_adapter()) {

      tty->print("adapter: arg_slot %d conversion op %s",

                 chain.adapter_arg_slot(),

                 adapter_op_to_string(chain.adapter_conversion_op()));

      switch (chain.adapter_conversion_op()) {

        case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY:

        case java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW:

        case java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST:

        case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM:

        case java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM:

        case java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF:

          break;

        case java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS:

        case java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS: {

          int dest_arg_slot = chain.adapter_conversion_vminfo();

          tty->print(" dest_arg_slot %d type %s", dest_arg_slot, type2name(chain.adapter_conversion_src_type()));

          break;

        }

        case java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS:

        case java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS: {

          int dup_slots = chain.adapter_conversion_stack_pushes();

          tty->print(" pushes %d", dup_slots);

          break;

        }

        case java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS:

        case java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS: {

          int coll_slots = chain.MethodHandle_vmslots();

          tty->print(" coll_slots %d", coll_slots);

          break;

        }

        case java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS: {

          // Check the required length.

          int spread_slots = 1 + chain.adapter_conversion_stack_pushes();

          tty->print(" spread_slots %d", spread_slots);

          break;

        }

        default:

          tty->print_cr("bad adapter conversion");

          break;

      }

    } else {

      // DMH

      tty->print("direct: ");

      chain.last_method_oop()->print_short_name(tty);

    }

    tty->print(" (");

    objArrayOop ptypes = java_lang_invoke_MethodType::ptypes(chain.method_type_oop());

    for (int i = ptypes->length() - 1; i >= 0; i--) {

      BasicType t = java_lang_Class::as_BasicType(ptypes->obj_at(i));

      if (t == T_ARRAY) t = T_OBJECT;

      tty->print("%c", type2char(t));

      if (t == T_LONG || t == T_DOUBLE) tty->print("_");

    }

    tty->print(")");

    BasicType rtype = java_lang_Class::as_BasicType(java_lang_invoke_MethodType::rtype(chain.method_type_oop()));

    if (rtype == T_ARRAY) rtype = T_OBJECT;

    tty->print("%c", type2char(rtype));

    tty->cr();

    if (!chain.is_last()) {

      chain.next(CHECK);

    } else {

      break;

    }

  }

}

#endif

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

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

      // Check that the arg_slot is valid.  In most cases it must be

      // within range of the current arguments but there are some

      // exceptions.  Those are sanity checked in their implemention

      // below.

      if ((arg_slot < 0 || arg_slot >= _outgoing.length()) &&

          conv_op > java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW &&

          conv_op != java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS &&

          conv_op != java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS) {

        lose(err_msg("bad argument index %d", arg_slot), 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--) {

          if (arg_type(slot) == 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, "");

        ArgToken arg = _outgoing.at(arg_slot);

        assert(dest == arg.basic_type(), "");

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

        ArgToken arg = _outgoing.at(arg_slot);

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

        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(err_msg("bad primitive conversion for %s -> %s", type2name(src), type2name(dest)), 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 = _outgoing.at(arg_slot);

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

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

        if (boxer == vmIntrinsics::_none) {

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

        }

        ArgToken arg = _outgoing.at(arg_slot);

        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 (!has_argument(dest_arg_slot)) {

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

        }

        // a simple swap between two arguments

        if (arg_slot > dest_arg_slot) {

          int tmp = arg_slot;

          arg_slot = dest_arg_slot;

          dest_arg_slot = tmp;

        }

        ArgToken a1 = _outgoing.at(arg_slot);

        ArgToken a2 = _outgoing.at(dest_arg_slot);

        change_argument(a2.basic_type(), dest_arg_slot, a1);

        change_argument(a1.basic_type(), arg_slot, a2);

        break;