/*

 * 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/_templateTable_x86_64.cpp.incl"

#define __ _masm->

// Platform-dependent initialization

void TemplateTable::pd_initialize() {

  // No amd64 specific initialization

}

// Address computation: local variables

static inline Address iaddress(int n) {

  return Address(r14, Interpreter::local_offset_in_bytes(n));

}

static inline Address laddress(int n) {

  return iaddress(n + 1);

}

static inline Address faddress(int n) {

  return iaddress(n);

}

static inline Address daddress(int n) {

  return laddress(n);

}

static inline Address aaddress(int n) {

  return iaddress(n);

}

static inline Address iaddress(Register r) {

  return Address(r14, r, Address::times_8, Interpreter::value_offset_in_bytes());

}

static inline Address laddress(Register r) {

  return Address(r14, r, Address::times_8, Interpreter::local_offset_in_bytes(1));

}

static inline Address faddress(Register r) {

  return iaddress(r);

}

static inline Address daddress(Register r) {

  return laddress(r);

}

static inline Address aaddress(Register r) {

  return iaddress(r);

}

static inline Address at_rsp() {

  return Address(rsp, 0);

}

// At top of Java expression stack which may be different than esp().  It

// isn't for category 1 objects.

static inline Address at_tos   () {

  return Address(rsp,  Interpreter::expr_offset_in_bytes(0));

}

static inline Address at_tos_p1() {

  return Address(rsp,  Interpreter::expr_offset_in_bytes(1));

}

static inline Address at_tos_p2() {

  return Address(rsp,  Interpreter::expr_offset_in_bytes(2));

}

static inline Address at_tos_p3() {

  return Address(rsp,  Interpreter::expr_offset_in_bytes(3));

}

// Condition conversion

static Assembler::Condition j_not(TemplateTable::Condition cc) {

  switch (cc) {

  case TemplateTable::equal        : return Assembler::notEqual;

  case TemplateTable::not_equal    : return Assembler::equal;

  case TemplateTable::less         : return Assembler::greaterEqual;

  case TemplateTable::less_equal   : return Assembler::greater;

  case TemplateTable::greater      : return Assembler::lessEqual;

  case TemplateTable::greater_equal: return Assembler::less;

  }

  ShouldNotReachHere();

  return Assembler::zero;

}

// Miscelaneous helper routines

Address TemplateTable::at_bcp(int offset) {

  assert(_desc->uses_bcp(), "inconsistent uses_bcp information");

  return Address(r13, offset);

}

void TemplateTable::patch_bytecode(Bytecodes::Code bytecode, Register bc,

                                   Register scratch,

                                   bool load_bc_into_scratch/*=true*/) {

  if (!RewriteBytecodes) {

    return;

  }

  // the pair bytecodes have already done the load.

  if (load_bc_into_scratch) {

    __ movl(bc, bytecode);

  }

  Label patch_done;

  if (JvmtiExport::can_post_breakpoint()) {

    Label fast_patch;

    // if a breakpoint is present we can't rewrite the stream directly

    __ movzbl(scratch, at_bcp(0));

    __ cmpl(scratch, Bytecodes::_breakpoint);

    __ jcc(Assembler::notEqual, fast_patch);

    __ get_method(scratch);

    // Let breakpoint table handling rewrite to quicker bytecode

    __ call_VM(noreg,

               CAST_FROM_FN_PTR(address,

                                InterpreterRuntime::set_original_bytecode_at),

               scratch, r13, bc);

#ifndef ASSERT

    __ jmpb(patch_done);

    __ bind(fast_patch);

  }

#else

    __ jmp(patch_done);

    __ bind(fast_patch);

  }

  Label okay;

  __ load_unsigned_byte(scratch, at_bcp(0));

  __ cmpl(scratch, (int) Bytecodes::java_code(bytecode));

  __ jcc(Assembler::equal, okay);

  __ cmpl(scratch, bc);

  __ jcc(Assembler::equal, okay);

  __ stop("patching the wrong bytecode");

  __ bind(okay);

#endif

  // patch bytecode

  __ movb(at_bcp(0), bc);

  __ bind(patch_done);

}

// Individual instructions

void TemplateTable::nop() {

  transition(vtos, vtos);

  // nothing to do

}

void TemplateTable::shouldnotreachhere() {

  transition(vtos, vtos);

  __ stop("shouldnotreachhere bytecode");

}

void TemplateTable::aconst_null() {

  transition(vtos, atos);

  __ xorl(rax, rax);

}

void TemplateTable::iconst(int value) {

  transition(vtos, itos);

  if (value == 0) {

    __ xorl(rax, rax);

  } else {

    __ movl(rax, value);

  }

}

void TemplateTable::lconst(int value) {

  transition(vtos, ltos);

  if (value == 0) {

    __ xorl(rax, rax);

  } else {

    __ movl(rax, value);

  }

}

void TemplateTable::fconst(int value) {

  transition(vtos, ftos);

  static float one = 1.0f, two = 2.0f;

  switch (value) {

  case 0:

    __ xorps(xmm0, xmm0);

    break;

  case 1:

    __ movflt(xmm0, ExternalAddress((address) &one));

    break;

  case 2:

    __ movflt(xmm0, ExternalAddress((address) &two));

    break;

  default:

    ShouldNotReachHere();

    break;

  }

}

void TemplateTable::dconst(int value) {

  transition(vtos, dtos);

  static double one = 1.0;

  switch (value) {

  case 0:

    __ xorpd(xmm0, xmm0);

    break;

  case 1:

    __ movdbl(xmm0, ExternalAddress((address) &one));

    break;

  default:

    ShouldNotReachHere();

    break;

  }

}

void TemplateTable::bipush() {

  transition(vtos, itos);

  __ load_signed_byte(rax, at_bcp(1));

}

void TemplateTable::sipush() {

  transition(vtos, itos);

  __ load_unsigned_word(rax, at_bcp(1));

  __ bswapl(rax);

  __ sarl(rax, 16);

}

void TemplateTable::ldc(bool wide) {

  transition(vtos, vtos);

  Label call_ldc, notFloat, notClass, Done;

  if (wide) {

    __ get_unsigned_2_byte_index_at_bcp(rbx, 1);

  } else {

    __ load_unsigned_byte(rbx, at_bcp(1));

  }

  __ get_cpool_and_tags(rcx, rax);

  const int base_offset = constantPoolOopDesc::header_size() * wordSize;

  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;

  // get type

  __ movzbl(rdx, Address(rax, rbx, Address::times_1, tags_offset));

  // unresolved string - get the resolved string

  __ cmpl(rdx, JVM_CONSTANT_UnresolvedString);

  __ jccb(Assembler::equal, call_ldc);

  // unresolved class - get the resolved class

  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass);

  __ jccb(Assembler::equal, call_ldc);

  // unresolved class in error state - call into runtime to throw the error

  // from the first resolution attempt

  __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError);

  __ jccb(Assembler::equal, call_ldc);

  // resolved class - need to call vm to get java mirror of the class

  __ cmpl(rdx, JVM_CONSTANT_Class);

  __ jcc(Assembler::notEqual, notClass);

  __ bind(call_ldc);

  __ movl(c_rarg1, wide);

  call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);

  __ push_ptr(rax);

  __ verify_oop(rax);

  __ jmp(Done);

  __ bind(notClass);

  __ cmpl(rdx, JVM_CONSTANT_Float);

  __ jccb(Assembler::notEqual, notFloat);

  // ftos

  __ movflt(xmm0, Address(rcx, rbx, Address::times_8, base_offset));

  __ push_f();

  __ jmp(Done);

  __ bind(notFloat);

#ifdef ASSERT

  {

    Label L;

    __ cmpl(rdx, JVM_CONSTANT_Integer);

    __ jcc(Assembler::equal, L);

    __ cmpl(rdx, JVM_CONSTANT_String);

    __ jcc(Assembler::equal, L);

    __ stop("unexpected tag type in ldc");

    __ bind(L);

  }

#endif

  // atos and itos

  Label isOop;

  __ cmpl(rdx, JVM_CONSTANT_Integer);

  __ jcc(Assembler::notEqual, isOop);

  __ movl(rax, Address(rcx, rbx, Address::times_8, base_offset));

  __ push_i(rax);

  __ jmp(Done);

  __ bind(isOop);

  __ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));

  __ push_ptr(rax);

  if (VerifyOops) {

    __ verify_oop(rax);

  }

  __ bind(Done);

}

void TemplateTable::ldc2_w() {

  transition(vtos, vtos);

  Label Long, Done;

  __ get_unsigned_2_byte_index_at_bcp(rbx, 1);

  __ get_cpool_and_tags(rcx, rax);

  const int base_offset = constantPoolOopDesc::header_size() * wordSize;

  const int tags_offset = typeArrayOopDesc::header_size(T_BYTE) * wordSize;

  // get type

  __ cmpb(Address(rax, rbx, Address::times_1, tags_offset),

          JVM_CONSTANT_Double);

  __ jccb(Assembler::notEqual, Long);

  // dtos

  __ movdbl(xmm0, Address(rcx, rbx, Address::times_8, base_offset));

  __ push_d();

  __ jmpb(Done);

  __ bind(Long);

  // ltos

  __ movq(rax, Address(rcx, rbx, Address::times_8, base_offset));

  __ push_l();

  __ bind(Done);

}

void TemplateTable::locals_index(Register reg, int offset) {

  __ load_unsigned_byte(reg, at_bcp(offset));

  __ negq(reg);

  if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2

}

void TemplateTable::iload() {

  transition(vtos, itos);

  if (RewriteFrequentPairs) {

    Label rewrite, done;

    const Register bc = c_rarg3;

    assert(rbx != bc, "register damaged");

    // get next byte

    __ load_unsigned_byte(rbx,

                          at_bcp(Bytecodes::length_for(Bytecodes::_iload)));

    // if _iload, wait to rewrite to iload2.  We only want to rewrite the

    // last two iloads in a pair.  Comparing against fast_iload means that

    // the next bytecode is neither an iload or a caload, and therefore

    // an iload pair.

    __ cmpl(rbx, Bytecodes::_iload);

    __ jcc(Assembler::equal, done);

    __ cmpl(rbx, Bytecodes::_fast_iload);

    __ movl(bc, Bytecodes::_fast_iload2);

    __ jccb(Assembler::equal, rewrite);

    // if _caload, rewrite to fast_icaload

    __ cmpl(rbx, Bytecodes::_caload);

    __ movl(bc, Bytecodes::_fast_icaload);

    __ jccb(Assembler::equal, rewrite);

    // rewrite so iload doesn't check again.

    __ movl(bc, Bytecodes::_fast_iload);

    // rewrite

    // bc: fast bytecode

    __ bind(rewrite);

    patch_bytecode(Bytecodes::_iload, bc, rbx, false);

    __ bind(done);

  }

  // Get the local value into tos

  locals_index(rbx);

  __ movl(rax, iaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::fast_iload2() {

  transition(vtos, itos);

  locals_index(rbx);

  __ movl(rax, iaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

  __ push(itos);

  locals_index(rbx, 3);

  __ movl(rax, iaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::fast_iload() {

  transition(vtos, itos);

  locals_index(rbx);

  __ movl(rax, iaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::lload() {

  transition(vtos, ltos);

  locals_index(rbx);

  __ movq(rax, laddress(rbx));

  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));

}

void TemplateTable::fload() {

  transition(vtos, ftos);

  locals_index(rbx);

  __ movflt(xmm0, faddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::dload() {

  transition(vtos, dtos);

  locals_index(rbx);

  __ movdbl(xmm0, daddress(rbx));

  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));

}

void TemplateTable::aload() {

  transition(vtos, atos);

  locals_index(rbx);

  __ movq(rax, aaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagReference, rbx));

}

void TemplateTable::locals_index_wide(Register reg) {

  __ movl(reg, at_bcp(2));

  __ bswapl(reg);

  __ shrl(reg, 16);

  __ negq(reg);

  if (TaggedStackInterpreter) __ shlq(reg, 1);  // index = index*2

}

void TemplateTable::wide_iload() {

  transition(vtos, itos);

  locals_index_wide(rbx);

  __ movl(rax, iaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::wide_lload() {

  transition(vtos, ltos);

  locals_index_wide(rbx);

  __ movq(rax, laddress(rbx));

  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));

}

void TemplateTable::wide_fload() {

  transition(vtos, ftos);

  locals_index_wide(rbx);

  __ movflt(xmm0, faddress(rbx));

  debug_only(__ verify_local_tag(frame::TagValue, rbx));

}

void TemplateTable::wide_dload() {

  transition(vtos, dtos);

  locals_index_wide(rbx);

  __ movdbl(xmm0, daddress(rbx));

  debug_only(__ verify_local_tag(frame::TagCategory2, rbx));

}

void TemplateTable::wide_aload() {

  transition(vtos, atos);

  locals_index_wide(rbx);

  __ movq(rax, aaddress(rbx));

  debug_only(__ verify_local_tag(frame::TagReference, rbx));

}

void TemplateTable::index_check(Register array, Register index) {

  // destroys rbx

  // check array

  __ null_check(array, arrayOopDesc::length_offset_in_bytes());

  // sign extend index for use by indexed load

  __ movslq(index, index);

  // check index

  __ cmpl(index, Address(array, arrayOopDesc::length_offset_in_bytes()));

  if (index != rbx) {

    // ??? convention: move aberrant index into ebx for exception message

    assert(rbx != array, "different registers");

    __ movl(rbx, index);

  }

  __ jump_cc(Assembler::aboveEqual,

             ExternalAddress(Interpreter::_throw_ArrayIndexOutOfBoundsException_entry));

}

void TemplateTable::iaload() {

  transition(itos, itos);

  __ pop_ptr(rdx);

  // eax: index

  // rdx: array

  index_check(rdx, rax); // kills rbx

  __ movl(rax, Address(rdx, rax,

                       Address::times_4,

                       arrayOopDesc::base_offset_in_bytes(T_INT)));

}

void TemplateTable::laload() {

  transition(itos, ltos);

  __ pop_ptr(rdx);

  // eax: index

  // rdx: array

  index_check(rdx, rax); // kills rbx

  __ movq(rax, Address(rdx, rbx,

                       Address::times_8,