/*

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

}

// stack walking support

frame MethodHandles::ricochet_frame_sender(const frame& fr, RegisterMap *map) {

  //RicochetFrame* f = RicochetFrame::from_frame(fr);

  // Cf. is_interpreted_frame path of frame::sender

  intptr_t* younger_sp = fr.sp();

  intptr_t* sp         = fr.sender_sp();

  map->make_integer_regs_unsaved();

  map->shift_window(sp, younger_sp);

  bool this_frame_adjusted_stack = true;  // I5_savedSP is live in this RF

  return frame(sp, younger_sp, this_frame_adjusted_stack);

}

void MethodHandles::ricochet_frame_oops_do(const frame& fr, OopClosure* blk, const RegisterMap* reg_map) {

  ResourceMark rm;

  RicochetFrame* f = RicochetFrame::from_frame(fr);

  // pick up the argument type descriptor:

  Thread* thread = Thread::current();

  Handle cookie(thread, f->compute_saved_args_layout(true, true));

  // process fixed part

  blk->do_oop((oop*)f->saved_target_addr());

  blk->do_oop((oop*)f->saved_args_layout_addr());

  // process variable arguments:

  if (cookie.is_null())  return;  // no arguments to describe

  // the cookie is actually the invokeExact method for my target

  // his argument signature is what I'm interested in

  assert(cookie->is_method(), "");

  methodHandle invoker(thread, methodOop(cookie()));

  assert(invoker->name() == vmSymbols::invokeExact_name(), "must be this kind of method");

  assert(!invoker->is_static(), "must have MH argument");

  int slot_count = invoker->size_of_parameters();

  assert(slot_count >= 1, "must include 'this'");

  intptr_t* base = f->saved_args_base();

  intptr_t* retval = NULL;

  if (f->has_return_value_slot())

    retval = f->return_value_slot_addr();

  int slot_num = slot_count - 1;

  intptr_t* loc = &base[slot_num];

  //blk->do_oop((oop*) loc);   // original target, which is irrelevant

  int arg_num = 0;

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

    if (ss.at_return_type())  continue;

    BasicType ptype = ss.type();

    if (ptype == T_ARRAY)  ptype = T_OBJECT; // fold all refs to T_OBJECT

    assert(ptype >= T_BOOLEAN && ptype <= T_OBJECT, "not array or void");

    slot_num -= type2size[ptype];

    loc = &base[slot_num];

    bool is_oop = (ptype == T_OBJECT && loc != retval);

    if (is_oop)  blk->do_oop((oop*)loc);

    arg_num += 1;

  }

  assert(slot_num == 0, "must have processed all the arguments");

}

// Ricochet Frames

const Register MethodHandles::RicochetFrame::L1_continuation      = L1;

const Register MethodHandles::RicochetFrame::L2_saved_target      = L2;

const Register MethodHandles::RicochetFrame::L3_saved_args_layout = L3;

const Register MethodHandles::RicochetFrame::L4_saved_args_base   = L4; // cf. Gargs = G4

const Register MethodHandles::RicochetFrame::L5_conversion        = L5;

#ifdef ASSERT

const Register MethodHandles::RicochetFrame::L0_magic_number_1    = L0;

#endif //ASSERT

oop MethodHandles::RicochetFrame::compute_saved_args_layout(bool read_cache, bool write_cache) {

  if (read_cache) {

    oop cookie = saved_args_layout();

    if (cookie != NULL)  return cookie;

  }

  oop target = saved_target();

  oop mtype  = java_lang_invoke_MethodHandle::type(target);

  oop mtform = java_lang_invoke_MethodType::form(mtype);

  oop cookie = java_lang_invoke_MethodTypeForm::vmlayout(mtform);

  if (write_cache)  {

    (*saved_args_layout_addr()) = cookie;

  }

  return cookie;

}

void MethodHandles::RicochetFrame::generate_ricochet_blob(MacroAssembler* _masm,

                                                          // output params:

                                                          int* bounce_offset,

                                                          int* exception_offset,

                                                          int* frame_size_in_words) {

  (*frame_size_in_words) = RicochetFrame::frame_size_in_bytes() / wordSize;

  address start = __ pc();

#ifdef ASSERT

  __ illtrap(0); __ illtrap(0); __ illtrap(0);

  // here's a hint of something special:

  __ set(MAGIC_NUMBER_1, G0);

  __ set(MAGIC_NUMBER_2, G0);

#endif //ASSERT

  __ illtrap(0);  // not reached

  // Return values are in registers.

  // L1_continuation contains a cleanup continuation we must return

  // to.

  (*bounce_offset) = __ pc() - start;

  BLOCK_COMMENT("ricochet_blob.bounce");

  if (VerifyMethodHandles)  RicochetFrame::verify_clean(_masm);

  trace_method_handle(_masm, "ricochet_blob.bounce");

  __ JMP(L1_continuation, 0);

  __ delayed()->nop();

  __ illtrap(0);

  DEBUG_ONLY(__ set(MAGIC_NUMBER_2, G0));

  (*exception_offset) = __ pc() - start;

  BLOCK_COMMENT("ricochet_blob.exception");

  // compare this to Interpreter::rethrow_exception_entry, which is parallel code

  // for example, see TemplateInterpreterGenerator::generate_throw_exception

  // Live registers in:

  //   Oexception  (O0): exception

  //   Oissuing_pc (O1): return address/pc that threw exception (ignored, always equal to bounce addr)

  __ verify_oop(Oexception);

  // Take down the frame.

  // Cf. InterpreterMacroAssembler::remove_activation.

  leave_ricochet_frame(_masm, /*recv_reg=*/ noreg, I5_savedSP, I7);

  // We are done with this activation frame; find out where to go next.

  // The continuation point will be an exception handler, which expects

  // the following registers set up:

  //

  // Oexception: exception

  // Oissuing_pc: the local call that threw exception

  // Other On: garbage

  // In/Ln:  the contents of the caller's register window

  //

  // We do the required restore at the last possible moment, because we

  // need to preserve some state across a runtime call.

  // (Remember that the caller activation is unknown--it might not be

  // interpreted, so things like Lscratch are useless in the caller.)

  __ mov(Oexception,  Oexception ->after_save());  // get exception in I0 so it will be on O0 after restore

  __ add(I7, frame::pc_return_offset, Oissuing_pc->after_save());  // likewise set I1 to a value local to the caller

  __ call_VM_leaf(L7_thread_cache,

                  CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address),

                  G2_thread, Oissuing_pc->after_save());

  // The caller's SP was adjusted upon method entry to accomodate

  // the callee's non-argument locals. Undo that adjustment.

  __ JMP(O0, 0);                         // return exception handler in caller

  __ delayed()->restore(I5_savedSP, G0, SP);

  // (same old exception object is already in Oexception; see above)

  // Note that an "issuing PC" is actually the next PC after the call

}

void MethodHandles::RicochetFrame::enter_ricochet_frame(MacroAssembler* _masm,

                                                        Register recv_reg,

                                                        Register argv_reg,

                                                        address return_handler) {

  // does not include the __ save()

  assert(argv_reg == Gargs, "");

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

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

  // Create the RicochetFrame.

  // Unlike on x86 we can store all required information in local

  // registers.

  BLOCK_COMMENT("push RicochetFrame {");

  __ set(ExternalAddress(return_handler),          L1_continuation);

  __ load_heap_oop(G3_mh_vmtarget,                 L2_saved_target);

  __ mov(G0,                                       L3_saved_args_layout);

  __ mov(Gargs,                                    L4_saved_args_base);

  __ lduw(G3_amh_conversion,                       L5_conversion);  // 32-bit field

  // I5, I6, I7 are already set up

  DEBUG_ONLY(__ set((int32_t) MAGIC_NUMBER_1,      L0_magic_number_1));

  BLOCK_COMMENT("} RicochetFrame");

}

void MethodHandles::RicochetFrame::leave_ricochet_frame(MacroAssembler* _masm,

                                                        Register recv_reg,

                                                        Register new_sp_reg,

                                                        Register sender_pc_reg) {

  assert(new_sp_reg == I5_savedSP, "exact_sender_sp already in place");

  assert(sender_pc_reg == I7, "in a fixed place");

  // does not include the __ ret() & __ restore()

  assert_different_registers(recv_reg, new_sp_reg, sender_pc_reg);

  // Take down the frame.

  // Cf. InterpreterMacroAssembler::remove_activation.

  BLOCK_COMMENT("end_ricochet_frame {");

  if (recv_reg->is_valid())

    __ mov(L2_saved_target, recv_reg);

  BLOCK_COMMENT("} end_ricochet_frame");

}

// Emit code to verify that FP is pointing at a valid ricochet frame.

#ifdef ASSERT

enum {

  ARG_LIMIT = 255, SLOP = 45,

  // use this parameter for checking for garbage stack movements:

  UNREASONABLE_STACK_MOVE = (ARG_LIMIT + SLOP)

  // the slop defends against false alarms due to fencepost errors

};

void MethodHandles::RicochetFrame::verify_clean(MacroAssembler* _masm) {

  // The stack should look like this:

  //    ... keep1 | dest=42 | keep2 | magic | handler | magic | recursive args | [RF]

  // Check various invariants.

  Register O7_temp = O7, O5_temp = O5;

  Label L_ok_1, L_ok_2, L_ok_3, L_ok_4;

  BLOCK_COMMENT("verify_clean {");

  // Magic numbers must check out:

  __ set((int32_t) MAGIC_NUMBER_1, O7_temp);

  __ cmp_and_br_short(O7_temp, L0_magic_number_1, Assembler::equal, Assembler::pt, L_ok_1);

  __ stop("damaged ricochet frame: MAGIC_NUMBER_1 not found");

  __ BIND(L_ok_1);

  // Arguments pointer must look reasonable:

#ifdef _LP64

  Register FP_temp = O5_temp;

  __ add(FP, STACK_BIAS, FP_temp);

#else

  Register FP_temp = FP;

#endif

  __ cmp_and_brx_short(L4_saved_args_base, FP_temp, Assembler::greaterEqualUnsigned, Assembler::pt, L_ok_2);

  __ stop("damaged ricochet frame: L4 < FP");

  __ BIND(L_ok_2);

  // Disable until we decide on it's fate

  // __ sub(L4_saved_args_base, UNREASONABLE_STACK_MOVE * Interpreter::stackElementSize, O7_temp);

  // __ cmp(O7_temp, FP_temp);

  // __ br(Assembler::lessEqualUnsigned, false, Assembler::pt, L_ok_3);

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

  // __ stop("damaged ricochet frame: (L4 - UNREASONABLE_STACK_MOVE) > FP");

  __ BIND(L_ok_3);

  extract_conversion_dest_type(_masm, L5_conversion, O7_temp);

  __ cmp_and_br_short(O7_temp, T_VOID, Assembler::equal, Assembler::pt, L_ok_4);

  extract_conversion_vminfo(_masm, L5_conversion, O5_temp);

  __ ld_ptr(L4_saved_args_base, __ argument_offset(O5_temp, O5_temp), O7_temp);

  __ cmp_and_brx_short(O7_temp, (int32_t) RETURN_VALUE_PLACEHOLDER, Assembler::equal, Assembler::pt, L_ok_4);

  __ stop("damaged ricochet frame: RETURN_VALUE_PLACEHOLDER not found");

  __ BIND(L_ok_4);

  BLOCK_COMMENT("} verify_clean");

}

#endif //ASSERT

void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_reg, Register temp_reg, Register temp2_reg) {

  if (VerifyMethodHandles)

    verify_klass(_masm, klass_reg, SystemDictionaryHandles::Class_klass(), temp_reg, temp2_reg,

                 "AMH argument is a Class");

  __ load_heap_oop(Address(klass_reg, java_lang_Class::klass_offset_in_bytes()), klass_reg);

}

void MethodHandles::load_conversion_vminfo(MacroAssembler* _masm, Address conversion_field_addr, Register reg) {

  assert(CONV_VMINFO_SHIFT == 0, "preshifted");

  assert(CONV_VMINFO_MASK == right_n_bits(BitsPerByte), "else change type of following load");

  __ ldub(conversion_field_addr.plus_disp(BytesPerInt - 1), reg);

}

void MethodHandles::extract_conversion_vminfo(MacroAssembler* _masm, Register conversion_field_reg, Register reg) {

  assert(CONV_VMINFO_SHIFT == 0, "preshifted");

  __ and3(conversion_field_reg, CONV_VMINFO_MASK, reg);

}

void MethodHandles::extract_conversion_dest_type(MacroAssembler* _masm, Register conversion_field_reg, Register reg) {

  __ srl(conversion_field_reg, CONV_DEST_TYPE_SHIFT, reg);

  __ and3(reg, 0x0F, reg);

}

void MethodHandles::load_stack_move(MacroAssembler* _masm,

                                    Address G3_amh_conversion,

                                    Register stack_move_reg) {

  BLOCK_COMMENT("load_stack_move {");

  __ ldsw(G3_amh_conversion, stack_move_reg);

  __ sra(stack_move_reg, CONV_STACK_MOVE_SHIFT, stack_move_reg);

#ifdef ASSERT

  if (VerifyMethodHandles) {

    Label L_ok, L_bad;

    int32_t stack_move_limit = 0x0800;  // extra-large

    __ cmp_and_br_short(stack_move_reg, stack_move_limit, Assembler::greaterEqual, Assembler::pn, L_bad);

    __ cmp(stack_move_reg, -stack_move_limit);

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

    __ delayed()->nop();

    __ BIND(L_bad);

    __ stop("load_stack_move of garbage value");

    __ BIND(L_ok);

  }

#endif

  BLOCK_COMMENT("} load_stack_move");

}

#ifdef ASSERT

void MethodHandles::RicochetFrame::verify() const {

  assert(magic_number_1() == MAGIC_NUMBER_1, "");

  if (!Universe::heap()->is_gc_active()) {

    if (saved_args_layout() != NULL) {

      assert(saved_args_layout()->is_method(), "must be valid oop");

    }

    if (saved_target() != NULL) {

      assert(java_lang_invoke_MethodHandle::is_instance(saved_target()), "checking frame value");

    }

  }

  int conv_op = adapter_conversion_op(conversion());

  assert(conv_op == java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS ||

         conv_op == java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS ||

         conv_op == java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF,

         "must be a sane conversion");

  if (has_return_value_slot()) {

    assert(*return_value_slot_addr() == RETURN_VALUE_PLACEHOLDER, "");

  }

}

void MethodHandles::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 {");

  __ cmp_and_brx_short(Gargs, argslot_reg, Assembler::greaterUnsigned, Assembler::pn, L_bad);

  __ add(FP, STACK_BIAS, temp_reg);  // STACK_BIAS is zero on !_LP64

  __ cmp_and_brx_short(argslot_reg, temp_reg, Assembler::lessEqualUnsigned, Assembler::pt, L_ok);

  __ BIND(L_bad);

  __ stop(error_message);

  __ BIND(L_ok);

  BLOCK_COMMENT("} verify_argslot");

}

void MethodHandles::verify_argslots(MacroAssembler* _masm,

                                    RegisterOrConstant arg_slots,

                                    Register arg_slot_base_reg,

                                    Register temp_reg,

                                    Register temp2_reg,

                                    bool negate_argslots,

                                    const char* error_message) {

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

  Label L_ok, L_bad;

  BLOCK_COMMENT("verify_argslots {");

  if (negate_argslots) {

    if (arg_slots.is_constant()) {

      arg_slots = -1 * arg_slots.as_constant();

    } else {

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

      arg_slots = temp_reg;

    }

  }

  __ add(arg_slot_base_reg, __ argument_offset(arg_slots, temp_reg), temp_reg);

  __ add(FP, STACK_BIAS, temp2_reg);  // STACK_BIAS is zero on !_LP64

  __ cmp_and_brx_short(temp_reg, temp2_reg, Assembler::greaterUnsigned, Assembler::pn, L_bad);

  // Gargs points to the first word so adjust by BytesPerWord

  __ add(arg_slot_base_reg, BytesPerWord, temp_reg);

  __ cmp_and_brx_short(Gargs, temp_reg, Assembler::lessEqualUnsigned, Assembler::pt, L_ok);

  __ BIND(L_bad);

  __ stop(error_message);

  __ BIND(L_ok);

  BLOCK_COMMENT("} verify_argslots");

}

// Make sure that arg_slots has the same sign as the given direction.

// If (and only if) arg_slots is a assembly-time constant, also allow it to be zero.

void MethodHandles::verify_stack_move(MacroAssembler* _masm,

                                      RegisterOrConstant arg_slots, int direction) {

  enum { UNREASONABLE_STACK_MOVE = 256 * 4 };  // limit of 255 arguments

  bool allow_zero = arg_slots.is_constant();

  if (direction == 0) { direction = +1; allow_zero = true; }

  assert(stack_move_unit() == -1, "else add extra checks here");

  if (arg_slots.is_register()) {

    Label L_ok, L_bad;

    BLOCK_COMMENT("verify_stack_move {");

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

    // __ br(Assembler::notZero, false, Assembler::pn, L_bad);

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

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

    if (direction > 0) {

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

      __ delayed()->nop();

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

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

      __ delayed()->nop();

    } else {

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

      __ delayed()->nop();

      __ cmp(arg_slots.as_register(), (int32_t) -UNREASONABLE_STACK_MOVE);

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

      __ delayed()->nop();

    }

    __ BIND(L_bad);

    if (direction > 0)

      __ stop("assert arg_slots > 0");

    else

      __ stop("assert arg_slots < 0");

    __ BIND(L_ok);

    BLOCK_COMMENT("} verify_stack_move");

  } else {

    intptr_t size = arg_slots.as_constant();

    if (direction < 0)  size = -size;

    assert(size >= 0, "correct direction of constant move");

    assert(size < UNREASONABLE_STACK_MOVE, "reasonable size of constant move");

  }

}

void MethodHandles::verify_klass(MacroAssembler* _masm,

                                 Register obj_reg, KlassHandle klass,

                                 Register temp_reg, Register temp2_reg,

                                 const char* error_message) {

  oop* klass_addr = klass.raw_value();

  assert(klass_addr >= SystemDictionaryHandles::Object_klass().raw_value() &&

         klass_addr <= SystemDictionaryHandles::Long_klass().raw_value(),

         "must be one of the SystemDictionaryHandles");

  Label L_ok, L_bad;

  BLOCK_COMMENT("verify_klass {");

  __ verify_oop(obj_reg);

  __ br_null_short(obj_reg, Assembler::pn, L_bad);

  __ load_klass(obj_reg, temp_reg);

  __ set(ExternalAddress(klass_addr), temp2_reg);

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

  __ cmp_and_brx_short(temp_reg, temp2_reg, Assembler::equal, Assembler::pt, L_ok);

  intptr_t super_check_offset = klass->super_check_offset();

  __ ld_ptr(Address(temp_reg, super_check_offset), temp_reg);

  __ set(ExternalAddress(klass_addr), temp2_reg);