/*

 * Copyright 2000-2009 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_LIRAssembler_x86.cpp.incl"

// These masks are used to provide 128-bit aligned bitmasks to the XMM

// instructions, to allow sign-masking or sign-bit flipping.  They allow

// fast versions of NegF/NegD and AbsF/AbsD.

// Note: 'double' and 'long long' have 32-bits alignment on x86.

static jlong* double_quadword(jlong *adr, jlong lo, jlong hi) {

  // Use the expression (adr)&(~0xF) to provide 128-bits aligned address

  // of 128-bits operands for SSE instructions.

  jlong *operand = (jlong*)(((long)adr)&((long)(~0xF)));

  // Store the value to a 128-bits operand.

  operand[0] = lo;

  operand[1] = hi;

  return operand;

}

// Buffer for 128-bits masks used by SSE instructions.

static jlong fp_signmask_pool[(4+1)*2]; // 4*128bits(data) + 128bits(alignment)

// Static initialization during VM startup.

static jlong *float_signmask_pool  = double_quadword(&fp_signmask_pool[1*2], CONST64(0x7FFFFFFF7FFFFFFF), CONST64(0x7FFFFFFF7FFFFFFF));

static jlong *double_signmask_pool = double_quadword(&fp_signmask_pool[2*2], CONST64(0x7FFFFFFFFFFFFFFF), CONST64(0x7FFFFFFFFFFFFFFF));

static jlong *float_signflip_pool  = double_quadword(&fp_signmask_pool[3*2], CONST64(0x8000000080000000), CONST64(0x8000000080000000));

static jlong *double_signflip_pool = double_quadword(&fp_signmask_pool[4*2], CONST64(0x8000000000000000), CONST64(0x8000000000000000));

NEEDS_CLEANUP // remove this definitions ?

const Register IC_Klass    = rax;   // where the IC klass is cached

const Register SYNC_header = rax;   // synchronization header

const Register SHIFT_count = rcx;   // where count for shift operations must be

#define __ _masm->

static void select_different_registers(Register preserve,

                                       Register extra,

                                       Register &tmp1,

                                       Register &tmp2) {

  if (tmp1 == preserve) {

    assert_different_registers(tmp1, tmp2, extra);

    tmp1 = extra;

  } else if (tmp2 == preserve) {

    assert_different_registers(tmp1, tmp2, extra);

    tmp2 = extra;

  }

  assert_different_registers(preserve, tmp1, tmp2);

}

static void select_different_registers(Register preserve,

                                       Register extra,

                                       Register &tmp1,

                                       Register &tmp2,

                                       Register &tmp3) {

  if (tmp1 == preserve) {

    assert_different_registers(tmp1, tmp2, tmp3, extra);

    tmp1 = extra;

  } else if (tmp2 == preserve) {

    assert_different_registers(tmp1, tmp2, tmp3, extra);

    tmp2 = extra;

  } else if (tmp3 == preserve) {

    assert_different_registers(tmp1, tmp2, tmp3, extra);

    tmp3 = extra;

  }

  assert_different_registers(preserve, tmp1, tmp2, tmp3);

}

bool LIR_Assembler::is_small_constant(LIR_Opr opr) {

  if (opr->is_constant()) {

    LIR_Const* constant = opr->as_constant_ptr();

    switch (constant->type()) {

      case T_INT: {

        return true;

      }

      default:

        return false;

    }

  }

  return false;

}

LIR_Opr LIR_Assembler::receiverOpr() {

  return FrameMap::receiver_opr;

}

LIR_Opr LIR_Assembler::incomingReceiverOpr() {

  return receiverOpr();

}

LIR_Opr LIR_Assembler::osrBufferPointer() {

  return FrameMap::as_pointer_opr(receiverOpr()->as_register());

}

//--------------fpu register translations-----------------------

address LIR_Assembler::float_constant(float f) {

  address const_addr = __ float_constant(f);

  if (const_addr == NULL) {

    bailout("const section overflow");

    return __ code()->consts()->start();

  } else {

    return const_addr;

  }

}

address LIR_Assembler::double_constant(double d) {

  address const_addr = __ double_constant(d);

  if (const_addr == NULL) {

    bailout("const section overflow");

    return __ code()->consts()->start();

  } else {

    return const_addr;

  }

}

void LIR_Assembler::set_24bit_FPU() {

  __ fldcw(ExternalAddress(StubRoutines::addr_fpu_cntrl_wrd_24()));

}

void LIR_Assembler::reset_FPU() {

  __ fldcw(ExternalAddress(StubRoutines::addr_fpu_cntrl_wrd_std()));

}

void LIR_Assembler::fpop() {

  __ fpop();

}

void LIR_Assembler::fxch(int i) {

  __ fxch(i);

}

void LIR_Assembler::fld(int i) {

  __ fld_s(i);

}

void LIR_Assembler::ffree(int i) {

  __ ffree(i);

}

void LIR_Assembler::breakpoint() {

  __ int3();

}

void LIR_Assembler::push(LIR_Opr opr) {

  if (opr->is_single_cpu()) {

    __ push_reg(opr->as_register());

  } else if (opr->is_double_cpu()) {

    NOT_LP64(__ push_reg(opr->as_register_hi()));

    __ push_reg(opr->as_register_lo());

  } else if (opr->is_stack()) {

    __ push_addr(frame_map()->address_for_slot(opr->single_stack_ix()));

  } else if (opr->is_constant()) {

    LIR_Const* const_opr = opr->as_constant_ptr();

    if (const_opr->type() == T_OBJECT) {

      __ push_oop(const_opr->as_jobject());

    } else if (const_opr->type() == T_INT) {

      __ push_jint(const_opr->as_jint());

    } else {

      ShouldNotReachHere();

    }

  } else {

    ShouldNotReachHere();

  }

}

void LIR_Assembler::pop(LIR_Opr opr) {

  if (opr->is_single_cpu()) {

    __ pop_reg(opr->as_register());

  } else {

    ShouldNotReachHere();

  }

}

bool LIR_Assembler::is_literal_address(LIR_Address* addr) {

  return addr->base()->is_illegal() && addr->index()->is_illegal();

}

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

Address LIR_Assembler::as_Address(LIR_Address* addr) {

  return as_Address(addr, rscratch1);

}

Address LIR_Assembler::as_Address(LIR_Address* addr, Register tmp) {

  if (addr->base()->is_illegal()) {

    assert(addr->index()->is_illegal(), "must be illegal too");

    AddressLiteral laddr((address)addr->disp(), relocInfo::none);

    if (! __ reachable(laddr)) {

      __ movptr(tmp, laddr.addr());

      Address res(tmp, 0);

      return res;

    } else {

      return __ as_Address(laddr);

    }

  }

  Register base = addr->base()->as_pointer_register();

  if (addr->index()->is_illegal()) {

    return Address( base, addr->disp());

  } else if (addr->index()->is_cpu_register()) {

    Register index = addr->index()->as_pointer_register();

    return Address(base, index, (Address::ScaleFactor) addr->scale(), addr->disp());

  } else if (addr->index()->is_constant()) {

    intptr_t addr_offset = (addr->index()->as_constant_ptr()->as_jint() << addr->scale()) + addr->disp();

    assert(Assembler::is_simm32(addr_offset), "must be");

    return Address(base, addr_offset);

  } else {

    Unimplemented();

    return Address();

  }

}

Address LIR_Assembler::as_Address_hi(LIR_Address* addr) {

  Address base = as_Address(addr);

  return Address(base._base, base._index, base._scale, base._disp + BytesPerWord);

}

Address LIR_Assembler::as_Address_lo(LIR_Address* addr) {

  return as_Address(addr);

}

void LIR_Assembler::osr_entry() {

  offsets()->set_value(CodeOffsets::OSR_Entry, code_offset());

  BlockBegin* osr_entry = compilation()->hir()->osr_entry();

  ValueStack* entry_state = osr_entry->state();

  int number_of_locks = entry_state->locks_size();

  // we jump here if osr happens with the interpreter

  // state set up to continue at the beginning of the

  // loop that triggered osr - in particular, we have

  // the following registers setup:

  //

  // rcx: osr buffer

  //

  // build frame

  ciMethod* m = compilation()->method();

  __ build_frame(initial_frame_size_in_bytes());

  // OSR buffer is

  //

  // locals[nlocals-1..0]

  // monitors[0..number_of_locks]

  //

  // locals is a direct copy of the interpreter frame so in the osr buffer

  // so first slot in the local array is the last local from the interpreter

  // and last slot is local[0] (receiver) from the interpreter

  //

  // Similarly with locks. The first lock slot in the osr buffer is the nth lock

  // from the interpreter frame, the nth lock slot in the osr buffer is 0th lock

  // in the interpreter frame (the method lock if a sync method)

  // Initialize monitors in the compiled activation.

  //   rcx: pointer to osr buffer

  //

  // All other registers are dead at this point and the locals will be

  // copied into place by code emitted in the IR.

  Register OSR_buf = osrBufferPointer()->as_pointer_register();

  { assert(frame::interpreter_frame_monitor_size() == BasicObjectLock::size(), "adjust code below");

    int monitor_offset = BytesPerWord * method()->max_locals() +

      (BasicObjectLock::size() * BytesPerWord) * (number_of_locks - 1);

    for (int i = 0; i < number_of_locks; i++) {

      int slot_offset = monitor_offset - ((i * BasicObjectLock::size()) * BytesPerWord);

#ifdef ASSERT

      // verify the interpreter's monitor has a non-null object

      {

        Label L;

        __ cmpptr(Address(OSR_buf, slot_offset + BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD);

        __ jcc(Assembler::notZero, L);

        __ stop("locked object is NULL");

        __ bind(L);

      }

#endif

      __ movptr(rbx, Address(OSR_buf, slot_offset + BasicObjectLock::lock_offset_in_bytes()));

      __ movptr(frame_map()->address_for_monitor_lock(i), rbx);

      __ movptr(rbx, Address(OSR_buf, slot_offset + BasicObjectLock::obj_offset_in_bytes()));

      __ movptr(frame_map()->address_for_monitor_object(i), rbx);

    }

  }

}

// inline cache check; done before the frame is built.

int LIR_Assembler::check_icache() {

  Register receiver = FrameMap::receiver_opr->as_register();

  Register ic_klass = IC_Klass;

  const int ic_cmp_size = LP64_ONLY(10) NOT_LP64(9);

  if (!VerifyOops) {

    // insert some nops so that the verified entry point is aligned on CodeEntryAlignment

    while ((__ offset() + ic_cmp_size) % CodeEntryAlignment != 0) {

      __ nop();

    }

  }

  int offset = __ offset();

  __ inline_cache_check(receiver, IC_Klass);

  assert(__ offset() % CodeEntryAlignment == 0 || VerifyOops, "alignment must be correct");

  if (VerifyOops) {

    // force alignment after the cache check.

    // It's been verified to be aligned if !VerifyOops

    __ align(CodeEntryAlignment);

  }

  return offset;

}

void LIR_Assembler::jobject2reg_with_patching(Register reg, CodeEmitInfo* info) {

  jobject o = NULL;

  PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_klass_id);

  __ movoop(reg, o);

  patching_epilog(patch, lir_patch_normal, reg, info);

}

void LIR_Assembler::monitorexit(LIR_Opr obj_opr, LIR_Opr lock_opr, Register new_hdr, int monitor_no, Register exception) {

  if (exception->is_valid()) {

    // preserve exception

    // note: the monitor_exit runtime call is a leaf routine

    //       and cannot block => no GC can happen

    // The slow case (MonitorAccessStub) uses the first two stack slots

    // ([esp+0] and [esp+4]), therefore we store the exception at [esp+8]

    __ movptr (Address(rsp, 2*wordSize), exception);

  }

  Register obj_reg  = obj_opr->as_register();

  Register lock_reg = lock_opr->as_register();

  // setup registers (lock_reg must be rax, for lock_object)

  assert(obj_reg != SYNC_header && lock_reg != SYNC_header, "rax, must be available here");

  Register hdr = lock_reg;

  assert(new_hdr == SYNC_header, "wrong register");

  lock_reg = new_hdr;

  // compute pointer to BasicLock

  Address lock_addr = frame_map()->address_for_monitor_lock(monitor_no);

  __ lea(lock_reg, lock_addr);

  // unlock object

  MonitorAccessStub* slow_case = new MonitorExitStub(lock_opr, true, monitor_no);

  // _slow_case_stubs->append(slow_case);

  // temporary fix: must be created after exceptionhandler, therefore as call stub

  _slow_case_stubs->append(slow_case);

  if (UseFastLocking) {

    // try inlined fast unlocking first, revert to slow locking if it fails

    // note: lock_reg points to the displaced header since the displaced header offset is 0!

    assert(BasicLock::displaced_header_offset_in_bytes() == 0, "lock_reg must point to the displaced header");

    __ unlock_object(hdr, obj_reg, lock_reg, *slow_case->entry());

  } else {

    // always do slow unlocking

    // note: the slow unlocking code could be inlined here, however if we use

    //       slow unlocking, speed doesn't matter anyway and this solution is

    //       simpler and requires less duplicated code - additionally, the

    //       slow unlocking code is the same in either case which simplifies

    //       debugging

    __ jmp(*slow_case->entry());

  }

  // done

  __ bind(*slow_case->continuation());

  if (exception->is_valid()) {

    // restore exception

    __ movptr (exception, Address(rsp, 2 * wordSize));

  }

}

// This specifies the rsp decrement needed to build the frame

int LIR_Assembler::initial_frame_size_in_bytes() {

  // if rounding, must let FrameMap know!

  // The frame_map records size in slots (32bit word)

  // subtract two words to account for return address and link

  return (frame_map()->framesize() - (2*VMRegImpl::slots_per_word))  * VMRegImpl::stack_slot_size;

}

void LIR_Assembler::emit_exception_handler() {

  // if the last instruction is a call (typically to do a throw which

  // is coming at the end after block reordering) the return address

  // must still point into the code area in order to avoid assertion

  // failures when searching for the corresponding bci => add a nop

  // (was bug 5/14/1999 - gri)

  __ nop();

  // generate code for exception handler

  address handler_base = __ start_a_stub(exception_handler_size);

  if (handler_base == NULL) {

    // not enough space left for the handler

    bailout("exception handler overflow");

    return;

  }

#ifdef ASSERT

  int offset = code_offset();

#endif // ASSERT

  compilation()->offsets()->set_value(CodeOffsets::Exceptions, code_offset());

  // if the method does not have an exception handler, then there is

  // no reason to search for one

    // the exception oop and pc are in rax, and rdx

    // no other registers need to be preserved, so invalidate them

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

    // check that there is really an exception

    __ verify_not_null_oop(rax);

    // search an exception handler (rax: exception oop, rdx: throwing pc)

    __ call(RuntimeAddress(Runtime1::entry_for(Runtime1::handle_exception_nofpu_id)));

    // if the call returns here, then the exception handler for particular

    // exception doesn't exist -> unwind activation and forward exception to caller

  }

  // the exception oop is in rax,

  // no other registers need to be preserved, so invalidate them

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

  // check that there is really an exception

  __ verify_not_null_oop(rax);

  // unlock the receiver/klass if necessary

  // rax,: exception

  ciMethod* method = compilation()->method();

  if (method->is_synchronized() && GenerateSynchronizationCode) {

    monitorexit(FrameMap::rbx_oop_opr, FrameMap::rcx_opr, SYNC_header, 0, rax);

  }

  // unwind activation and forward exception to caller

  // rax,: exception

  __ jump(RuntimeAddress(Runtime1::entry_for(Runtime1::unwind_exception_id)));

  assert(code_offset() - offset <= exception_handler_size, "overflow");

  __ end_a_stub();

}

void LIR_Assembler::emit_deopt_handler() {

  // if the last instruction is a call (typically to do a throw which

  // is coming at the end after block reordering) the return address

  // must still point into the code area in order to avoid assertion

  // failures when searching for the corresponding bci => add a nop

  // (was bug 5/14/1999 - gri)

  __ nop();

  // generate code for exception handler

  address handler_base = __ start_a_stub(deopt_handler_size);

  if (handler_base == NULL) {

    // not enough space left for the handler

    bailout("deopt handler overflow");

    return;

  }

#ifdef ASSERT

  int offset = code_offset();

#endif // ASSERT

  compilation()->offsets()->set_value(CodeOffsets::Deopt, code_offset());

  InternalAddress here(__ pc());

  __ pushptr(here.addr());

  __ jump(RuntimeAddress(SharedRuntime::deopt_blob()->unpack()));

  assert(code_offset() - offset <= deopt_handler_size, "overflow");

  __ end_a_stub();

}

// This is the fast version of java.lang.String.compare; it has not

// OSR-entry and therefore, we generate a slow version for OSR's

void LIR_Assembler::emit_string_compare(LIR_Opr arg0, LIR_Opr arg1, LIR_Opr dst, CodeEmitInfo* info) {

  __ movptr (rbx, rcx); // receiver is in rcx

  __ movptr (rax, arg1->as_register());

  // Get addresses of first characters from both Strings

  __ movptr (rsi, Address(rax, java_lang_String::value_offset_in_bytes()));

  __ movptr (rcx, Address(rax, java_lang_String::offset_offset_in_bytes()));