/*

 * Copyright 1997-2008 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/_templateInterpreter_sparc.cpp.incl"

#ifndef CC_INTERP

#ifndef FAST_DISPATCH

#define FAST_DISPATCH 1

#endif

#undef FAST_DISPATCH

// Generation of Interpreter

//

// The InterpreterGenerator generates the interpreter into Interpreter::_code.

#define __ _masm->

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

void InterpreterGenerator::save_native_result(void) {

  // result potentially in O0/O1: save it across calls

  const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

  // result potentially in F0/F1: save it across calls

  const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

  // save and restore any potential method result value around the unlocking operation

  __ stf(FloatRegisterImpl::D, F0, d_tmp);

#ifdef _LP64

  __ stx(O0, l_tmp);

#else

  __ std(O0, l_tmp);

#endif

}

void InterpreterGenerator::restore_native_result(void) {

  const Address& l_tmp = InterpreterMacroAssembler::l_tmp;

  const Address& d_tmp = InterpreterMacroAssembler::d_tmp;

  // Restore any method result value

  __ ldf(FloatRegisterImpl::D, d_tmp, F0);

#ifdef _LP64

  __ ldx(l_tmp, O0);

#else

  __ ldd(l_tmp, O0);

#endif

}

address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) {

  assert(!pass_oop || message == NULL, "either oop or message but not both");

  address entry = __ pc();

  // expression stack must be empty before entering the VM if an exception happened

  __ empty_expression_stack();

  // load exception object

  __ set((intptr_t)name, G3_scratch);

  if (pass_oop) {

    __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), G3_scratch, Otos_i);

  } else {

    __ set((intptr_t)message, G4_scratch);

    __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), G3_scratch, G4_scratch);

  }

  // throw exception

  assert(Interpreter::throw_exception_entry() != NULL, "generate it first");

  Address thrower(G3_scratch, Interpreter::throw_exception_entry());

  __ jump_to (thrower);

  __ delayed()->nop();

  return entry;

}

address TemplateInterpreterGenerator::generate_ClassCastException_handler() {

  address entry = __ pc();

  // expression stack must be empty before entering the VM if an exception

  // happened

  __ empty_expression_stack();

  // load exception object

  __ call_VM(Oexception,

             CAST_FROM_FN_PTR(address,

                              InterpreterRuntime::throw_ClassCastException),

             Otos_i);

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler(const char* name) {

  address entry = __ pc();

  // expression stack must be empty before entering the VM if an exception happened

  __ empty_expression_stack();

  // convention: expect aberrant index in register G3_scratch, then shuffle the

  // index to G4_scratch for the VM call

  __ mov(G3_scratch, G4_scratch);

  __ set((intptr_t)name, G3_scratch);

  __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), G3_scratch, G4_scratch);

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {

  address entry = __ pc();

  // expression stack must be empty before entering the VM if an exception happened

  __ empty_expression_stack();

  __ call_VM(Oexception, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));

  __ should_not_reach_here();

  return entry;

}

address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step) {

  address compiled_entry = __ pc();

  Label cont;

  address entry = __ pc();

#if !defined(_LP64) && defined(COMPILER2)

  // All return values are where we want them, except for Longs.  C2 returns

  // longs in G1 in the 32-bit build whereas the interpreter wants them in O0/O1.

  // Since the interpreter will return longs in G1 and O0/O1 in the 32bit

  // build even if we are returning from interpreted we just do a little

  // stupid shuffing.

  // Note: I tried to make c2 return longs in O0/O1 and G1 so we wouldn't have to

  // do this here. Unfortunately if we did a rethrow we'd see an machepilog node

  // first which would move g1 -> O0/O1 and destroy the exception we were throwing.

  if( state == ltos ) {

    __ srl (G1, 0,O1);

    __ srlx(G1,32,O0);

  }

#endif /* !_LP64 && COMPILER2 */

  __ bind(cont);

  // The callee returns with the stack possibly adjusted by adapter transition

  // We remove that possible adjustment here.

  // All interpreter local registers are untouched. Any result is passed back

  // in the O0/O1 or float registers. Before continuing, the arguments must be

  // popped from the java expression stack; i.e., Lesp must be adjusted.

  __ mov(Llast_SP, SP);   // Remove any adapter added stack space.

  const Register cache = G3_scratch;

  const Register size  = G1_scratch;

  __ get_cache_and_index_at_bcp(cache, G1_scratch, 1);

  __ ld_ptr(Address(cache, 0, in_bytes(constantPoolCacheOopDesc::base_offset()) +

                    in_bytes(ConstantPoolCacheEntry::flags_offset())), size);

  __ and3(size, 0xFF, size);                   // argument size in words

  __ sll(size, Interpreter::logStackElementSize(), size); // each argument size in bytes

  __ add(Lesp, size, Lesp);                    // pop arguments

  __ dispatch_next(state, step);

  return entry;

}

address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) {

  address entry = __ pc();

  __ get_constant_pool_cache(LcpoolCache); // load LcpoolCache

  { Label L;

    Address exception_addr (G2_thread, 0, in_bytes(Thread::pending_exception_offset()));

    __ ld_ptr(exception_addr, Gtemp);

    __ tst(Gtemp);

    __ brx(Assembler::equal, false, Assembler::pt, L);

    __ delayed()->nop();

    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception));

    __ should_not_reach_here();

    __ bind(L);

  }

  __ dispatch_next(state, step);

  return entry;

}

// A result handler converts/unboxes a native call result into

// a java interpreter/compiler result. The current frame is an

// interpreter frame. The activation frame unwind code must be

// consistent with that of TemplateTable::_return(...). In the

// case of native methods, the caller's SP was not modified.

address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) {

  address entry = __ pc();

  Register Itos_i  = Otos_i ->after_save();

  Register Itos_l  = Otos_l ->after_save();

  Register Itos_l1 = Otos_l1->after_save();

  Register Itos_l2 = Otos_l2->after_save();

  switch (type) {

    case T_BOOLEAN: __ subcc(G0, O0, G0); __ addc(G0, 0, Itos_i); break; // !0 => true; 0 => false

    case T_CHAR   : __ sll(O0, 16, O0); __ srl(O0, 16, Itos_i);   break; // cannot use and3, 0xFFFF too big as immediate value!

    case T_BYTE   : __ sll(O0, 24, O0); __ sra(O0, 24, Itos_i);   break;

    case T_SHORT  : __ sll(O0, 16, O0); __ sra(O0, 16, Itos_i);   break;

    case T_LONG   :

#ifndef _LP64

                    __ mov(O1, Itos_l2);  // move other half of long

#endif              // ifdef or no ifdef, fall through to the T_INT case

    case T_INT    : __ mov(O0, Itos_i);                         break;

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

    case T_FLOAT  : assert(F0 == Ftos_f, "fix this code" );     break;

    case T_DOUBLE : assert(F0 == Ftos_d, "fix this code" );     break;

    case T_OBJECT :

      __ ld_ptr(FP, (frame::interpreter_frame_oop_temp_offset*wordSize) + STACK_BIAS, Itos_i);

      __ verify_oop(Itos_i);

      break;

    default       : ShouldNotReachHere();

  }

  __ ret();                           // return from interpreter activation

  __ delayed()->restore(I5_savedSP, G0, SP);  // remove interpreter frame

  NOT_PRODUCT(__ emit_long(0);)       // marker for disassembly

  return entry;

}

address TemplateInterpreterGenerator::generate_safept_entry_for(TosState state, address runtime_entry) {

  address entry = __ pc();

  __ push(state);

  __ call_VM(noreg, runtime_entry);

  __ dispatch_via(vtos, Interpreter::normal_table(vtos));

  return entry;

}

address TemplateInterpreterGenerator::generate_continuation_for(TosState state) {

  address entry = __ pc();

  __ dispatch_next(state);

  return entry;

}

//

// Helpers for commoning out cases in the various type of method entries.

//

// increment invocation count & check for overflow

//

// Note: checking for negative value instead of overflow

//       so we have a 'sticky' overflow test

//

// Lmethod: method

// ??: invocation counter

//

void InterpreterGenerator::generate_counter_incr(Label* overflow, Label* profile_method, Label* profile_method_continue) {

  // Update standard invocation counters

  __ increment_invocation_counter(O0, G3_scratch);

  if (ProfileInterpreter) {  // %%% Merge this into methodDataOop

    Address interpreter_invocation_counter(Lmethod, 0, in_bytes(methodOopDesc::interpreter_invocation_counter_offset()));

    __ ld(interpreter_invocation_counter, G3_scratch);

    __ inc(G3_scratch);

    __ st(G3_scratch, interpreter_invocation_counter);

  }

  if (ProfileInterpreter && profile_method != NULL) {

    // Test to see if we should create a method data oop

    Address profile_limit(G3_scratch, (address)&InvocationCounter::InterpreterProfileLimit);

    __ sethi(profile_limit);

    __ ld(profile_limit, G3_scratch);

    __ cmp(O0, G3_scratch);

    __ br(Assembler::lessUnsigned, false, Assembler::pn, *profile_method_continue);

    __ delayed()->nop();

    // if no method data exists, go to profile_method

    __ test_method_data_pointer(*profile_method);

  }

  Address invocation_limit(G3_scratch, (address)&InvocationCounter::InterpreterInvocationLimit);

  __ sethi(invocation_limit);

  __ ld(invocation_limit, G3_scratch);

  __ cmp(O0, G3_scratch);

  __ br(Assembler::greaterEqualUnsigned, false, Assembler::pn, *overflow);

  __ delayed()->nop();

}

// Allocate monitor and lock method (asm interpreter)

// ebx - methodOop

//

void InterpreterGenerator::lock_method(void) {

  const Address access_flags      (Lmethod, 0, in_bytes(methodOopDesc::access_flags_offset()));

  __ ld(access_flags, O0);

#ifdef ASSERT

 { Label ok;

   __ btst(JVM_ACC_SYNCHRONIZED, O0);

   __ br( Assembler::notZero, false, Assembler::pt, ok);

   __ delayed()->nop();

   __ stop("method doesn't need synchronization");

   __ bind(ok);

  }

#endif // ASSERT

  // get synchronization object to O0

  { Label done;

    const int mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes();

    __ btst(JVM_ACC_STATIC, O0);

    __ br( Assembler::zero, true, Assembler::pt, done);

    __ delayed()->ld_ptr(Llocals, Interpreter::local_offset_in_bytes(0), O0); // get receiver for not-static case

    __ ld_ptr( Lmethod, in_bytes(methodOopDesc::constants_offset()), O0);

    __ ld_ptr( O0, constantPoolOopDesc::pool_holder_offset_in_bytes(), O0);

    // lock the mirror, not the klassOop

    __ ld_ptr( O0, mirror_offset, O0);

#ifdef ASSERT

    __ tst(O0);

    __ breakpoint_trap(Assembler::zero);

#endif // ASSERT

    __ bind(done);

  }

  __ add_monitor_to_stack(true, noreg, noreg);  // allocate monitor elem

  __ st_ptr( O0, Lmonitors, BasicObjectLock::obj_offset_in_bytes());   // store object

  // __ untested("lock_object from method entry");

  __ lock_object(Lmonitors, O0);

}

void TemplateInterpreterGenerator::generate_stack_overflow_check(Register Rframe_size,

                                                         Register Rscratch,

                                                         Register Rscratch2) {

  const int page_size = os::vm_page_size();

  Address saved_exception_pc(G2_thread, 0,

                             in_bytes(JavaThread::saved_exception_pc_offset()));

  Label after_frame_check;

  assert_different_registers(Rframe_size, Rscratch, Rscratch2);

  __ set( page_size,   Rscratch );

  __ cmp( Rframe_size, Rscratch );

  __ br( Assembler::lessEqual, false, Assembler::pt, after_frame_check );

  __ delayed()->nop();

  // get the stack base, and in debug, verify it is non-zero

  __ ld_ptr( G2_thread, in_bytes(Thread::stack_base_offset()), Rscratch );

#ifdef ASSERT

  Label base_not_zero;

  __ cmp( Rscratch, G0 );

  __ brx( Assembler::notEqual, false, Assembler::pn, base_not_zero );

  __ delayed()->nop();

  __ stop("stack base is zero in generate_stack_overflow_check");

  __ bind(base_not_zero);

#endif

  // get the stack size, and in debug, verify it is non-zero

  assert( sizeof(size_t) == sizeof(intptr_t), "wrong load size" );

  __ ld_ptr( G2_thread, in_bytes(Thread::stack_size_offset()), Rscratch2 );

#ifdef ASSERT

  Label size_not_zero;

  __ cmp( Rscratch2, G0 );

  __ brx( Assembler::notEqual, false, Assembler::pn, size_not_zero );

  __ delayed()->nop();

  __ stop("stack size is zero in generate_stack_overflow_check");

  __ bind(size_not_zero);

#endif

  // compute the beginning of the protected zone minus the requested frame size

  __ sub( Rscratch, Rscratch2,   Rscratch );

  __ set( (StackRedPages+StackYellowPages) * page_size, Rscratch2 );

  __ add( Rscratch, Rscratch2,   Rscratch );

  // Add in the size of the frame (which is the same as subtracting it from the

  // SP, which would take another register

  __ add( Rscratch, Rframe_size, Rscratch );

  // the frame is greater than one page in size, so check against

  // the bottom of the stack

  __ cmp( SP, Rscratch );

  __ brx( Assembler::greater, false, Assembler::pt, after_frame_check );

  __ delayed()->nop();

  // Save the return address as the exception pc

  __ st_ptr(O7, saved_exception_pc);

  // the stack will overflow, throw an exception

  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));

  // if you get to here, then there is enough stack space

  __ bind( after_frame_check );

}

//

// Generate a fixed interpreter frame. This is identical setup for interpreted

// methods and for native methods hence the shared code.

void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {

  //

  //

  // The entry code sets up a new interpreter frame in 4 steps:

  //

  // 1) Increase caller's SP by for the extra local space needed:

  //    (check for overflow)

  //    Efficient implementation of xload/xstore bytecodes requires

  //    that arguments and non-argument locals are in a contigously

  //    addressable memory block => non-argument locals must be

  //    allocated in the caller's frame.

  //

  // 2) Create a new stack frame and register window:

  //    The new stack frame must provide space for the standard

  //    register save area, the maximum java expression stack size,

  //    the monitor slots (0 slots initially), and some frame local

  //    scratch locations.

  //

  // 3) The following interpreter activation registers must be setup:

  //    Lesp       : expression stack pointer

  //    Lbcp       : bytecode pointer

  //    Lmethod    : method

  //    Llocals    : locals pointer

  //    Lmonitors  : monitor pointer

  //    LcpoolCache: constant pool cache

  //

  // 4) Initialize the non-argument locals if necessary:

  //    Non-argument locals may need to be initialized to NULL

  //    for GC to work. If the oop-map information is accurate

  //    (in the absence of the JSR problem), no initialization

  //    is necessary.

  //

  // (gri - 2/25/2000)

  const Address size_of_parameters(G5_method, 0, in_bytes(methodOopDesc::size_of_parameters_offset()));

  const Address size_of_locals    (G5_method, 0, in_bytes(methodOopDesc::size_of_locals_offset()));

  const Address max_stack         (G5_method, 0, in_bytes(methodOopDesc::max_stack_offset()));

  int rounded_vm_local_words = round_to( frame::interpreter_frame_vm_local_words, WordsPerLong );

  const int extra_space =

    rounded_vm_local_words +                   // frame local scratch space

    frame::memory_parameter_word_sp_offset +   // register save area

    (native_call ? frame::interpreter_frame_extra_outgoing_argument_words : 0);

  const Register Glocals_size = G3;

  const Register Otmp1 = O3;

  const Register Otmp2 = O4;

  // Lscratch can't be used as a temporary because the call_stub uses

  // it to assert that the stack frame was setup correctly.

  __ lduh( size_of_parameters, Glocals_size);

  // Gargs points to first local + BytesPerWord

  // Set the saved SP after the register window save

  //

  assert_different_registers(Gargs, Glocals_size, Gframe_size, O5_savedSP);

  __ sll(Glocals_size, Interpreter::logStackElementSize(), Otmp1);

  __ add(Gargs, Otmp1, Gargs);

  if (native_call) {

    __ calc_mem_param_words( Glocals_size, Gframe_size );

    __ add( Gframe_size,  extra_space, Gframe_size);

    __ round_to( Gframe_size, WordsPerLong );

    __ sll( Gframe_size, LogBytesPerWord, Gframe_size );

  } else {

    //

    // Compute number of locals in method apart from incoming parameters

    //

    __ lduh( size_of_locals, Otmp1 );

    __ sub( Otmp1, Glocals_size, Glocals_size );

    __ round_to( Glocals_size, WordsPerLong );

    __ sll( Glocals_size, Interpreter::logStackElementSize(), Glocals_size );

    // see if the frame is greater than one page in size. If so,

    // then we need to verify there is enough stack space remaining

    // Frame_size = (max_stack + extra_space) * BytesPerWord;

    __ lduh( max_stack, Gframe_size );

    __ add( Gframe_size, extra_space, Gframe_size );

    __ round_to( Gframe_size, WordsPerLong );

    __ sll( Gframe_size, Interpreter::logStackElementSize(), Gframe_size);

    // Add in java locals size for stack overflow check only

    __ add( Gframe_size, Glocals_size, Gframe_size );

    const Register Otmp2 = O4;

    assert_different_registers(Otmp1, Otmp2, O5_savedSP);

    generate_stack_overflow_check(Gframe_size, Otmp1, Otmp2);

    __ sub( Gframe_size, Glocals_size, Gframe_size);

    //

    // bump SP to accomodate the extra locals

    //

    __ sub( SP, Glocals_size, SP );

  }

  //

  // now set up a stack frame with the size computed above

  //

  __ neg( Gframe_size );

  __ save( SP, Gframe_size, SP );

  //

  // now set up all the local cache registers

  //

  // NOTE: At this point, Lbyte_code/Lscratch has been modified. Note

  // that all present references to Lbyte_code initialize the register

  // immediately before use

  if (native_call) {

    __ mov(G0, Lbcp);

  } else {

    __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::const_offset())), Lbcp );

    __ add(Address(Lbcp, 0, in_bytes(constMethodOopDesc::codes_offset())), Lbcp );

  }

  __ mov( G5_method, Lmethod);                 // set Lmethod

  __ get_constant_pool_cache( LcpoolCache );   // set LcpoolCache

  __ sub(FP, rounded_vm_local_words * BytesPerWord, Lmonitors ); // set Lmonitors

#ifdef _LP64