/*

 * 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 "incls/_precompiled.incl"

#include "incls/_methodHandles_sparc.cpp.incl"

#define __ _masm->

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: sender SP (must preserve)

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

  // G5_method:  invoke methodOop; becomes method type.

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

  // O0, O1: garbage temps, blown away

  Register O0_argslot = O0;

  Register O1_scratch = O1;

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

  Label wrong_method_type;

  __ bind(wrong_method_type);

  __ 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 into G5_method_type

  {

    Register tem = G5_method;

    assert(tem == G5_method_type, "yes, it's the same register");

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

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

    }

  }

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

  __ load_heap_oop(Address(G5_method_type, __ delayed_value(java_dyn_MethodType::form_offset_in_bytes, O1_scratch)),        O0_argslot);

  __ ldsw(         Address(O0_argslot,     __ delayed_value(java_dyn_MethodTypeForm::vmslots_offset_in_bytes, O1_scratch)), O0_argslot);

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

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

  __ jump_to_method_handle_entry(G3_method_handle, O1_scratch);

  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;

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

}

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

  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;

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

}

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

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

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

}

#ifndef PRODUCT

extern "C" void print_method_handle(oop mh);

void trace_method_handle_stub(const char* adaptername,

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

  print_method_handle(mh);

}

#endif // PRODUCT

// which conversion op types are implemented here?

int MethodHandles::adapter_conversion_ops_supported_mask() {

  return ((1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_ONLY)

         |(1<<sun_dyn_AdapterMethodHandle::OP_RETYPE_RAW)

         |(1<<sun_dyn_AdapterMethodHandle::OP_CHECK_CAST)

         |(1<<sun_dyn_AdapterMethodHandle::OP_PRIM_TO_PRIM)

         |(1<<sun_dyn_AdapterMethodHandle::OP_REF_TO_PRIM)

         |(1<<sun_dyn_AdapterMethodHandle::OP_SWAP_ARGS)

         |(1<<sun_dyn_AdapterMethodHandle::OP_ROT_ARGS)

         |(1<<sun_dyn_AdapterMethodHandle::OP_DUP_ARGS)

         |(1<<sun_dyn_AdapterMethodHandle::OP_DROP_ARGS)

         //|(1<<sun_dyn_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)

  Register O0_argslot = O0;

  Register O1_scratch = O1;

  Register O2_scratch = O2;

  Register O3_scratch = O3;

  Register G5_index   = G5;

  guarantee(java_dyn_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 G3_mh_vmtarget(   G3_method_handle, java_dyn_MethodHandle::vmtarget_offset_in_bytes());

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

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

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

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

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

  Address G3_amh_conversion(G3_method_handle, sun_dyn_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();

  switch ((int) ek) {

  case _raise_exception:

    {

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

      // exception.  Extra local arguments are passed in scratch

      // registers, as required type in O3, failing object (or NULL)

      // in O2, failing bytecode type in O1.

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

      // Push arguments as if coming from the interpreter.

      Register O0_scratch = O0_argslot;

      int stackElementSize = Interpreter::stackElementSize;

      // Make space on the stack for the arguments and set Gargs

      // correctly.

      __ sub(SP, 4*stackElementSize, SP);  // Keep stack aligned.

      __ add(SP, (frame::varargs_offset)*wordSize - 1*Interpreter::stackElementSize + STACK_BIAS + BytesPerWord, Gargs);

      // void raiseException(int code, Object actual, Object required)

      __ st(    O1_scratch, Address(Gargs, 2*stackElementSize));  // code

      __ st_ptr(O2_scratch, Address(Gargs, 1*stackElementSize));  // actual

      __ st_ptr(O3_scratch, Address(Gargs, 0*stackElementSize));  // required

      Label no_method;

      // FIXME: fill in _raise_exception_method with a suitable sun.dyn 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, no_method);

      __ delayed()->nop();

      int jobject_oop_offset = 0;

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

      __ tst(G5_method);

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

      __ delayed()->nop();

      __ verify_oop(G5_method);

      __ jump_indirect_to(G5_method_fie, O1_scratch);

      __ delayed()->nop();

      // If we get here, the Java runtime did not do its job of creating the exception.

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

      __ bind(no_method);

      __ unimplemented("_raise_exception no method");

    }

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

      }

      __ jump_indirect_to(G5_method_fie, O1_scratch);

      __ delayed()->nop();

    }

    break;

  case _invokevirtual_mh:

    {

      // Same as TemplateTable::invokevirtual,

      // minus the CP setup and profiling:

      // Pick out the vtable index and receiver offset from the MH,

      // and then we can discard it:

      __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch);

      __ ldsw(G3_dmh_vmindex, G5_index);

      // Note:  The verifier allows us to ignore G3_mh_vmtarget.

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

      __ null_check(G3_method_handle, oopDesc::klass_offset_in_bytes());

      // Get receiver klass:

      Register O0_klass = O0_argslot;

      __ load_klass(G3_method_handle, O0_klass);

      __ verify_oop(O0_klass);

      // Get target methodOop & entry point:

      const int base = instanceKlass::vtable_start_offset() * wordSize;

      assert(vtableEntry::size() * wordSize == wordSize, "adjust the scaling in the code below");

      __ sll_ptr(G5_index, LogBytesPerWord, G5_index);

      __ add(O0_klass, G5_index, O0_klass);

      Address vtable_entry_addr(O0_klass, base + vtableEntry::method_offset_in_bytes());

      __ ld_ptr(vtable_entry_addr, G5_method);

      __ verify_oop(G5_method);

      __ jump_indirect_to(G5_method_fie, O1_scratch);

      __ delayed()->nop();

    }

    break;

  case _invokeinterface_mh:

    {

      // Same as TemplateTable::invokeinterface,

      // minus the CP setup and profiling:

      __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch);

      Register O1_intf  = O1_scratch;

      __ load_heap_oop(G3_mh_vmtarget, O1_intf);

      __ ldsw(G3_dmh_vmindex, G5_index);

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

      __ null_check(G3_method_handle, oopDesc::klass_offset_in_bytes());

      // Get receiver klass:

      Register O0_klass = O0_argslot;

      __ load_klass(G3_method_handle, O0_klass);

      __ verify_oop(O0_klass);

      // Get interface:

      Label no_such_interface;

      __ verify_oop(O1_intf);

      __ lookup_interface_method(O0_klass, O1_intf,

                                 // Note: next two args must be the same:

                                 G5_index, G5_method,

                                 O2_scratch,