// stack walking support

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

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

  if (map->update_map())

    frame::update_map_with_saved_link(map, &f->_sender_link);

  return frame(f->extended_sender_sp(), f->exact_sender_sp(), f->sender_link(), f->sender_pc());

}

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

  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;

  intptr_t* loc = &base[slot_num -= 1];

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

    loc = &base[slot_num -= type2size[ptype]];

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

}

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

  oop cookie = NULL;

  if (read_cache) {

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

  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* frame_size_in_words,

                                                          int* bounce_offset,

                                                          int* exception_offset) {

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

  address start = __ pc();

  __ hlt(); __ hlt(); __ hlt();

  // here's a hint of something special:

  __ push(MAGIC_NUMBER_1);

  __ push(MAGIC_NUMBER_2);

#endif //ASSERT

  __ hlt();  // not reached

  // A return PC has just been popped from the stack.

  // Return values are in registers.

  // The ebp points into the RicochetFrame, which 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(frame_address(continuation_offset_in_bytes()));

  __ hlt();

  DEBUG_ONLY(__ push(MAGIC_NUMBER_2));

  (*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:

  //   rax: exception

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

  __ verify_oop(rax);

  // no need to empty_FPU_stack or reinit_heapbase, since caller frame will do the same if needed

  // Take down the frame.

  // Cf. InterpreterMacroAssembler::remove_activation.

  leave_ricochet_frame(_masm, /*rcx_recv=*/ noreg,

                       saved_last_sp_register(),

                       /*sender_pc_reg=*/ rdx);

  // In between activations - previous activation type unknown yet

  // compute continuation point - the continuation point expects the

  // following registers set up:

  //

  // rax: exception

  // rdx: return address/pc that threw exception

  // rsp: expression stack of caller

  // rbp: ebp of caller

  __ push(rax);                                  // save exception

  __ push(rdx);                                  // save return address

  Register thread_reg = LP64_ONLY(r15_thread) NOT_LP64(rdi);

  NOT_LP64(__ get_thread(thread_reg));

  __ call_VM_leaf(CAST_FROM_FN_PTR(address,

                                   SharedRuntime::exception_handler_for_return_address),

                  thread_reg, rdx);

  __ mov(rbx, rax);                              // save exception handler

  __ pop(rdx);                                   // restore return address

  __ pop(rax);                                   // restore exception

  __ jmp(rbx);                                   // jump to exception

                                                 // handler of caller

}

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

                                                        Register rcx_recv,

                                                        Register rax_argv,

                                                        address return_handler,

                                                        Register rbx_temp) {

  const Register saved_last_sp = saved_last_sp_register();

  Address rcx_mh_vmtarget(    rcx_recv, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes() );

  Address rcx_amh_conversion( rcx_recv, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes() );

  // Push the RicochetFrame a word at a time.

  // This creates something similar to an interpreter frame.

  // Cf. TemplateInterpreterGenerator::generate_fixed_frame.

  BLOCK_COMMENT("push RicochetFrame {");

  DEBUG_ONLY(int rfo = (int) sizeof(RicochetFrame));

  assert((rfo -= wordSize) == RicochetFrame::sender_pc_offset_in_bytes(), "");

#define RF_FIELD(push_value, name)                                      \

  { push_value;                                                         \

    assert((rfo -= wordSize) == RicochetFrame::name##_offset_in_bytes(), ""); }

  RF_FIELD(__ push(rbp),                   sender_link);

  RF_FIELD(__ push(saved_last_sp),         exact_sender_sp);  // rsi/r13

  RF_FIELD(__ pushptr(rcx_amh_conversion), conversion);

  RF_FIELD(__ push(rax_argv),              saved_args_base);   // can be updated if args are shifted

  RF_FIELD(__ push((int32_t) NULL_WORD),   saved_args_layout); // cache for GC layout cookie

  if (UseCompressedOops) {

    __ load_heap_oop(rbx_temp, rcx_mh_vmtarget);

    RF_FIELD(__ push(rbx_temp),            saved_target);

  } else {

    RF_FIELD(__ pushptr(rcx_mh_vmtarget),  saved_target);

  }

  __ lea(rbx_temp, ExternalAddress(return_handler));

  RF_FIELD(__ push(rbx_temp),              continuation);

#undef RF_FIELD

  assert(rfo == 0, "fully initialized the RicochetFrame");

  // compute new frame pointer:

  __ lea(rbp, Address(rsp, RicochetFrame::sender_link_offset_in_bytes()));

  // Push guard word #1 in debug mode.

  DEBUG_ONLY(__ push((int32_t) RicochetFrame::MAGIC_NUMBER_1));

  // For debugging, leave behind an indication of which stub built this frame.

  DEBUG_ONLY({ Label L; __ call(L, relocInfo::none); __ bind(L); });

  BLOCK_COMMENT("} RicochetFrame");

}

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

                                                        Register rcx_recv,

                                                        Register new_sp_reg,

                                                        Register sender_pc_reg) {

  assert_different_registers(rcx_recv, new_sp_reg, sender_pc_reg);

  const Register saved_last_sp = saved_last_sp_register();

  // Take down the frame.

  // Cf. InterpreterMacroAssembler::remove_activation.

  BLOCK_COMMENT("end_ricochet_frame {");

  // TO DO: If (exact_sender_sp - extended_sender_sp) > THRESH, compact the frame down.

  // This will keep stack in bounds even with unlimited tailcalls, each with an adapter.

  if (rcx_recv->is_valid())

    __ movptr(rcx_recv,    RicochetFrame::frame_address(RicochetFrame::saved_target_offset_in_bytes()));

  __ movptr(sender_pc_reg, RicochetFrame::frame_address(RicochetFrame::sender_pc_offset_in_bytes()));

  __ movptr(saved_last_sp, RicochetFrame::frame_address(RicochetFrame::exact_sender_sp_offset_in_bytes()));

  __ movptr(rbp,           RicochetFrame::frame_address(RicochetFrame::sender_link_offset_in_bytes()));

  __ mov(rsp, new_sp_reg);

  BLOCK_COMMENT("} end_ricochet_frame");

}

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

#ifdef ASSERT

enum {

  ARG_LIMIT = 255, SLOP = 4,

  // 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 | RF | magic | handler | magic | recursive args |

  // Check various invariants.

  verify_offsets();

  Register rdi_temp = rdi;

  Register rcx_temp = rcx;

  { __ push(rdi_temp); __ push(rcx_temp); }

#define UNPUSH_TEMPS \

  { __ pop(rcx_temp);  __ pop(rdi_temp); }

  Address magic_number_1_addr  = RicochetFrame::frame_address(RicochetFrame::magic_number_1_offset_in_bytes());

  Address magic_number_2_addr  = RicochetFrame::frame_address(RicochetFrame::magic_number_2_offset_in_bytes());

  Address continuation_addr    = RicochetFrame::frame_address(RicochetFrame::continuation_offset_in_bytes());

  Address conversion_addr      = RicochetFrame::frame_address(RicochetFrame::conversion_offset_in_bytes());

  Address saved_args_base_addr = RicochetFrame::frame_address(RicochetFrame::saved_args_base_offset_in_bytes());

  Label L_bad, L_ok;

  BLOCK_COMMENT("verify_clean {");

  // Magic numbers must check out:

  __ cmpptr(magic_number_1_addr, (int32_t) MAGIC_NUMBER_1);

  __ jcc(Assembler::notEqual, L_bad);

  __ cmpptr(magic_number_2_addr, (int32_t) MAGIC_NUMBER_2);

  __ jcc(Assembler::notEqual, L_bad);

  // Arguments pointer must look reasonable:

  __ movptr(rcx_temp, saved_args_base_addr);

  __ cmpptr(rcx_temp, rbp);

  __ jcc(Assembler::below, L_bad);

  __ subptr(rcx_temp, UNREASONABLE_STACK_MOVE * Interpreter::stackElementSize);

  __ cmpptr(rcx_temp, rbp);

  __ jcc(Assembler::above, L_bad);

  load_conversion_dest_type(_masm, rdi_temp, conversion_addr);

  __ cmpl(rdi_temp, T_VOID);

  __ jcc(Assembler::equal, L_ok);

  __ movptr(rcx_temp, saved_args_base_addr);

  load_conversion_vminfo(_masm, rdi_temp, conversion_addr);

  __ cmpptr(Address(rcx_temp, rdi_temp, Interpreter::stackElementScale()),

            (int32_t) RETURN_VALUE_PLACEHOLDER);

  __ jcc(Assembler::equal, L_ok);

  __ BIND(L_bad);

  UNPUSH_TEMPS;

  __ stop("damaged ricochet frame");

  __ BIND(L_ok);

  UNPUSH_TEMPS;

  BLOCK_COMMENT("} verify_clean");

#undef UNPUSH_TEMPS

}

#endif //ASSERT

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

  if (VerifyMethodHandles)

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

                 "AMH argument is a Class");

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

}

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

  int bits   = BitsPerByte;

  int offset = (CONV_VMINFO_SHIFT / bits);

  int shift  = (CONV_VMINFO_SHIFT % bits);

  __ load_unsigned_byte(reg, conversion_field_addr.plus_disp(offset));

  assert(CONV_VMINFO_MASK == right_n_bits(bits - shift), "else change type of previous load");

  assert(shift == 0, "no shift needed");

}

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

  int bits   = BitsPerByte;

  int offset = (CONV_DEST_TYPE_SHIFT / bits);

  int shift  = (CONV_DEST_TYPE_SHIFT % bits);

  __ load_unsigned_byte(reg, conversion_field_addr.plus_disp(offset));

  assert(CONV_TYPE_MASK == right_n_bits(bits - shift), "else change type of previous load");

  __ shrl(reg, shift);

  DEBUG_ONLY(int conv_type_bits = (int) exact_log2(CONV_TYPE_MASK+1));

  assert((shift + conv_type_bits) == bits, "left justified in byte");

}

void MethodHandles::load_stack_move(MacroAssembler* _masm,

                                    Register rdi_stack_move,

                                    Register rcx_amh,

                                    bool might_be_negative) {

  BLOCK_COMMENT("load_stack_move");

  Address rcx_amh_conversion(rcx_amh, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes());

  __ movl(rdi_stack_move, rcx_amh_conversion);

  __ sarl(rdi_stack_move, CONV_STACK_MOVE_SHIFT);

#ifdef _LP64

  if (might_be_negative) {

    // clean high bits of stack motion register (was loaded as an int)

    __ movslq(rdi_stack_move, rdi_stack_move);

  }

#endif //_LP64

  if (VerifyMethodHandles) {

    Label L_ok, L_bad;

    int32_t stack_move_limit = 0x4000;  // extra-large

    __ cmpptr(rdi_stack_move, stack_move_limit);

    __ jcc(Assembler::greaterEqual, L_bad);

    __ cmpptr(rdi_stack_move, -stack_move_limit);

    __ jcc(Assembler::greater, L_ok);

    __ bind(L_bad);

    __ stop("load_stack_move of garbage value");

    __ BIND(L_ok);

  }

}

#ifndef PRODUCT

void MethodHandles::RicochetFrame::verify_offsets() {

  // Check compatibility of this struct with the more generally used offsets of class frame:

  int ebp_off = sender_link_offset_in_bytes();  // offset from struct base to local rbp value

  assert(ebp_off + wordSize*frame::interpreter_frame_method_offset      == saved_args_base_offset_in_bytes(), "");

  assert(ebp_off + wordSize*frame::interpreter_frame_last_sp_offset     == conversion_offset_in_bytes(), "");

  assert(ebp_off + wordSize*frame::interpreter_frame_sender_sp_offset   == exact_sender_sp_offset_in_bytes(), "");

  // These last two have to be exact:

  assert(ebp_off + wordSize*frame::link_offset                          == sender_link_offset_in_bytes(), "");

  assert(ebp_off + wordSize*frame::return_addr_offset                   == sender_pc_offset_in_bytes(), "");

}

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

  verify_offsets();

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

  assert(magic_number_2() == MAGIC_NUMBER_2, "");

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

  }

}

#endif //PRODUCT

#ifdef ASSERT

void MethodHandles::verify_argslot(MacroAssembler* _masm,

                                   Register argslot_reg,

                                   const char* error_message) {

  BLOCK_COMMENT("verify_argslot {");

  __ BIND(L_ok);

void MethodHandles::verify_argslots(MacroAssembler* _masm,

                                    RegisterOrConstant arg_slots,

                                    Register arg_slot_base_reg,

                                    bool negate_argslots,

                                    const char* error_message) {

  // Verify that [argslot..argslot+size) lies within (rsp, rbp).

  Label L_ok, L_bad;

  Register rdi_temp = rdi;

  BLOCK_COMMENT("verify_argslots {");

  __ push(rdi_temp);

  if (negate_argslots) {

    if (arg_slots.is_constant()) {

      arg_slots = -1 * arg_slots.as_constant();

    } else {

      __ movptr(rdi_temp, arg_slots);

      __ negptr(rdi_temp);

      arg_slots = rdi_temp;

    }

  }

  __ lea(rdi_temp, Address(arg_slot_base_reg, arg_slots, Interpreter::stackElementScale()));

  __ cmpptr(rdi_temp, rbp);

  __ pop(rdi_temp);

  __ jcc(Assembler::above, L_bad);

  __ cmpptr(rsp, arg_slot_base_reg);

  __ jcc(Assembler::below, 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) {

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

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

    // jcc(Assembler::notZero, L_bad);

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

    if (direction > 0) {

      __ jcc(allow_zero ? Assembler::less : Assembler::lessEqual, L_bad);

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

      __ jcc(Assembler::less, L_ok);

    } else {

      __ jcc(allow_zero ? Assembler::greater : Assembler::greaterEqual, L_bad);

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

      __ jcc(Assembler::greater, L_ok);

    }

    __ bind(L_bad);

    if (direction > 0)