/*

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

#include "memory/allocation.inline.hpp"

#include "prims/methodHandles.hpp"

#define __ _masm->

#ifdef PRODUCT

#define BLOCK_COMMENT(str) /* nothing */

#else

#define BLOCK_COMMENT(str) __ block_comment(str)

#endif

#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")

address MethodHandleEntry::start_compiled_entry(MacroAssembler* _masm,

                                                address interpreted_entry) {

  // Just before the actual machine code entry point, allocate space

  // for a MethodHandleEntry::Data record, so that we can manage everything

  // from one base pointer.

  __ align(wordSize);

  address target = __ pc() + sizeof(Data);

  while (__ pc() < target) {

    __ nop();

    __ align(wordSize);

  }

  MethodHandleEntry* me = (MethodHandleEntry*) __ pc();

  me->set_end_address(__ pc());         // set a temporary end_address

  me->set_from_interpreted_entry(interpreted_entry);

  me->set_type_checking_entry(NULL);

  return (address) me;

}

MethodHandleEntry* MethodHandleEntry::finish_compiled_entry(MacroAssembler* _masm,

                                                address start_addr) {

  MethodHandleEntry* me = (MethodHandleEntry*) start_addr;

  assert(me->end_address() == start_addr, "valid ME");

  // Fill in the real end_address:

  __ align(wordSize);

  me->set_end_address(__ pc());

  return me;

}

// Code generation

address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* _masm) {

  // I5_savedSP/O5_savedSP: sender SP (must preserve)

  // G4 (Gargs): incoming argument list (must preserve)

  // G5_method:  invoke methodOop

  // G3_method_handle: receiver method handle (must load from sp[MethodTypeForm.vmslots])

  // O0, O1, O2, O3, O4: garbage temps, blown away

  Register O0_mtype   = O0;

  Register O1_scratch = O1;

  Register O2_scratch = O2;

  Register O3_scratch = O3;

  Register O4_argslot = O4;

  Register O4_argbase = O4;

  // emit WrongMethodType path first, to enable back-branch from main path

  Label wrong_method_type;

  __ bind(wrong_method_type);

  Label invoke_generic_slow_path;

  assert(methodOopDesc::intrinsic_id_size_in_bytes() == sizeof(u1), "");;

  __ ldub(Address(G5_method, methodOopDesc::intrinsic_id_offset_in_bytes()), O1_scratch);

  __ cmp(O1_scratch, (int) vmIntrinsics::_invokeExact);

  __ brx(Assembler::notEqual, false, Assembler::pt, invoke_generic_slow_path);

  __ delayed()->nop();

  __ mov(O0_mtype, G5_method_type);  // required by throw_WrongMethodType

  // mov(G3_method_handle, G3_method_handle);  // already in this register

  __ jump_to(AddressLiteral(Interpreter::throw_WrongMethodType_entry()), O1_scratch);

  __ delayed()->nop();

  // here's where control starts out:

  __ align(CodeEntryAlignment);

  address entry_point = __ pc();

  // fetch the MethodType from the method handle

  {

    Register tem = G5_method;

    for (jint* pchase = methodOopDesc::method_type_offsets_chain(); (*pchase) != -1; pchase++) {

      __ ld_ptr(Address(tem, *pchase), O0_mtype);

      tem = O0_mtype;          // in case there is another indirection

    }

  }

  // given the MethodType, find out where the MH argument is buried

  __ load_heap_oop(Address(O0_mtype,   __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes,        O1_scratch)), O4_argslot);

  __ ldsw(         Address(O4_argslot, __ delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, O1_scratch)), O4_argslot);

  __ add(Gargs, __ argument_offset(O4_argslot, 1), O4_argbase);

  // Note: argument_address uses its input as a scratch register!

  __ ld_ptr(Address(O4_argbase, -Interpreter::stackElementSize), G3_method_handle);

  trace_method_handle(_masm, "invokeExact");

  __ check_method_handle_type(O0_mtype, G3_method_handle, O1_scratch, wrong_method_type);

  __ jump_to_method_handle_entry(G3_method_handle, O1_scratch);

  // for invokeGeneric (only), apply argument and result conversions on the fly

  __ bind(invoke_generic_slow_path);

#ifdef ASSERT

  { Label L;

    __ ldub(Address(G5_method, methodOopDesc::intrinsic_id_offset_in_bytes()), O1_scratch);

    __ cmp(O1_scratch, (int) vmIntrinsics::_invokeGeneric);

    __ brx(Assembler::equal, false, Assembler::pt, L);

    __ delayed()->nop();

    __ stop("bad methodOop::intrinsic_id");

    __ bind(L);

  }

#endif //ASSERT

  // make room on the stack for another pointer:

  insert_arg_slots(_masm, 2 * stack_move_unit(), _INSERT_REF_MASK, O4_argbase, O1_scratch, O2_scratch, O3_scratch);

  // load up an adapter from the calling type (Java weaves this)

  Register O2_form    = O2_scratch;

  Register O3_adapter = O3_scratch;

  __ load_heap_oop(Address(O0_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes,               O1_scratch)), O2_form);

  // load_heap_oop(Address(O2_form,  __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);

  // deal with old JDK versions:

  __ add(          Address(O2_form,  __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter);

  __ cmp(O3_adapter, O2_form);

  Label sorry_no_invoke_generic;

  __ brx(Assembler::lessUnsigned, false, Assembler::pn, sorry_no_invoke_generic);

  __ delayed()->nop();

  __ load_heap_oop(Address(O3_adapter, 0), O3_adapter);

  __ tst(O3_adapter);

  __ brx(Assembler::zero, false, Assembler::pn, sorry_no_invoke_generic);

  __ delayed()->nop();

  __ st_ptr(O3_adapter, Address(O4_argbase, 1 * Interpreter::stackElementSize));

  // As a trusted first argument, pass the type being called, so the adapter knows

  // the actual types of the arguments and return values.

  // (Generic invokers are shared among form-families of method-type.)

  __ st_ptr(O0_mtype,   Address(O4_argbase, 0 * Interpreter::stackElementSize));

  // FIXME: assert that O3_adapter is of the right method-type.

  __ mov(O3_adapter, G3_method_handle);

  trace_method_handle(_masm, "invokeGeneric");

  __ jump_to_method_handle_entry(G3_method_handle, O1_scratch);

  __ bind(sorry_no_invoke_generic); // no invokeGeneric implementation available!

  __ mov(O0_mtype, G5_method_type);  // required by throw_WrongMethodType

  // mov(G3_method_handle, G3_method_handle);  // already in this register

  __ jump_to(AddressLiteral(Interpreter::throw_WrongMethodType_entry()), O1_scratch);

  __ delayed()->nop();

  return entry_point;

}

#ifdef ASSERT

static void verify_argslot(MacroAssembler* _masm, Register argslot_reg, Register temp_reg, const char* error_message) {

  // Verify that argslot lies within (Gargs, FP].

  Label L_ok, L_bad;

  BLOCK_COMMENT("{ verify_argslot");

#ifdef _LP64

  __ add(FP, STACK_BIAS, temp_reg);

  __ cmp(argslot_reg, temp_reg);

#else

  __ cmp(argslot_reg, FP);

#endif

  __ brx(Assembler::greaterUnsigned, false, Assembler::pn, L_bad);

  __ delayed()->nop();

  __ cmp(Gargs, argslot_reg);

  __ brx(Assembler::lessEqualUnsigned, false, Assembler::pt, L_ok);

  __ delayed()->nop();

  __ bind(L_bad);

  __ stop(error_message);

  __ bind(L_ok);

  BLOCK_COMMENT("} verify_argslot");

}

#endif

// Helper to insert argument slots into the stack.

// arg_slots must be a multiple of stack_move_unit() and <= 0

void MethodHandles::insert_arg_slots(MacroAssembler* _masm,

                                     RegisterOrConstant arg_slots,

                                     int arg_mask,

                                     Register argslot_reg,

                                     Register temp_reg, Register temp2_reg, Register temp3_reg) {

  assert(temp3_reg != noreg, "temp3 required");

  assert_different_registers(argslot_reg, temp_reg, temp2_reg, temp3_reg,

                             (!arg_slots.is_register() ? Gargs : arg_slots.as_register()));

#ifdef ASSERT

  verify_argslot(_masm, argslot_reg, temp_reg, "insertion point must fall within current frame");

  if (arg_slots.is_register()) {

    Label L_ok, L_bad;

    __ cmp(arg_slots.as_register(), (int32_t) NULL_WORD);

    __ br(Assembler::greater, false, Assembler::pn, L_bad);

    __ delayed()->nop();

    __ btst(-stack_move_unit() - 1, arg_slots.as_register());

    __ br(Assembler::zero, false, Assembler::pt, L_ok);

    __ delayed()->nop();

    __ bind(L_bad);

    __ stop("assert arg_slots <= 0 and clear low bits");

    __ bind(L_ok);

  } else {

    assert(arg_slots.as_constant() <= 0, "");

    assert(arg_slots.as_constant() % -stack_move_unit() == 0, "");

  }

#endif // ASSERT

#ifdef _LP64

  if (arg_slots.is_register()) {

    // Was arg_slots register loaded as signed int?

    Label L_ok;

    __ sll(arg_slots.as_register(), BitsPerInt, temp_reg);

    __ sra(temp_reg, BitsPerInt, temp_reg);

    __ cmp(arg_slots.as_register(), temp_reg);

    __ br(Assembler::equal, false, Assembler::pt, L_ok);

    __ delayed()->nop();

    __ stop("arg_slots register not loaded as signed int");

    __ bind(L_ok);

  }

#endif

  // Make space on the stack for the inserted argument(s).

  // Then pull down everything shallower than argslot_reg.

  // The stacked return address gets pulled down with everything else.

  // That is, copy [sp, argslot) downward by -size words.  In pseudo-code:

  //   sp -= size;

  //   for (temp = sp + size; temp < argslot; temp++)

  //     temp[-size] = temp[0]

  //   argslot -= size;

  BLOCK_COMMENT("insert_arg_slots {");

  RegisterOrConstant offset = __ regcon_sll_ptr(arg_slots, LogBytesPerWord, temp3_reg);

  // Keep the stack pointer 2*wordSize aligned.

  const int TwoWordAlignmentMask = right_n_bits(LogBytesPerWord + 1);

  RegisterOrConstant masked_offset = __ regcon_andn_ptr(offset, TwoWordAlignmentMask, temp_reg);

  __ add(SP, masked_offset, SP);

  __ mov(Gargs, temp_reg);  // source pointer for copy

  __ add(Gargs, offset, Gargs);

  {

    Label loop;

    __ BIND(loop);

    // pull one word down each time through the loop

    __ ld_ptr(Address(temp_reg, 0), temp2_reg);

    __ st_ptr(temp2_reg, Address(temp_reg, offset));

    __ add(temp_reg, wordSize, temp_reg);

    __ cmp(temp_reg, argslot_reg);

    __ brx(Assembler::less, false, Assembler::pt, loop);

    __ delayed()->nop();  // FILLME

  }

  // Now move the argslot down, to point to the opened-up space.

  __ add(argslot_reg, offset, argslot_reg);

  BLOCK_COMMENT("} insert_arg_slots");

}

// Helper to remove argument slots from the stack.

// arg_slots must be a multiple of stack_move_unit() and >= 0

void MethodHandles::remove_arg_slots(MacroAssembler* _masm,

                                     RegisterOrConstant arg_slots,

                                     Register argslot_reg,

                                     Register temp_reg, Register temp2_reg, Register temp3_reg) {

  assert(temp3_reg != noreg, "temp3 required");

  assert_different_registers(argslot_reg, temp_reg, temp2_reg, temp3_reg,

                             (!arg_slots.is_register() ? Gargs : arg_slots.as_register()));

  RegisterOrConstant offset = __ regcon_sll_ptr(arg_slots, LogBytesPerWord, temp3_reg);

#ifdef ASSERT

  // Verify that [argslot..argslot+size) lies within (Gargs, FP).

  __ add(argslot_reg, offset, temp2_reg);

  verify_argslot(_masm, temp2_reg, temp_reg, "deleted argument(s) must fall within current frame");

  if (arg_slots.is_register()) {

    Label L_ok, L_bad;

    __ cmp(arg_slots.as_register(), (int32_t) NULL_WORD);

    __ br(Assembler::less, false, Assembler::pn, L_bad);

    __ delayed()->nop();

    __ btst(-stack_move_unit() - 1, arg_slots.as_register());

    __ br(Assembler::zero, false, Assembler::pt, L_ok);

    __ delayed()->nop();

    __ bind(L_bad);

    __ stop("assert arg_slots >= 0 and clear low bits");

    __ bind(L_ok);

  } else {

    assert(arg_slots.as_constant() >= 0, "");

    assert(arg_slots.as_constant() % -stack_move_unit() == 0, "");

  }

#endif // ASSERT

  BLOCK_COMMENT("remove_arg_slots {");

  // Pull up everything shallower than argslot.

  // Then remove the excess space on the stack.

  // The stacked return address gets pulled up with everything else.

  // That is, copy [sp, argslot) upward by size words.  In pseudo-code:

  //   for (temp = argslot-1; temp >= sp; --temp)

  //     temp[size] = temp[0]

  //   argslot += size;

  //   sp += size;

  __ sub(argslot_reg, wordSize, temp_reg);  // source pointer for copy

  {

    Label loop;

    __ BIND(loop);

    // pull one word up each time through the loop

    __ ld_ptr(Address(temp_reg, 0), temp2_reg);

    __ st_ptr(temp2_reg, Address(temp_reg, offset));

    __ sub(temp_reg, wordSize, temp_reg);

    __ cmp(temp_reg, Gargs);

    __ brx(Assembler::greaterEqual, false, Assembler::pt, loop);

    __ delayed()->nop();  // FILLME

  }

  // Now move the argslot up, to point to the just-copied block.

  __ add(Gargs, offset, Gargs);

  // And adjust the argslot address to point at the deletion point.

  __ add(argslot_reg, offset, argslot_reg);

  // Keep the stack pointer 2*wordSize aligned.

  const int TwoWordAlignmentMask = right_n_bits(LogBytesPerWord + 1);

  RegisterOrConstant masked_offset = __ regcon_andn_ptr(offset, TwoWordAlignmentMask, temp_reg);

  __ add(SP, masked_offset, SP);

  BLOCK_COMMENT("} remove_arg_slots");

}

#ifndef PRODUCT

extern "C" void print_method_handle(oop mh);

void trace_method_handle_stub(const char* adaptername,

                              oopDesc* mh) {

  printf("MH %s mh="INTPTR_FORMAT"\n", adaptername, (intptr_t) mh);

  print_method_handle(mh);

}

void MethodHandles::trace_method_handle(MacroAssembler* _masm, const char* adaptername) {

  if (!TraceMethodHandles)  return;

  BLOCK_COMMENT("trace_method_handle {");

  // save: Gargs, O5_savedSP

  __ save_frame(16);

  __ set((intptr_t) adaptername, O0);

  __ mov(G3_method_handle, O1);

  __ mov(G3_method_handle, L3);

  __ mov(Gargs, L4);

  __ mov(G5_method_type, L5);

  __ call_VM_leaf(L7, CAST_FROM_FN_PTR(address, trace_method_handle_stub));

  __ mov(L3, G3_method_handle);

  __ mov(L4, Gargs);

  __ mov(L5, G5_method_type);

  __ restore();

  BLOCK_COMMENT("} trace_method_handle");

}

#endif // PRODUCT

// which conversion op types are implemented here?

int MethodHandles::adapter_conversion_ops_supported_mask() {

  return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS)

         |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS)

         //|(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) //BUG!

         );

  // FIXME: MethodHandlesTest gets a crash if we enable OP_SPREAD_ARGS.

}

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

// MethodHandles::generate_method_handle_stub

//

// Generate an "entry" field for a method handle.

// This determines how the method handle will respond to calls.

void MethodHandles::generate_method_handle_stub(MacroAssembler* _masm, MethodHandles::EntryKind ek) {

  // Here is the register state during an interpreted call,

  // as set up by generate_method_handle_interpreter_entry():

  // - G5: garbage temp (was MethodHandle.invoke methodOop, unused)

  // - G3: receiver method handle

  // - O5_savedSP: sender SP (must preserve)

  const Register O0_argslot = O0;

  const Register O1_scratch = O1;

  const Register O2_scratch = O2;

  const Register O3_scratch = O3;

  const Register G5_index   = G5;

  // Argument registers for _raise_exception.

  const Register O0_code     = O0;

  const Register O1_actual   = O1;

  const Register O2_required = O2;

  guarantee(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets");

  // Some handy addresses:

  Address G5_method_fie(    G5_method,        in_bytes(methodOopDesc::from_interpreted_offset()));

  Address G5_method_fce(    G5_method,        in_bytes(methodOopDesc::from_compiled_offset()));

  Address G3_mh_vmtarget(   G3_method_handle, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes());

  Address G3_dmh_vmindex(   G3_method_handle, java_lang_invoke_DirectMethodHandle::vmindex_offset_in_bytes());

  Address G3_bmh_vmargslot( G3_method_handle, java_lang_invoke_BoundMethodHandle::vmargslot_offset_in_bytes());

  Address G3_bmh_argument(  G3_method_handle, java_lang_invoke_BoundMethodHandle::argument_offset_in_bytes());

  Address G3_amh_vmargslot( G3_method_handle, java_lang_invoke_AdapterMethodHandle::vmargslot_offset_in_bytes());

  Address G3_amh_argument ( G3_method_handle, java_lang_invoke_AdapterMethodHandle::argument_offset_in_bytes());

  Address G3_amh_conversion(G3_method_handle, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes());

  const int java_mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();

  if (have_entry(ek)) {

    __ nop();  // empty stubs make SG sick

    return;

  }

  address interp_entry = __ pc();

  trace_method_handle(_masm, entry_name(ek));

  switch ((int) ek) {

  case _raise_exception:

    {

      // Not a real MH entry, but rather shared code for raising an

      // exception.  Since we use the compiled entry, arguments are

      // expected in compiler argument registers.

      assert(raise_exception_method(), "must be set");

      assert(raise_exception_method()->from_compiled_entry(), "method must be linked");

      __ mov(O5_savedSP, SP);  // Cut the stack back to where the caller started.

      Label L_no_method;

      // FIXME: fill in _raise_exception_method with a suitable java.lang.invoke method

      __ set(AddressLiteral((address) &_raise_exception_method), G5_method);

      __ ld_ptr(Address(G5_method, 0), G5_method);

      __ tst(G5_method);

      __ brx(Assembler::zero, false, Assembler::pn, L_no_method);

      __ delayed()->nop();

      const int jobject_oop_offset = 0;

      __ ld_ptr(Address(G5_method, jobject_oop_offset), G5_method);

      __ tst(G5_method);

      __ brx(Assembler::zero, false, Assembler::pn, L_no_method);

      __ delayed()->nop();

      __ verify_oop(G5_method);

      __ jump_indirect_to(G5_method_fce, O3_scratch);  // jump to compiled entry

      __ delayed()->nop();

      // Do something that is at least causes a valid throw from the interpreter.

      __ bind(L_no_method);

      __ unimplemented("call throw_WrongMethodType_entry");

    }

    break;

  case _invokestatic_mh:

  case _invokespecial_mh:

    {

      __ load_heap_oop(G3_mh_vmtarget, G5_method);  // target is a methodOop

      __ verify_oop(G5_method);

      // Same as TemplateTable::invokestatic or invokespecial,

      // minus the CP setup and profiling:

      if (ek == _invokespecial_mh) {

        // Must load & check the first argument before entering the target method.

        __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch);

        __ ld_ptr(__ argument_address(O0_argslot), G3_method_handle);

        __ null_check(G3_method_handle);

        __ verify_oop(G3_method_handle);

      }