/*

 * Copyright 1999-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_c1_Runtime1_x86.cpp.incl"

// Implementation of StubAssembler

int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, int args_size) {

  // setup registers

  const Register thread = rdi; // is callee-saved register (Visual C++ calling conventions)

  assert(!(oop_result1->is_valid() || oop_result2->is_valid()) || oop_result1 != oop_result2, "registers must be different");

  assert(oop_result1 != thread && oop_result2 != thread, "registers must be different");

  assert(args_size >= 0, "illegal args_size");

  set_num_rt_args(1 + args_size);

  // push java thread (becomes first argument of C function)

  get_thread(thread);

  pushl(thread);

  set_last_Java_frame(thread, noreg, rbp, NULL);

  // do the call

  call(RuntimeAddress(entry));

  int call_offset = offset();

  // verify callee-saved register

#ifdef ASSERT

  guarantee(thread != rax, "change this code");

  pushl(rax);

  { Label L;

    get_thread(rax);

    cmpl(thread, rax);

    jcc(Assembler::equal, L);

    int3();

    stop("StubAssembler::call_RT: rdi not callee saved?");

    bind(L);

  }

  popl(rax);

#endif

  reset_last_Java_frame(thread, true, false);

  // discard thread and arguments

  addl(rsp, (1 + args_size)*BytesPerWord);

  // check for pending exceptions

  { Label L;

    cmpl(Address(thread, Thread::pending_exception_offset()), NULL_WORD);

    jcc(Assembler::equal, L);

    // exception pending => remove activation and forward to exception handler

    movl(rax, Address(thread, Thread::pending_exception_offset()));

    // make sure that the vm_results are cleared

    if (oop_result1->is_valid()) {

      movl(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);

    }

    if (oop_result2->is_valid()) {

      movl(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);

    }

    if (frame_size() == no_frame_size) {

      leave();

      jump(RuntimeAddress(StubRoutines::forward_exception_entry()));

    } else if (_stub_id == Runtime1::forward_exception_id) {

      should_not_reach_here();

    } else {

      jump(RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));

    }

    bind(L);

  }

  // get oop results if there are any and reset the values in the thread

  if (oop_result1->is_valid()) {

    movl(oop_result1, Address(thread, JavaThread::vm_result_offset()));

    movl(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);

    verify_oop(oop_result1);

  }

  if (oop_result2->is_valid()) {

    movl(oop_result2, Address(thread, JavaThread::vm_result_2_offset()));

    movl(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);

    verify_oop(oop_result2);

  }

  return call_offset;

}

int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1) {

  pushl(arg1);

  return call_RT(oop_result1, oop_result2, entry, 1);

}

int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2) {

  pushl(arg2);

  pushl(arg1);

  return call_RT(oop_result1, oop_result2, entry, 2);

}

int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2, Register arg3) {

  pushl(arg3);

  pushl(arg2);

  pushl(arg1);

  return call_RT(oop_result1, oop_result2, entry, 3);

}

// Implementation of StubFrame

class StubFrame: public StackObj {

 private:

  StubAssembler* _sasm;

 public:

  StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments);

  void load_argument(int offset_in_words, Register reg);

  ~StubFrame();

};

#define __ _sasm->

StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments) {

  _sasm = sasm;

  __ set_info(name, must_gc_arguments);

  __ enter();

}

// load parameters that were stored with LIR_Assembler::store_parameter

// Note: offsets for store_parameter and load_argument must match

void StubFrame::load_argument(int offset_in_words, Register reg) {

  // rbp, + 0: link

  //     + 1: return address

  //     + 2: argument with offset 0

  //     + 3: argument with offset 1

  //     + 4: ...

  __ movl(reg, Address(rbp, (offset_in_words + 2) * BytesPerWord));

}

StubFrame::~StubFrame() {

  __ leave();

  __ ret(0);

}

#undef __

// Implementation of Runtime1

#define __ sasm->

const int float_regs_as_doubles_size_in_words = 16;

const int xmm_regs_as_doubles_size_in_words = 16;

// Stack layout for saving/restoring  all the registers needed during a runtime

// call (this includes deoptimization)

// Note: note that users of this frame may well have arguments to some runtime

// while these values are on the stack. These positions neglect those arguments

// but the code in save_live_registers will take the argument count into

// account.

//

enum reg_save_layout {

  dummy1,

  dummy2,

  // Two temps to be used as needed by users of save/restore callee registers

  temp_2_off,

  temp_1_off,

  xmm_regs_as_doubles_off,

  float_regs_as_doubles_off = xmm_regs_as_doubles_off + xmm_regs_as_doubles_size_in_words,

  fpu_state_off = float_regs_as_doubles_off + float_regs_as_doubles_size_in_words,

  fpu_state_end_off = fpu_state_off + FPUStateSizeInWords,

  marker = fpu_state_end_off,

  extra_space_offset,

  rdi_off = extra_space_offset,

  rsi_off,

  rbp_off,

  rsp_off,

  rbx_off,

  rdx_off,

  rcx_off,

  rax_off,

  saved_rbp_off,

  return_off,

  reg_save_frame_size,  // As noted: neglects any parameters to runtime

  // equates

  // illegal instruction handler

  continue_dest_off = temp_1_off,

  // deoptimization equates

  fp0_off = float_regs_as_doubles_off, // slot for java float/double return value

  xmm0_off = xmm_regs_as_doubles_off,  // slot for java float/double return value

  deopt_type = temp_2_off,             // slot for type of deopt in progress

  ret_type = temp_1_off                // slot for return type

};

// Save off registers which might be killed by calls into the runtime.

// Tries to smart of about FP registers.  In particular we separate

// saving and describing the FPU registers for deoptimization since we

// have to save the FPU registers twice if we describe them and on P4

// saving FPU registers which don't contain anything appears

// expensive.  The deopt blob is the only thing which needs to

// describe FPU registers.  In all other cases it should be sufficient

// to simply save their current value.

static OopMap* generate_oop_map(StubAssembler* sasm, int num_rt_args,

                                bool save_fpu_registers = true) {

  int frame_size = reg_save_frame_size + num_rt_args; // args + thread

  sasm->set_frame_size(frame_size);

  // record saved value locations in an OopMap

  // locations are offsets from sp after runtime call; num_rt_args is number of arguments in call, including thread

  OopMap* map = new OopMap(frame_size, 0);

  map->set_callee_saved(VMRegImpl::stack2reg(rax_off + num_rt_args), rax->as_VMReg());

  map->set_callee_saved(VMRegImpl::stack2reg(rcx_off + num_rt_args), rcx->as_VMReg());

  map->set_callee_saved(VMRegImpl::stack2reg(rdx_off + num_rt_args), rdx->as_VMReg());

  map->set_callee_saved(VMRegImpl::stack2reg(rbx_off + num_rt_args), rbx->as_VMReg());

  map->set_callee_saved(VMRegImpl::stack2reg(rsi_off + num_rt_args), rsi->as_VMReg());

  map->set_callee_saved(VMRegImpl::stack2reg(rdi_off + num_rt_args), rdi->as_VMReg());

  if (save_fpu_registers) {

    if (UseSSE < 2) {

      int fpu_off = float_regs_as_doubles_off;

      for (int n = 0; n < FrameMap::nof_fpu_regs; n++) {

        VMReg fpu_name_0 = FrameMap::fpu_regname(n);

        map->set_callee_saved(VMRegImpl::stack2reg(fpu_off +     num_rt_args), fpu_name_0);

        // %%% This is really a waste but we'll keep things as they were for now

        if (true) {

          map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + 1 + num_rt_args), fpu_name_0->next());

        }

        fpu_off += 2;

      }

      assert(fpu_off == fpu_state_off, "incorrect number of fpu stack slots");

    }

    if (UseSSE >= 2) {

      int xmm_off = xmm_regs_as_doubles_off;

      for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {

        VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();

        map->set_callee_saved(VMRegImpl::stack2reg(xmm_off +     num_rt_args), xmm_name_0);

        // %%% This is really a waste but we'll keep things as they were for now

        if (true) {

          map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + 1 + num_rt_args), xmm_name_0->next());

        }

        xmm_off += 2;

      }

      assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");

    } else if (UseSSE == 1) {

      int xmm_off = xmm_regs_as_doubles_off;

      for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {

        VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();

        map->set_callee_saved(VMRegImpl::stack2reg(xmm_off +     num_rt_args), xmm_name_0);

        xmm_off += 2;

      }

      assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");

    }

  }

  return map;

}

static OopMap* save_live_registers(StubAssembler* sasm, int num_rt_args,

                                   bool save_fpu_registers = true) {

  __ block_comment("save_live_registers");

  int frame_size = reg_save_frame_size + num_rt_args; // args + thread

  // frame_size = round_to(frame_size, 4);

  sasm->set_frame_size(frame_size);

  __ pushad();         // integer registers

  // assert(float_regs_as_doubles_off % 2 == 0, "misaligned offset");

  // assert(xmm_regs_as_doubles_off % 2 == 0, "misaligned offset");

  __ subl(rsp, extra_space_offset * wordSize);

#ifdef ASSERT

  __ movl(Address(rsp, marker * wordSize), 0xfeedbeef);

#endif

  if (save_fpu_registers) {

    if (UseSSE < 2) {

      // save FPU stack

      __ fnsave(Address(rsp, fpu_state_off * wordSize));

      __ fwait();

#ifdef ASSERT

      Label ok;

      __ cmpw(Address(rsp, fpu_state_off * wordSize), StubRoutines::fpu_cntrl_wrd_std());

      __ jccb(Assembler::equal, ok);

      __ stop("corrupted control word detected");

      __ bind(ok);

#endif

      // Reset the control word to guard against exceptions being unmasked

      // since fstp_d can cause FPU stack underflow exceptions.  Write it

      // into the on stack copy and then reload that to make sure that the

      // current and future values are correct.

      __ movw(Address(rsp, fpu_state_off * wordSize), StubRoutines::fpu_cntrl_wrd_std());

      __ frstor(Address(rsp, fpu_state_off * wordSize));

      // Save the FPU registers in de-opt-able form

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord +  0));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord +  8));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 16));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 24));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 32));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 40));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 48));

      __ fstp_d(Address(rsp, float_regs_as_doubles_off * BytesPerWord + 56));

    }

    if (UseSSE >= 2) {

      // save XMM registers

      // XMM registers can contain float or double values, but this is not known here,

      // so always save them as doubles.

      // note that float values are _not_ converted automatically, so for float values

      // the second word contains only garbage data.

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize +  0), xmm0);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize +  8), xmm1);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 16), xmm2);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 24), xmm3);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 32), xmm4);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 40), xmm5);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 48), xmm6);

      __ movdbl(Address(rsp, xmm_regs_as_doubles_off * wordSize + 56), xmm7);

    } else if (UseSSE == 1) {

      // save XMM registers as float because double not supported without SSE2

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize +  0), xmm0);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize +  8), xmm1);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 16), xmm2);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 24), xmm3);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 32), xmm4);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 40), xmm5);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 48), xmm6);

      __ movflt(Address(rsp, xmm_regs_as_doubles_off * wordSize + 56), xmm7);

    }

  }

  // FPU stack must be empty now

  __ verify_FPU(0, "save_live_registers");

  return generate_oop_map(sasm, num_rt_args, save_fpu_registers);

}

static void restore_fpu(StubAssembler* sasm, bool restore_fpu_registers = true) {

  if (restore_fpu_registers) {

    if (UseSSE >= 2) {

      // restore XMM registers

      __ movdbl(xmm0, Address(rsp, xmm_regs_as_doubles_off * wordSize +  0));

      __ movdbl(xmm1, Address(rsp, xmm_regs_as_doubles_off * wordSize +  8));

      __ movdbl(xmm2, Address(rsp, xmm_regs_as_doubles_off * wordSize + 16));

      __ movdbl(xmm3, Address(rsp, xmm_regs_as_doubles_off * wordSize + 24));

      __ movdbl(xmm4, Address(rsp, xmm_regs_as_doubles_off * wordSize + 32));

      __ movdbl(xmm5, Address(rsp, xmm_regs_as_doubles_off * wordSize + 40));

      __ movdbl(xmm6, Address(rsp, xmm_regs_as_doubles_off * wordSize + 48));

      __ movdbl(xmm7, Address(rsp, xmm_regs_as_doubles_off * wordSize + 56));

    } else if (UseSSE == 1) {

      // restore XMM registers

      __ movflt(xmm0, Address(rsp, xmm_regs_as_doubles_off * wordSize +  0));

      __ movflt(xmm1, Address(rsp, xmm_regs_as_doubles_off * wordSize +  8));

      __ movflt(xmm2, Address(rsp, xmm_regs_as_doubles_off * wordSize + 16));

      __ movflt(xmm3, Address(rsp, xmm_regs_as_doubles_off * wordSize + 24));

      __ movflt(xmm4, Address(rsp, xmm_regs_as_doubles_off * wordSize + 32));

      __ movflt(xmm5, Address(rsp, xmm_regs_as_doubles_off * wordSize + 40));

      __ movflt(xmm6, Address(rsp, xmm_regs_as_doubles_off * wordSize + 48));

      __ movflt(xmm7, Address(rsp, xmm_regs_as_doubles_off * wordSize + 56));

    }

    if (UseSSE < 2) {

      __ frstor(Address(rsp, fpu_state_off * wordSize));

    } else {

      // check that FPU stack is really empty

      __ verify_FPU(0, "restore_live_registers");

    }

  } else {

    // check that FPU stack is really empty

    __ verify_FPU(0, "restore_live_registers");

  }

#ifdef ASSERT

  {

    Label ok;

    __ cmpl(Address(rsp, marker * wordSize), 0xfeedbeef);

    __ jcc(Assembler::equal, ok);

    __ stop("bad offsets in frame");

    __ bind(ok);

  }

#endif

  __ addl(rsp, extra_space_offset * wordSize);

}

static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers = true) {

  __ block_comment("restore_live_registers");

  restore_fpu(sasm, restore_fpu_registers);

  __ popad();

}

static void restore_live_registers_except_rax(StubAssembler* sasm, bool restore_fpu_registers = true) {

  __ block_comment("restore_live_registers_except_rax");

  restore_fpu(sasm, restore_fpu_registers);

  __ popl(rdi);

  __ popl(rsi);

  __ popl(rbp);

  __ popl(rbx); // skip this value

  __ popl(rbx);

  __ popl(rdx);

  __ popl(rcx);

  __ addl(rsp, 4);

}

void Runtime1::initialize_pd() {

  // nothing to do

}

// target: the entry point of the method that creates and posts the exception oop

// has_argument: true if the exception needs an argument (passed on stack because registers must be preserved)

OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {

  // preserve all registers

  int num_rt_args = has_argument ? 2 : 1;

  OopMap* oop_map = save_live_registers(sasm, num_rt_args);

  // now all registers are saved and can be used freely

  // verify that no old value is used accidentally

  __ invalidate_registers(true, true, true, true, true, true);

  // registers used by this stub

  const Register temp_reg = rbx;

  // load argument for exception that is passed as an argument into the stub

  if (has_argument) {

    __ movl(temp_reg, Address(rbp, 2*BytesPerWord));

    __ pushl(temp_reg);

  }

  int call_offset = __ call_RT(noreg, noreg, target, num_rt_args - 1);

  OopMapSet* oop_maps = new OopMapSet();

  oop_maps->add_gc_map(call_offset, oop_map);

  __ stop("should not reach here");

  return oop_maps;

}

void Runtime1::generate_handle_exception(StubAssembler *sasm, OopMapSet* oop_maps, OopMap* oop_map, bool save_fpu_registers) {

  // incoming parameters

  const Register exception_oop = rax;

  const Register exception_pc = rdx;

  // other registers used in this stub

  const Register real_return_addr = rbx;

  const Register thread = rdi;

  __ block_comment("generate_handle_exception");

#ifdef TIERED

  // C2 can leave the fpu stack dirty

  if (UseSSE < 2 ) {

    __ empty_FPU_stack();

  }

#endif // TIERED

  // verify that only rax, and rdx is valid at this time

  __ invalidate_registers(false, true, true, false, true, true);

  // verify that rax, contains a valid exception

  __ verify_not_null_oop(exception_oop);

  // load address of JavaThread object for thread-local data

  __ get_thread(thread);

#ifdef ASSERT

  // check that fields in JavaThread for exception oop and issuing pc are

  // empty before writing to them

  Label oop_empty;

  __ cmpl(Address(thread, JavaThread::exception_oop_offset()), 0);

  __ jcc(Assembler::equal, oop_empty);

  __ stop("exception oop already set");

  __ bind(oop_empty);

  Label pc_empty;

  __ cmpl(Address(thread, JavaThread::exception_pc_offset()), 0);

  __ jcc(Assembler::equal, pc_empty);

  __ stop("exception pc already set");

  __ bind(pc_empty);

#endif

  // save exception oop and issuing pc into JavaThread

  // (exception handler will load it from here)

  __ movl(Address(thread, JavaThread::exception_oop_offset()), exception_oop);

  __ movl(Address(thread, JavaThread::exception_pc_offset()), exception_pc);