/*

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

#ifndef CC_INTERP

#ifndef FAST_DISPATCH

#define FAST_DISPATCH 1

#endif

#undef FAST_DISPATCH

// Implementation of InterpreterMacroAssembler

// This file specializes the assember with interpreter-specific macros

#else // CC_INTERP

#ifndef STATE

#define STATE(field_name) Lstate, in_bytes(byte_offset_of(BytecodeInterpreter, field_name))

#endif // STATE

#endif // CC_INTERP

void InterpreterMacroAssembler::compute_extra_locals_size_in_bytes(Register args_size, Register locals_size, Register delta) {

  // Note: this algorithm is also used by C1's OSR entry sequence.

  // Any changes should also be applied to CodeEmitter::emit_osr_entry().

  assert_different_registers(args_size, locals_size);

  // max_locals*2 for TAGS.  Assumes that args_size has already been adjusted.

  if (TaggedStackInterpreter) sll(locals_size, 1, locals_size);

  subcc(locals_size, args_size, delta);// extra space for non-arguments locals in words

  // Use br/mov combination because it works on both V8 and V9 and is

  // faster.

  Label skip_move;

  br(Assembler::negative, true, Assembler::pt, skip_move);

  delayed()->mov(G0, delta);

  bind(skip_move);

  round_to(delta, WordsPerLong);       // make multiple of 2 (SP must be 2-word aligned)

  sll(delta, LogBytesPerWord, delta);  // extra space for locals in bytes

}

#ifndef CC_INTERP

// Dispatch code executed in the prolog of a bytecode which does not do it's

// own dispatch. The dispatch address is computed and placed in IdispatchAddress

void InterpreterMacroAssembler::dispatch_prolog(TosState state, int bcp_incr) {

  assert_not_delayed();

#ifdef FAST_DISPATCH

  // FAST_DISPATCH and ProfileInterpreter are mutually exclusive since

  // they both use I2.

  assert(!ProfileInterpreter, "FAST_DISPATCH and +ProfileInterpreter are mutually exclusive");

  ldub(Lbcp, bcp_incr, Lbyte_code);                     // load next bytecode

  add(Lbyte_code, Interpreter::distance_from_dispatch_table(state), Lbyte_code);

                                                        // add offset to correct dispatch table

  sll(Lbyte_code, LogBytesPerWord, Lbyte_code);         // multiply by wordSize

  ld_ptr(IdispatchTables, Lbyte_code, IdispatchAddress);// get entry addr

#else

  // dispatch table to use

#endif

}

// Dispatch code executed in the epilog of a bytecode which does not do it's

// own dispatch. The dispatch address in IdispatchAddress is used for the

// dispatch.

void InterpreterMacroAssembler::dispatch_epilog(TosState state, int bcp_incr) {

  assert_not_delayed();

  verify_FPU(1, state);

  interp_verify_oop(Otos_i, state, __FILE__, __LINE__);

  jmp( IdispatchAddress, 0 );

  if (bcp_incr != 0)  delayed()->inc(Lbcp, bcp_incr);

  else                delayed()->nop();

}

void InterpreterMacroAssembler::dispatch_next(TosState state, int bcp_incr) {

  // %%%% consider branching to a single shared dispatch stub (for each bcp_incr)

  assert_not_delayed();

  ldub( Lbcp, bcp_incr, Lbyte_code);               // load next bytecode

  dispatch_Lbyte_code(state, Interpreter::dispatch_table(state), bcp_incr);

}

void InterpreterMacroAssembler::dispatch_next_noverify_oop(TosState state, int bcp_incr) {

  // %%%% consider branching to a single shared dispatch stub (for each bcp_incr)

  assert_not_delayed();

  ldub( Lbcp, bcp_incr, Lbyte_code);               // load next bytecode

  dispatch_Lbyte_code(state, Interpreter::dispatch_table(state), bcp_incr, false);

}

void InterpreterMacroAssembler::dispatch_via(TosState state, address* table) {

  // load current bytecode

  assert_not_delayed();

  ldub( Lbcp, 0, Lbyte_code);               // load next bytecode

  dispatch_base(state, table);

}

void InterpreterMacroAssembler::call_VM_leaf_base(

  Register java_thread,

  address  entry_point,

  int      number_of_arguments

) {

  if (!java_thread->is_valid())

    java_thread = L7_thread_cache;

  // super call

  MacroAssembler::call_VM_leaf_base(java_thread, entry_point, number_of_arguments);

}

void InterpreterMacroAssembler::call_VM_base(

  Register        oop_result,

  Register        java_thread,

  Register        last_java_sp,

  address         entry_point,

  int             number_of_arguments,

  bool            check_exception

) {

  if (!java_thread->is_valid())

    java_thread = L7_thread_cache;

  // See class ThreadInVMfromInterpreter, which assumes that the interpreter

  // takes responsibility for setting its own thread-state on call-out.

  // However, ThreadInVMfromInterpreter resets the state to "in_Java".

  //save_bcp();                                  // save bcp

  MacroAssembler::call_VM_base(oop_result, java_thread, last_java_sp, entry_point, number_of_arguments, check_exception);

  //restore_bcp();                               // restore bcp

  //restore_locals();                            // restore locals pointer

}

void InterpreterMacroAssembler::check_and_handle_popframe(Register scratch_reg) {

  if (JvmtiExport::can_pop_frame()) {

    Label L;

    // Check the "pending popframe condition" flag in the current thread

    // Initiate popframe handling only if it is not already being processed.  If the flag

    // has the popframe_processing bit set, it means that this code is called *during* popframe

    // handling - we don't want to reenter.

    btst(JavaThread::popframe_pending_bit, scratch_reg);

    br(zero, false, pt, L);

    delayed()->nop();

    btst(JavaThread::popframe_processing_bit, scratch_reg);

    br(notZero, false, pt, L);

    delayed()->nop();

    // Call Interpreter::remove_activation_preserving_args_entry() to get the

    // address of the same-named entrypoint in the generated interpreter code.

    call_VM_leaf(noreg, CAST_FROM_FN_PTR(address, Interpreter::remove_activation_preserving_args_entry));

    // Jump to Interpreter::_remove_activation_preserving_args_entry

    jmpl(O0, G0, G0);

    delayed()->nop();

    bind(L);

  }

}

void InterpreterMacroAssembler::load_earlyret_value(TosState state) {

  Register thr_state = G4_scratch;

  switch (state) {

  case ltos: ld_long(val_addr, Otos_l);                   break;

  case atos: ld_ptr(oop_addr, Otos_l);

             st_ptr(G0, oop_addr);                        break;

  case btos:                                           // fall through

  case ctos:                                           // fall through

  case stos:                                           // fall through

  case itos: ld(val_addr, Otos_l1);                       break;

  case ftos: ldf(FloatRegisterImpl::S, val_addr, Ftos_f); break;

  case dtos: ldf(FloatRegisterImpl::D, val_addr, Ftos_d); break;

  case vtos: /* nothing to do */                          break;

  default  : ShouldNotReachHere();

  }

  // Clean up tos value in the jvmti thread state

  or3(G0, ilgl, G3_scratch);

  stw(G3_scratch, tos_addr);

  st_long(G0, val_addr);

  interp_verify_oop(Otos_i, state, __FILE__, __LINE__);

}

void InterpreterMacroAssembler::check_and_handle_earlyret(Register scratch_reg) {

  if (JvmtiExport::can_force_early_return()) {

    Label L;

    Register thr_state = G3_scratch;

    tst(thr_state);

    br(zero, false, pt, L); // if (thread->jvmti_thread_state() == NULL) exit;

    delayed()->nop();

    // Initiate earlyret handling only if it is not already being processed.

    // If the flag has the earlyret_processing bit set, it means that this code

    // is called *during* earlyret handling - we don't want to reenter.

    cmp(G4_scratch, JvmtiThreadState::earlyret_pending);

    br(Assembler::notEqual, false, pt, L);

    delayed()->nop();

    // Call Interpreter::remove_activation_early_entry() to get the address of the

    // same-named entrypoint in the generated interpreter code

    call_VM_leaf(noreg, CAST_FROM_FN_PTR(address, Interpreter::remove_activation_early_entry), Otos_l1);

    // Jump to Interpreter::_remove_activation_early_entry

    jmpl(O0, G0, G0);

    delayed()->nop();

    bind(L);

  }

}

void InterpreterMacroAssembler::super_call_VM_leaf(Register thread_cache, address entry_point, Register arg_1) {

  mov(arg_1, O0);

  MacroAssembler::call_VM_leaf_base(thread_cache, entry_point, 1);

}

#endif /* CC_INTERP */

#ifndef CC_INTERP

void InterpreterMacroAssembler::dispatch_base(TosState state, address* table) {

  assert_not_delayed();

  dispatch_Lbyte_code(state, table);

}

void InterpreterMacroAssembler::dispatch_normal(TosState state) {

  dispatch_base(state, Interpreter::normal_table(state));

}

void InterpreterMacroAssembler::dispatch_only(TosState state) {

  dispatch_base(state, Interpreter::dispatch_table(state));

}

// common code to dispatch and dispatch_only

// dispatch value in Lbyte_code and increment Lbcp

void InterpreterMacroAssembler::dispatch_Lbyte_code(TosState state, address* table, int bcp_incr, bool verify) {

  verify_FPU(1, state);

  // %%%%% maybe implement +VerifyActivationFrameSize here

  //verify_thread(); //too slow; we will just verify on method entry & exit

  if (verify) interp_verify_oop(Otos_i, state, __FILE__, __LINE__);

#ifdef FAST_DISPATCH

  if (table == Interpreter::dispatch_table(state)) {

    // use IdispatchTables

    add(Lbyte_code, Interpreter::distance_from_dispatch_table(state), Lbyte_code);

                                                        // add offset to correct dispatch table

    sll(Lbyte_code, LogBytesPerWord, Lbyte_code);       // multiply by wordSize

    ld_ptr(IdispatchTables, Lbyte_code, G3_scratch);    // get entry addr

  } else {

#endif

    // dispatch table to use

    sll(Lbyte_code, LogBytesPerWord, Lbyte_code);       // multiply by wordSize

    ld_ptr(G3_scratch, Lbyte_code, G3_scratch);         // get entry addr

#ifdef FAST_DISPATCH

  }

#endif

  jmp( G3_scratch, 0 );

  if (bcp_incr != 0)  delayed()->inc(Lbcp, bcp_incr);

  else                delayed()->nop();

}

// Helpers for expression stack

// Longs and doubles are Category 2 computational types in the

// JVM specification (section 3.11.1) and take 2 expression stack or

// local slots.

// Aligning them on 32 bit with tagged stacks is hard because the code generated

// for the dup* bytecodes depends on what types are already on the stack.

// If the types are split into the two stack/local slots, that is much easier

// (and we can use 0 for non-reference tags).

// Known good alignment in _LP64 but unknown otherwise

void InterpreterMacroAssembler::load_unaligned_double(Register r1, int offset, FloatRegister d) {

  assert_not_delayed();

#ifdef _LP64

  ldf(FloatRegisterImpl::D, r1, offset, d);

#else

  ldf(FloatRegisterImpl::S, r1, offset, d);

  ldf(FloatRegisterImpl::S, r1, offset + Interpreter::stackElementSize(), d->successor());

#endif

}

// Known good alignment in _LP64 but unknown otherwise

void InterpreterMacroAssembler::store_unaligned_double(FloatRegister d, Register r1, int offset) {

  assert_not_delayed();

#ifdef _LP64

  stf(FloatRegisterImpl::D, d, r1, offset);

  // store something more useful here

  debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)

#else

  stf(FloatRegisterImpl::S, d, r1, offset);

  stf(FloatRegisterImpl::S, d->successor(), r1, offset + Interpreter::stackElementSize());

#endif

}

// Known good alignment in _LP64 but unknown otherwise

void InterpreterMacroAssembler::load_unaligned_long(Register r1, int offset, Register rd) {

  assert_not_delayed();

#ifdef _LP64

  ldx(r1, offset, rd);

#else

  ld(r1, offset, rd);

  ld(r1, offset + Interpreter::stackElementSize(), rd->successor());

#endif

}

// Known good alignment in _LP64 but unknown otherwise

void InterpreterMacroAssembler::store_unaligned_long(Register l, Register r1, int offset) {

  assert_not_delayed();

#ifdef _LP64

  stx(l, r1, offset);

  // store something more useful here

  debug_only(stx(G0, r1, offset+Interpreter::stackElementSize());)

#else

  st(l, r1, offset);

  st(l->successor(), r1, offset + Interpreter::stackElementSize());

#endif

}

#ifdef ASSERT

void InterpreterMacroAssembler::verify_stack_tag(frame::Tag t,

                                                 Register r,

                                                 Register scratch) {

  if (TaggedStackInterpreter) {

    Label ok, long_ok;

    ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(0), r);

    if (t == frame::TagCategory2) {

      cmp(r, G0);

      brx(Assembler::equal, false, Assembler::pt, long_ok);

      delayed()->ld_ptr(Lesp, Interpreter::expr_tag_offset_in_bytes(1), r);

      stop("stack long/double tag value bad");

      bind(long_ok);

      cmp(r, G0);

    } else if (t == frame::TagValue) {

      cmp(r, G0);

    } else {

      assert_different_registers(r, scratch);

      mov(t, scratch);

      cmp(r, scratch);

    }

    brx(Assembler::equal, false, Assembler::pt, ok);

    delayed()->nop();

    // Also compare if the stack value is zero, then the tag might

    // not have been set coming from deopt.

    ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);

    cmp(r, G0);

    brx(Assembler::equal, false, Assembler::pt, ok);

    delayed()->nop();

    stop("Stack tag value is bad");

    bind(ok);

  }

}

#endif // ASSERT

void InterpreterMacroAssembler::pop_i(Register r) {

  assert_not_delayed();

  // Uses destination register r for scratch

  debug_only(verify_stack_tag(frame::TagValue, r));

  ld(Lesp, Interpreter::expr_offset_in_bytes(0), r);

  inc(Lesp, Interpreter::stackElementSize());

  debug_only(verify_esp(Lesp));

}

void InterpreterMacroAssembler::pop_ptr(Register r, Register scratch) {

  assert_not_delayed();

  // Uses destination register r for scratch

  debug_only(verify_stack_tag(frame::TagReference, r, scratch));

  ld_ptr(Lesp, Interpreter::expr_offset_in_bytes(0), r);

  inc(Lesp, Interpreter::stackElementSize());

  debug_only(verify_esp(Lesp));

}

void InterpreterMacroAssembler::pop_l(Register r) {

  assert_not_delayed();

  // Uses destination register r for scratch

  debug_only(verify_stack_tag(frame::TagCategory2, r));

  load_unaligned_long(Lesp, Interpreter::expr_offset_in_bytes(0), r);

  inc(Lesp, 2*Interpreter::stackElementSize());

  debug_only(verify_esp(Lesp));

}

void InterpreterMacroAssembler::pop_f(FloatRegister f, Register scratch) {

  assert_not_delayed();

  debug_only(verify_stack_tag(frame::TagValue, scratch));

  ldf(FloatRegisterImpl::S, Lesp, Interpreter::expr_offset_in_bytes(0), f);

  inc(Lesp, Interpreter::stackElementSize());

  debug_only(verify_esp(Lesp));

}

void InterpreterMacroAssembler::pop_d(FloatRegister f, Register scratch) {

  assert_not_delayed();

  debug_only(verify_stack_tag(frame::TagCategory2, scratch));

  load_unaligned_double(Lesp, Interpreter::expr_offset_in_bytes(0), f);

  inc(Lesp, 2*Interpreter::stackElementSize());

  debug_only(verify_esp(Lesp));

}

// (Note use register first, then decrement so dec can be done during store stall)

void InterpreterMacroAssembler::tag_stack(Register r) {

  if (TaggedStackInterpreter) {

    st_ptr(r, Lesp, Interpreter::tag_offset_in_bytes());

  }

}

void InterpreterMacroAssembler::tag_stack(frame::Tag t, Register r) {

  if (TaggedStackInterpreter) {

    assert (frame::TagValue == 0, "TagValue must be zero");

    if (t == frame::TagValue) {

      st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());

    } else if (t == frame::TagCategory2) {

      st_ptr(G0, Lesp, Interpreter::tag_offset_in_bytes());

      // Tag next slot down too

      st_ptr(G0, Lesp, -Interpreter::stackElementSize() + Interpreter::tag_offset_in_bytes());

    } else {

      assert_different_registers(r, O3);

      mov(t, O3);

      st_ptr(O3, Lesp, Interpreter::tag_offset_in_bytes());

    }

  }

}

void InterpreterMacroAssembler::push_i(Register r) {

  assert_not_delayed();

  debug_only(verify_esp(Lesp));

  tag_stack(frame::TagValue, r);

  st(  r,    Lesp, Interpreter::value_offset_in_bytes());

  dec( Lesp, Interpreter::stackElementSize());

}

void InterpreterMacroAssembler::push_ptr(Register r) {

  assert_not_delayed();

  tag_stack(frame::TagReference, r);

  st_ptr(  r,    Lesp, Interpreter::value_offset_in_bytes());

  dec( Lesp, Interpreter::stackElementSize());

}

void InterpreterMacroAssembler::push_ptr(Register r, Register tag) {

  assert_not_delayed();

  tag_stack(tag);

  st_ptr(r, Lesp, Interpreter::value_offset_in_bytes());

  dec( Lesp, Interpreter::stackElementSize());

}

// remember: our convention for longs in SPARC is:

// O0 (Otos_l1) has high-order part in first word,

// O1 (Otos_l2) has low-order part in second word

void InterpreterMacroAssembler::push_l(Register r) {

  assert_not_delayed();

  debug_only(verify_esp(Lesp));

  tag_stack(frame::TagCategory2, r);

  // Longs are in stored in memory-correct order, even if unaligned.

  // and may be separated by stack tags.

  int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();

  store_unaligned_long(r, Lesp, offset);

  dec(Lesp, 2 * Interpreter::stackElementSize());

}

void InterpreterMacroAssembler::push_f(FloatRegister f) {

  assert_not_delayed();

  debug_only(verify_esp(Lesp));

  tag_stack(frame::TagValue, Otos_i);

  stf(FloatRegisterImpl::S, f, Lesp, Interpreter::value_offset_in_bytes());

  dec(Lesp, Interpreter::stackElementSize());

}

void InterpreterMacroAssembler::push_d(FloatRegister d)   {

  assert_not_delayed();

  debug_only(verify_esp(Lesp));

  tag_stack(frame::TagCategory2, Otos_i);

  // Longs are in stored in memory-correct order, even if unaligned.

  // and may be separated by stack tags.

  int offset = -Interpreter::stackElementSize() + Interpreter::value_offset_in_bytes();

  store_unaligned_double(d, Lesp, offset);

  dec(Lesp, 2 * Interpreter::stackElementSize());

}